widgets.h

Go to the documentation of this file.

//**************************************************************************/
// Copyright (c) 2008 Autodesk, Inc.
// All rights reserved.
//
// Use of this software is subject to the terms of the Autodesk license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
//
//**************************************************************************/ 
// DESCRIPTION:
// CREATED: October 2008
//**************************************************************************/
                       
#ifndef __MUDBOXSDK_WIDGETS_H__
#define __MUDBOXSDK_WIDGETS_H__
#pragma once
                                       
// In order to create custom gui for your plugins, you need to install the Qt library. 
// Classes in this file are valid only when Qt is properly installed
           
#include <QtCore/QObject>
#include <QtCore/QFileInfo>
#include <QtCore/QMap>
#include <QtCore/QSignalMapper>
#include <QtGui/QWidget>
#include <QtGui/QLabel>
#include <QtGui/QLineEdit>
#include <QtGui/QCheckBox>
#include <QtGui/QPushButton>
#include <QtGui/QSlider>
#include <QtGui/QMouseEvent>
#include <QtGui/QSpinBox>
#include <QtGui/QComboBox>
#include <QtGui/QGroupBox>
#include <QtGui/QFrame>
#include <QtGui/QToolButton>
#include <QtGui/QHBoxLayout>
#include <QtGui/QGridLayout>
#include <QtGui/QButtonGroup>
#include <QtGui/QTabBar>
#include <QtGui/QDialog>
#include <QtCore/QTimer>

#if defined(JAMBUILD)
#include <Mudbox/mudbox.h>
#else
#include "mudbox.h"
#endif            

#define CPBOX_WIDTH 6
// max # of curve points. Matches the limit in the Curve class defined in Maths.h which may be used as an alternate to NURBS
// curve sometimes. 
#define MAX_CURVE_POINTS 64 


namespace mudbox
{
    class MBDLL_DECL MirrorComboBox : public QComboBox
    {
        Q_OBJECT
    public:
        MirrorComboBox(QWidget * parent = 0, const char * name = 0)
        :QComboBox(parent){ setObjectName(name); }
        
        ~MirrorComboBox(){}
        
    signals:
        void departed(int);

        // This signal is emitted when the popup list is closed.
        void popupClosed(int);
        
    protected:
        void focusOutEvent ( QFocusEvent * )
        {
            emit departed(0);
        }

        void hidePopup()
        {
            emit popupClosed(0);
            QComboBox::hidePopup();
        };
    };
    

    class MBDLL_DECL AttributeSign : public QLabel
    {
        Q_OBJECT
        class AttributeWidget *m_pOwner;
        void mousePressEvent( QMouseEvent *pEvent );
        void dragEnterEvent( QDragEnterEvent *pEvent );
        void dropEvent( QDropEvent *pEvent );
        void SetImage( const QString &sFileName );

    public:
        AttributeSign( class AttributeWidget *pOwner );
        void UpdateImage( void );
    };

    class MBDLL_DECL AttributeWidget : public QWidget, public Node
    {
        Attribute *m_pAttribute;
        Node *m_pNode;
        int m_iNodeID;
        AttributeWatch m_cWatcher;
        QSize sizeHint( void ) const;
        bool m_bDestructed; // HACK

    protected:
        void OnNodeEvent( const Attribute &cAttribute, NodeEventType eType );
        QLabel m_cLabel;
        QHBoxLayout m_cMainLayout, *m_pValueLayout, *m_pValueStretchLayout;
        QWidget m_cValue;
        float m_fLabelWidth;
        int m_iHeight;
        bool m_bLeftAlignedName;

    public:
        AttributeWidget( QWidget *pParent, int iWidth, Attribute *pAttribute );
        ~AttributeWidget( void );
        bool Validate( void );
        virtual void Update( void ) {};
        virtual void MoveValue( int /*iStart*/, int /*iEnd*/ ) {};
        virtual void MoveContent( int iStart, int iEnd, bool bVisibleValue );
        virtual void ChangeWidth( int iWidth, bool bVisibleValue );
        inline Attribute *GetAttribute( void ) const { return m_pAttribute; };
        inline Node *GetNode( void ) const { return m_pNode; };
    };

    class MBDLL_DECL AttributeVectorbox : public AttributeWidget
    {
        Q_OBJECT

    protected:
        void Update( void );
        QLineEdit m_cXBox, m_cYBox, m_cZBox;

    public:
        AttributeVectorbox( QWidget *pParent, int iWidth, avector *pAttribute );

    public slots:
        void OnChange( void );
    };

    class MBDLL_DECL AttributeVector4box : public AttributeWidget
    {
        Q_OBJECT

    protected:
        void Update( void );
        QLineEdit m_cXBox, m_cYBox, m_cZBox, m_cWBox;

