YQWizard.h

/*
  Copyright (C) 2000-2012 Novell, Inc
  This library is free software; you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as
  published by the Free Software Foundation; either version 2.1 of the
  License, or (at your option) version 3.0 of the License. This library
  is distributed in the hope that it will be useful, but WITHOUT ANY
  WARRANTY; without even the implied warranty of MERCHANTABILITY or
  FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
  License for more details. You should have received a copy of the GNU
  Lesser General Public License along with this library; if not, write
  to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
  Floor, Boston, MA 02110-1301 USA
*/


/*-/

  File:       YQWizard.h

  Author:     Stefan Hundhammer <shundhammer@suse.de>

/-*/


#ifndef YQWizard_h
#define YQWizard_h

#include <string>
#include <vector>

#include <qpixmap.h>
#include <qstringlist.h>
#include "QY2ListView.h"
#include <QGridLayout>
#include <QSplitter>
#include <qlabel.h>
#include <QMenu>
#include <QAction>
#include <qevent.h>
#include <yui/YWizard.h>
#include "YQWizardButton.h"

using std::vector;

class QGridLayout;
class QFrame;
class QSplitter;
class QLabel;
class QMenuBar;
class QPushButton;
class QSpacerItem;
class QToolButton;
class QStackedWidget;
class YReplacePoint;
class QTreeWidgetItem;
class YQAlignment;
class YQReplacePoint;
class QY2ListView;
class QY2HelpDialog;
class QY2RelNotesDialog;


class YQWizard : public QSplitter, public YWizard
{
    Q_OBJECT

protected:
    class Step;
    class TreeItem;

public:
    YQWizard( YWidget *     parent,
          const std::string &   backButtonLabel,
          const std::string &   abortButtonLabel,
          const std::string &   nextButtonLabel,
          YWizardMode   wizardMode = YWizardMode_Standard );

    virtual ~YQWizard();

    virtual std::string debugLabel() const;

    enum Direction { Forward, Backward };

    Direction direction() const { return _direction; }

    //
    // Wizard basics
    //

    virtual YQWizardButton * backButton()  const { return _backButton;  }
    virtual YQWizardButton * abortButton() const { return _abortButton; }
    virtual YQWizardButton * nextButton()  const { return _nextButton;  }

    virtual YReplacePoint * contentsReplacePoint() const { return _contentsReplacePoint; }

    virtual void setButtonLabel( YPushButton * button, const std::string & newLabel );

    virtual void setHelpText( const std::string & helpText );

    virtual void setDialogIcon( const std::string & iconName );

    virtual void setDialogTitle( const std::string & titleText );

    virtual std::string getDialogTitle();

    virtual void setDialogHeading( const std::string & headingText );


    virtual std::string getDialogHeading();

    //
    // Steps handling
    //

    virtual void addStep( const std::string & text, const std::string & id );

    virtual void addStepHeading( const std::string & text );

    QList<YQWizard::Step*> stepsList() { return _stepsList; }

    void copySteps( YQWizard *wizard);

    virtual void deleteSteps();

    virtual void setCurrentStep( const std::string & id );

    QString currentStep() { return _currentStepID; };

    virtual void updateSteps();


    //
    // Tree handling
    //

    virtual void addTreeItem( const std::string & parentID,
                  const std::string & text,
                  const std::string & id    );

    virtual void selectTreeItem( const std::string & id );

    virtual std::string currentTreeSelection();

    virtual void deleteTreeItems();


    //
    // Menu handling
    //

    virtual void addMenu( const std::string & text,
              const std::string & id );

    virtual void addSubMenu( const std::string & parentMenuID,
                 const std::string & text,
                 const std::string & id );

    virtual void addMenuEntry( const std::string & parentMenuID,
                   const std::string & text,
                   const std::string & id );

    virtual void addMenuSeparator( const std::string & parentMenuID );

    virtual void deleteMenus();


    //
    // Misc
    //

    virtual void showReleaseNotesButton( const std::string & label,
                     const std::string & id );

    virtual void hideReleaseNotesButton();

    virtual void retranslateInternalButtons();

    virtual bool eventFilter( QObject * obj, QEvent * ev );

    QWidget * workArea() const { return _workArea; }


    //
    // Geometry management
    //

    virtual int preferredWidth();

    virtual int preferredHeight();

    virtual void setSize( int newWidth, int newHeight );

    bool isSecondary() const;

signals:

    void backClicked();

    void abortClicked();

    void nextClicked();


public slots:

    void resizeClientArea();

    void showHelp();

    void showHotkeys();

    void showSteps();

    void showTree();

protected slots:

    void slotBackClicked();

    void slotAbortClicked();

    void slotNextClicked();

    void showReleaseNotes();

    void sendTreeEvent( QTreeWidgetItem * item );

    void treeSelectionChanged();

    void sendMenuEvent( QAction *action );

protected:

    // Layout functions

