Command.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (c) 2002 Jürgen Riegel <juergen.riegel@web.de>              *
 *                                                                         *
 *   This file is part of the FreeCAD CAx development system.              *
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Library General Public           *
 *   License as published by the Free Software Foundation; either          *
 *   version 2 of the License, or (at your option) any later version.      *
 *                                                                         *
 *   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 Library General Public License for more details.                  *
 *                                                                         *
 *   You should have received a copy of the GNU Library General Public     *
 *   License along with this library; see the file COPYING.LIB. If not,    *
 *   write to the Free Software Foundation, Inc., 59 Temple Place,         *
 *   Suite 330, Boston, MA  02111-1307, USA                                *
 *                                                                         *
 ***************************************************************************/


#ifndef GUI_COMMAND_H
#define GUI_COMMAND_H


#include <list>
#include <map>
#include <string>
#include <vector>

#include <Base/Type.h>

class QWidget;
typedef struct _object PyObject;

namespace App
{
  class Document;
  class DocumentObject;
}

namespace Gui {

class Action;
class Application;
class CommandManager;
class Command;
class ActionGroup;
class Document;
class SelectionSingleton;
class MDIView;


void CreateStdCommands(void);
void CreateDocCommands(void);
void CreateFeatCommands(void);
void CreateMacroCommands(void);
void CreateViewStdCommands(void);
void CreateWindowStdCommands(void);
void CreateTestCommands(void);


class GuiExport CommandBase 
{
public:
    CommandBase(const char* sMenu, const char* sToolTip=0, const char* sWhat=0, 
                const char* sStatus=0, const char* sPixmap=0, const char* sAccel=0);
    virtual ~CommandBase();

    Action*  getAction() const;

protected:
    virtual Action * createAction(void);
public:
    virtual void languageChange() = 0;
    virtual const char* className() const = 0;

    virtual const char* getMenuText   () const { return sMenuText;    }
    virtual const char* getToolTipText() const { return sToolTipText; }
    virtual const char* getStatusTip  () const { return sStatusTip;   }
    virtual const char* getWhatsThis  () const { return sWhatsThis;   }
    virtual const char* getPixmap     () const { return sPixmap;      }
    virtual const char* getAccel      () const { return sAccel;       }

    void setWhatsThis  (const char*);
    void setMenuText   (const char*);
    void setToolTipText(const char*);
    void setStatusTip  (const char*);
    void setPixmap     (const char*);
    void setAccel      (const char*);

protected:
    const char* sMenuText;
    const char* sToolTipText;
    const char* sWhatsThis;
    const char* sStatusTip;
    const char* sPixmap;
    const char* sAccel;
protected:
    Action *_pcAction; 
};

class GuiExport Command : public CommandBase
{
public:
    Command(const char* name);
    virtual ~Command();

protected:

    virtual void activated(int iMsg)=0;
    virtual bool isActive(void){return true;} 
    virtual Action * createAction(void);
    void applyCommandData(Action* );
    const char* keySequenceToAccel(int) const;
    void adjustCameraPosition();

public:

    friend class CommandManager;
    void testActive(void);
    void invoke (int); 
    void addTo(QWidget *);



    static Application*  getGuiApplication(void);   
    Gui::SelectionSingleton&  getSelection(void);
    Gui::Document*  getActiveGuiDocument(void) const;
    App::Document*  getDocument(const char* Name=0) const;
    bool isViewOfType(Base::Type t) const;
    App::DocumentObject*  getObject(const char* Name) const;
    std::string getUniqueObjectName(const char *BaseName) const;


    static void openCommand(const char* sName=0);
    static void commitCommand(void);
    static void abortCommand(void);
    static void updateActive(void);
    static void updateAll(std::list<Gui::Document*> cList);
    static bool isActiveObjectValid(void);
    void languageChange();


    enum DoCmd_Type {
        Doc,
        App,
        Gui
    };
    static void blockCommand(bool);
    static void doCommand(DoCmd_Type eType,const char* sCmd,...);
    static void copyVisual(const char* to, const char* attr, const char* from);
    static void copyVisual(const char* to, const char* attr_to, const char* from, const char* attr_from);
    //static void addModule(const char* sModuleName);
    const std::string strToPython(const char* Str);
    const std::string strToPython(const std::string &Str){return strToPython(Str.c_str());};


    const char * beginCmdHelp(void);
    const char * endCmdHelp(void);
    virtual const char* getHelpUrl(void) const { return sHelpUrl; }