    public:
        AttributeVector4box( QWidget *pParent, int iWidth, avector4 *pAttribute );

        public slots:
            void OnChange( void );
    };

    class MBDLL_DECL AttributeEditbox : public AttributeWidget
    {
        Q_OBJECT

    protected:
        void Update( void );
        QLineEdit m_cEditbox;
        QLabel m_cValueLabel;

    public:
        AttributeEditbox( QWidget *pParent, int iWidth, Attribute *pAttribute );

    public slots:
        void OnChange( void );
        void OnEditFinished( void );
    };

    class MBDLL_DECL AttributeImagebox : public AttributeWidget
    {
        Q_OBJECT
        void MoveValue( int iStart, int iEnd );
        void Update( void );
        void OnNodeEvent( const Attribute &cAttribute, NodeEventType eType );

        unsigned int m_iWidth;

    protected:
        QLabel m_cLabel;

    public:
        AttributeImagebox( QWidget *pParent, int iWidth, AttributePointer<Image> *pImage );
    };

    class MBDLL_DECL AttributeCheckbox : public AttributeWidget
    {
        Q_OBJECT
        bool m_bLock;
        void Update( void );

    protected:
        QCheckBox m_cCheckbox;

    public:
        AttributeCheckbox( QWidget *pParent, int iWidth, abool *pAttribute );

    public slots:
        void OnChange( int iState );
    };

    class MBDLL_DECL AttributeColorbox : public AttributeWidget
    {
        Q_OBJECT

    protected:
        void Update( void );

    public:
        AttributeColorbox( QWidget *pParent, int iWidth, acolor *pAttribute );

    public slots:
        void OnAboutToShowChooser(QColor* color);
        void OnColorChanged(const QColor&);

    public:
        static QWidget* CreateColorButton(const QColor& color, QWidget* parent, Attribute *pAttribute);
    };

    class MBDLL_DECL AttributeSliderbox : public AttributeEditbox
    {
        class Slider : public QSlider
        {
            void mouseDoubleClickEvent( QMouseEvent *pEvent )
            {
                if ( m_pOwner )
                {
                    afloatr* pA = (afloatr *)m_pOwner->GetAttribute();
                    if ( pEvent->button() == Qt::LeftButton )
                        pA->SetMax( pA->Value() );
                    if ( pEvent->button() == Qt::RightButton )
                        pA->SetMin( pA->Value() );
                    setValue( (int)(1000*(pA->Value()-pA->Min())/(pA->Max()-pA->Min())) );
                };
            };
        public:
            Slider( QWidget *pParent ) : QSlider( pParent ) { m_pOwner = 0; };
            AttributeSliderbox *m_pOwner;
        };
        Q_OBJECT
        bool m_bLock, m_bSliderLock;

    protected:
        void Update( void );
        Slider m_cSlider;

    public:
        AttributeSliderbox( QWidget *pParent, int iWidth, afloatr *pAttribute );

    public slots:
        void OnMove( int );
    };

    class MBDLL_DECL AttributeSpinbox : public AttributeWidget
    {
        struct SpinBox : public QSpinBox
        {
            SpinBox( QWidget *pParent, int iDigitCount ) : QSpinBox( pParent )
            {
                m_iDigitCount = iDigitCount;
            };
        private:
            QString textFromValue ( int v ) const
            {
                QString s = QString::number( v );
                while ( s.length() < m_iDigitCount )
                    s = "0"+s;
                return s;
            };
            int m_iDigitCount;
        };
        Q_OBJECT

    protected:
        SpinBox m_cSpin;
        bool m_bLock;
        void Update( void );

    public:
        AttributeSpinbox( QWidget *pParent, int iWidth, aint *pAttribute, int iSpinWidth = 40, int iDigitCount = 1 );

    public slots:
        void OnChange( int );
    };

    class MBDLL_DECL AttributeCombobox : public AttributeWidget
    {
        Q_OBJECT
        bool m_bLock;

    protected:
        void Update( void );
        MirrorComboBox m_cCombo;
        QTabBar *m_cTabBar;
        QWidget *m_pButtonFrame;

    public:
        AttributeCombobox( QWidget *pParent, int iWidth, aenum *pAttribute );

    public slots:
        void OnActivate( int ); 
        void OnFinished( int ); 
    };

    class MBDLL_DECL AttributeComboboxMap : public AttributeWidget
    {
        Q_OBJECT

    protected:
        QComboBox m_cCombo;

    public:
        AttributeComboboxMap( QWidget* pParent, int iWidth, astring* pAttribute, const QMap<QString, QString>& pMap );

    protected:
        void Update(const QMap<QString, QString>&);
        static void Update(QComboBox* cComboBox, const QMap<QString, QString>& pMap, const QString& sSelected);