    void layoutTitleBar     ( QWidget * parent );
    QLayout *layoutSideBar  ( QWidget * parent );
    void layoutSideBarButtonBox ( QWidget * parent, QPushButton * button );
    void layoutStepsPanel();
    void layoutTreePanel();
    QWidget *layoutWorkArea ( QWidget * parent );
    void layoutClientArea   ( QWidget * parent );
    QLayout *layoutButtonBox    ( QWidget * parent );
    bool titleIsOnTheLeft();

    void destroyButtons();

    void updateStepStates();

    void sendEvent( const std::string & id );

    void connectNotify ( const char * signal );

    void disconnectNotify ( const char * signal );

    void setButtonLabel( YQWizardButton * button, const QString & newLabel );

    void enableButton( YQWizardButton * button, bool enabled );

    void setButtonFocus( YQWizardButton * button );

    YQWizard::Step * findStep( const QString & id );

    YQWizard::TreeItem * findTreeItem( const std::string & id );


    //
    // Data members
    //

    std::string _backButtonLabel;
    std::string _abortButtonLabel;
    std::string _nextButtonLabel;

    bool    _stepsEnabled;
    bool    _stepsRegistered;
    bool    _treeEnabled;
    bool    _protectNextButton;
    bool    _stepsDirty;
    bool    _sendButtonEvents;
    Direction   _direction;

    QString _currentStepID;
    QString     _qHelpText;
    QString     _qHotkeysText;

    QY2HelpDialog * _helpDlg;
    QY2HelpDialog * _hotkeysDlg;
    QY2RelNotesDialog * _relNotesDlg;

    QStackedWidget *    _sideBar;
    QWidget     *       _stepsPanel;
    YQWizardButton *    _releaseNotesButton;
    static std::string       _releaseNotesButtonId;
    static std::string       _releaseNotesButtonLabel;
    YQWizardButton *    _helpButton;
    QAction *           _helpAction;
    QAction *           _hotkeysAction;
    QPushButton *       _stepsButton;
    QPushButton *       _treeButton;
    QFrame *            _treePanel;
    QY2ListView *       _tree;

    QFrame *            _workArea;
    QWidget *       _clientArea;
    QMenuBar *              _menuBar;
    QLabel *            _dialogIcon;
    QLabel *                _dialogLogo;
    QLabel *                _dialogBanner;    
    QLabel *            _dialogHeading;
    YQAlignment *           _contents;
    YQWizardButton *        _backButton;
    YQWizardButton *        _abortButton;
    YQWizardButton *        _nextButton;
    YReplacePoint * _contentsReplacePoint;

    QList<YQWizard::Step*>  _stepsList;
    QHash<QString,YQWizard::Step*>  _stepsIDs;
    QHash<QString,YQWizard::TreeItem*>  _treeIDs;
    QHash<QString,QMenu*>       _menuIDs;
    QHash<QAction*, std::string>        _menuEntryIDs;

    QIcon _previousWindowIcon;

private:
    static YQWizard *main_wizard;

protected:

    class Step
    {
    public:

    Step( const QString & name = "", const QString & id = "" )
        : _name( name )
        , _statusLabel( 0 )
        , _nameLabel(0)
        , _enabled( true )
        , _idList( id )
        , _status( Unset )
    {}

    virtual ~Step();

    virtual bool isHeading() const { return false; }

    enum Status { Unset, Todo, Current, Done };

    QString  name()     const { return _name;       }
    QLabel * statusLabel()  const { return _statusLabel;    }
    QLabel * nameLabel()    const { return _nameLabel;  }
    bool     isEnabled()    const { return _enabled;    }
    const QStringList & id() const { return _idList;    }
    void addID( const QString & id ) { _idList.append( id ); }
    virtual bool hasID( const QString & id ) { return _idList.indexOf( id ) != -1; }

    void setStatusLabel( QLabel * label )   { _statusLabel = label; }
    void setNameLabel  ( QLabel * label )   { _nameLabel   = label; }
    void setEnabled( bool enabled )     { _enabled = enabled; }

    void deleteLabels();

    void setStatus( Status s );

    protected:

    QString     _name;
    QLabel *    _statusLabel;
    QLabel *    _nameLabel;
    bool        _enabled;
    QStringList _idList;
    Status          _status;

    private:
    Q_DISABLE_COPY(Step);
    };


    class StepHeading: public Step
    {
    public:

    StepHeading( const QString & name = "" )
        : Step( name, "" )
        {}

    virtual ~StepHeading() {}
    virtual bool isHeading() const { return true; }
    virtual bool hasID( const QString & id ) { return false; }

    private:
    Q_DISABLE_COPY(StepHeading);
    };


    class TreeItem: public QY2ListViewItem
    {
    public:
    TreeItem( QY2ListView *     parent,
          const QString &   text,
          const QString &   id )
        : QY2ListViewItem( parent, text )
        , _id( id )
        {}

    TreeItem( YQWizard::TreeItem *  parent,
          const QString &   text,
          const QString &   id )
        : QY2ListViewItem( parent, text )
        , _id( id )
        {}

        virtual QString text(int index) const { return QTreeWidgetItem::text(index); }
    QString text() const { return QTreeWidgetItem::text(0); }
    QString id()   const { return _id; }

    private:
    QString _id;
    };

}; // class YQWizard



#endif // YQWizard_h