    bool hasActiveDocument(void) const;
    bool hasObject(const char* Name);


    const char* getAppModuleName(void) const {return sAppModule;}
    const char* getName() const { return sName; }
    const char* getGroupName() const { return sGroup; }

protected:
    enum CmdType {
        AlterDoc       = 1,  
        Alter3DView    = 2,  
        AlterSelection = 4,  
        ForEdit        = 8   
    };

    const char* sAppModule;
    const char* sGroup;
    const char* sName;
    const char* sHelpUrl;
    int         eType;
private:
    static bool _blockCmd;
};

class PythonCommand: public Command
{
public:
    PythonCommand(const char* name,PyObject * pcPyCommand, const char* pActivationString);
    virtual ~PythonCommand() {}

protected:

    virtual void activated(int iMsg);
    virtual bool isActive(void);
    const char* getHelpUrl(void);
    virtual Action * createAction(void);

public:

    void languageChange();
    const char* className() const
    { return "PythonCommand"; }
    const char* getWhatsThis  () const;
    const char* getMenuText   () const;
    const char* getToolTipText() const;
    const char* getStatusTip  () const;
    const char* getPixmap     () const;
    const char* getAccel      () const;

protected:
    const char* getResource(const char* sName) const;
    PyObject * _pcPyCommand;
    PyObject * _pcPyResourceDict;
    std::string Activation;
};


class MacroCommand: public Command
{
public:
    MacroCommand(const char* name);
    virtual ~MacroCommand() {}

protected:

    void activated(int iMsg);
    Action * createAction(void);

public:
    const char* getScriptName () const { return sScriptName; }
    void languageChange() {}
    const char* className() const
    { return "Gui::MacroCommand"; }
 

    void setScriptName ( const char* );

    static void load();
    static void save();

protected:
    const char* sScriptName;
};

class GuiExport CommandManager
{
public:
    CommandManager();
    ~CommandManager();
    void addCommand(Command* pCom);
    void removeCommand(Command* pCom);

    bool addTo(const char* Name, QWidget* pcWidget);

    std::vector <Command*> getModuleCommands(const char *sModName) const;

    std::vector <Command*> getAllCommands(void) const;

    std::vector <Command*> getGroupCommands(const char *sGrpName) const;

    Command* getCommandByName(const char* sName) const;

    void runCommandByName (const char* sName) const;

    const std::map<std::string, Command*>& getCommands() const { return _sCommands; }
    void testActive(void);
private:
    void clearCommands();
    std::map<std::string,Command*> _sCommands;
};

} // namespace Gui


#define DEF_STD_CMD(X) class X : public Gui::Command \
{\
public:\
    X();\
    virtual const char* className() const\
    { return #X; }\
protected: \
    virtual void activated(int iMsg);\
};

#define DEF_STD_CMD_A(X) class X : public Gui::Command \
{\
public:\
    X();\
    virtual ~X(){}\
    virtual const char* className() const\
    { return #X; }\
protected: \
    virtual void activated(int iMsg);\
    virtual bool isActive(void);\
};

#define DEF_STD_CMD_C(X) class X : public Gui::Command \
{\
public:\
    X();\
    virtual ~X(){}\
    virtual const char* className() const\
    { return #X; }\
protected: \
    virtual void activated(int iMsg);\
    virtual Gui::Action * createAction(void);\
};

#define DEF_STD_CMD_AC(X) class X : public Gui::Command \
{\
public:\
    X();\
    virtual ~X(){}\
    virtual const char* className() const\
    { return #X; }\
protected: \
    virtual void activated(int iMsg);\
    virtual bool isActive(void);\
    virtual Gui::Action * createAction(void);\
};

#define DEF_STD_CMD_ACL(X) class X : public Gui::Command \
{\
public:\
    X();\
    virtual ~X(){}\
    virtual void languageChange(); \
    virtual const char* className() const\
    { return #X; }\
protected: \
    virtual void activated(int iMsg);\
    virtual bool isActive(void);\
    virtual Gui::Action * createAction(void);\
};

#define DEF_3DV_CMD(X) class X : public Gui::Command \
{\
public:\
    X();\
    virtual ~X(){}\
    virtual const char* className() const\
    { return #X; }\
protected: \
    virtual void activated(int iMsg);\
    virtual bool isActive(void)\
    {\
        Gui::MDIView* view = Gui::getMainWindow()->activeWindow();\
        return view && view->isDerivedFrom(Gui::View3DInventor::getClassTypeId());\
    }\
};

#endif // GUI_COMMAND_H