    public slots:
        void OnActivate( int );
    };

    class MBDLL_DECL AttributeFilenamebox : public AttributeEditbox
    {
        Q_OBJECT

    protected:
        QPushButton m_cBrowseButton;

    public:
        AttributeFilenamebox( QWidget *pParent, int iWidth, afilename *pAttribute );

    public slots:
        void OnBrowse( void );
        void OnEdit( void );
    };

    class MBDLL_DECL AttributeTextureFilenamebox : public AttributeFilenamebox
    {
        Q_OBJECT

    public:
        AttributeTextureFilenamebox( QWidget *pParent, int iWidth, afilename *pAttribute );

    public slots:
        void OnMenu( void );
        void OnSave( void );
    };

    class MBDLL_DECL AttributeEventbox : public AttributeWidget
    {
        Q_OBJECT

    protected:
        QPushButton m_cButton;

    public:
        AttributeEventbox( QWidget *pParent, int iWidth, EventGate *pAttribute );

    public slots:
        void OnAction( void );
    };

    class MBDLL_DECL AttributePointerbox : public AttributeWidget
    {
        Q_OBJECT
        bool m_bLock;
        bool m_bNullStringInserted;

    protected: QComboBox m_cCombo; const ClassDesc *m_pType; void Update( void );
    public: AttributePointerbox( QWidget *pParent, int iWidth, Attribute *pAttribute, const ClassDesc *pClass );
    public slots: void OnChange( int );
    };

    class MBDLL_DECL AttributeCheckboxCollection : public AttributeWidget
    {
        Q_OBJECT
        QCheckBox *m_aCheckboxes[32];
        QWidget m_cValues;
        void Update( void );

    public:
        AttributeCheckboxCollection( QWidget *pParent, int iWidth, aboolc *pAttribute );

    public slots:
        void OnChange( int iState );
    };

    class MBDLL_DECL AttributeSliderWithCheckbox : public AttributeWidget
    {
        Q_OBJECT
        bool m_bLock;
        void Update( void );

    protected:
        QLabel *m_pLabel;
        QSlider *m_pSlider;
        QLineEdit *m_pEditBox;
        QGroupBox m_cGroupBox;

    public:
        AttributeSliderWithCheckbox( QWidget *pParent, int iWidth, acheckablefloat *pAttribute );

    public slots:
        void OnChange( void );
    };

    class MBDLL_DECL AttributeSliderArrayWithCheckbox : public AttributeWidget
    {
        Q_OBJECT
        bool m_bLock;
        void Update( void );

    protected:
        QVector<QLabel *> m_aLabel;
        QVector<QLineEdit *> m_aEditBox;
        QVector<QSlider *> m_aSlider;
        QGroupBox m_cGroupBox;

    public:
        AttributeSliderArrayWithCheckbox( QWidget *pParent, int iWidth, AttributeCheckableFloatArray *pAttribute );

    public slots:
        void OnChange( void );
    };

    class MBDLL_DECL CPBox : public QWidget
    {
        Q_OBJECT
    public:
        CPBox( int iIndex, QWidget *pParent = 0, const char *sName = 0 );
        bool m_bSelected;
        int m_iIndex;

    protected:
        void mousePressEvent( QMouseEvent *pEvent );
        QSize sizeHint( void ) const;
        void paintEvent( QPaintEvent *pEvent );
    };

    class MBDLL_DECL CurveEditor : public QFrame
    {
        Q_OBJECT
    public:
        CurveEditor( QWidget *pParent = 0, const char *sName = 0, bool bNurbs = false );
        void SelectCP( CPBox *pCP );
        void DeleteCP( void );
        void AddCP( float x, float y );
        void Init( void *pCurve = 0 );
        void SetFixedSize(int w, int h);
        void MakeReadOnly();
        void NurbsValueChanged();
        void ApplyCurve();

        bool m_bSnap, m_bNurbs;
        int m_iDeleteHandleSize;
        void *m_pCurve;

    signals:
        void nurbsValueChanged();
        void CurveReadyToBeApplied();

    protected:
        QSize sizeHint( void ) const;
        void paintEvent( QPaintEvent *pe );
        void resizeEvent( QResizeEvent *pEvent );
        void mousePressEvent( QMouseEvent *pEvent );
        void mouseReleaseEvent( QMouseEvent *pEvent );
        void mouseMoveEvent( QMouseEvent *pEvent );
        void keyPressEvent( QKeyEvent *pEvent );
        void keyReleaseEvent ( QKeyEvent *pEvent );
        int CanvasToScreenX( float f );
        int CanvasToScreenY( float f );
        float ScreenToCanvasX( int i );
        float ScreenToCanvasY( int i );
        int m_iCanvasWidth, m_iCanvasHeight;
        CPBox *m_aBoxes[MAX_CURVE_POINTS];
        CPBox *m_pSelectedBox;
        QPoint m_aDeleteCoordinates[MAX_CURVE_POINTS];

    private:
        void ComputeDeleteCoordinates();
        bool IsPointNear(const QPoint& pos);
        int IndexOfClosestPoint(const QPoint& post);

        bool m_bIsDragging, m_bReadOnly, m_bIsPointAddable, m_bIsPointDeletable;
        int m_iSnapDistance, m_iNumBoxes, m_iDeleteIndex;
        float m_fGridSizeX, m_fGridSizeY, m_fStep;
        QCursor m_addCursor, m_deleteCursor;
        QRect m_CurveDisplayBoundary, m_DeleteDisplayBoundary;
    };

    class MBDLL_DECL AttributeCurveEditor : public AttributeWidget
    {
        Q_OBJECT

    protected:
        QPushButton *m_pStoreF;
        CurveEditor *m_pCurveEditor;
        bool eventFilter( QObject *pTarget, QEvent *pEvent );

    public:
        AttributeCurveEditor( 
                            QWidget *pParent, 
                            int iWidth, 
                            acurveptr *pAttribute, 
                            bool bSnapAndStore, 
                            bool bInAdjustColor = false 
                            ); 

        bool EditorInAdjustColor() const { return m_bUsedInAdjustColor; };

        void ReplaceNurbsInEditor(NURBSCurve *pCurve) { m_pCurveEditor->Init(pCurve); };

    public slots:
        void OnChange( void );

        void Update( void );

        void OnEnlarge(void);

        void StartUpdateCountdown(void);

        void OnColorCorrectionClosing(void);

    signals:
        void ParentEditorInColorCorrectionClosing(void);

    private:
        QTimer m_updateTimer;
        bool m_bIsUpdatingTargets, m_bUsedInAdjustColor;
    };

    class MBDLL_DECL EnlargedCurveEditor : public QDialog
    {
        Q_OBJECT
    public:
        EnlargedCurveEditor( 
            AttributeCurveEditor *pCurve 
            );

    signals:
        void CurveSelected( int iIndex );
    
    protected:
        void resizeEvent( QResizeEvent *pEvent );

        void changeEvent ( QEvent *pEvent );
    
    private:
        CurveEditor *m_pCurveEditorFrame;
        AttributeCurveEditor *m_pAttributeCurve;
        // if the AttributeCurveEditor contained in this dialog belongs to a curve from Adjust Color Dialog, this is the index of
        // the item in the combo box for the curve selection. -1 otherwise.
        int m_iIndexOfCurve; 
    };

    class MBDLL_DECL AttributeStampConfigurationWidget : public AttributeWidget
    {
        Q_OBJECT

    protected:
        void UpdateImage( void );
        bool LoadImage(const QString &imgFileName);

        QImage        m_CachedImage;
        QString       m_CachedImageFileName;

        QGroupBox     m_cGroupBox;
        QLabel       *m_pPreviewImage;
        QGroupBox    *m_pRandomize;
        QToolButton  *m_pOrientToStroke; 
        QToolButton  *m_pRotateStamp; 
        QToolButton  *m_pFlipXStamp; 
        QToolButton  *m_pFlipYStamp;
        QSlider      *m_pRotateRandomize; 
        QSlider      *m_pPositionXRandomize; 
        QSlider      *m_pPositionYRandomize; 
        QSlider      *m_pScaleRandomize; 
        QSlider      *m_pStrengthRandomize;
        QCheckBox    *m_pFlipRandomize;
        QCheckBox    *m_pFlopRandomize;
        bool          m_bUpdating;

    public:
        AttributeStampConfigurationWidget( QWidget *pParent, int iWidth, astampcfg *pAttribute );

    public slots:
        void Update( void );
        void OnChange( void );
        void OnRotate( void );
    };
    
    
    class MBDLL_DECL AttributeMirrorConfigurationWidget : public AttributeWidget
    {
        Q_OBJECT
    public:
        AttributeMirrorConfigurationWidget( QWidget *pParent, int iWidth, amirrorcfg *pAttribute );

    protected:
        bool m_bLock;
        void Update( void );
        MirrorComboBox m_cCombo;
    public slots:
        void OnChange( int );   
        void ShowMirrorAxis( int );
    };

    class MBDLL_DECL HelpButton : public QPushButton
    {
        Q_OBJECT
    public:
        HelpButton( QWidget* parent, const QString & sID, const QString & sText = tr("Help...") );
        void SetHelpID( const QString & sID );
        QString HelpID( void ) { return m_sID; };

    protected:
        QString m_sID;
        static QSignalMapper *s_pSignalMapper;

    };
};

#endif