cmddriver.h

Go to the documentation of this file.

#pragma once

/*+
________________________________________________________________________

 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        Bert Bril
 Date:          Sep 2005
________________________________________________________________________

-*/

#include "uicmddrivermod.h"
#include "bufstringset.h"
#include "od_iostream.h"
#include "separstr.h"
#include "strmdata.h"
#include "thread.h"
#include "uimainwin.h"

#include "cmddriverbasics.h"
#include "searchkey.h"

class StreamData;
class uiObject;
class uiMenu;
class uiTaskRunner;
namespace File { class Path; }


namespace CmdDrive
{
    class Activator;
    class IdentifierManager;
    class ExprInterpreter;
    class WildcardManager;
    class MenuTracer;

#define mLogStrm \
    if ( drv_.logStream().isOK() ) drv_.logStream()

#define mTimeStrm \
    mLogStrm << "[" << Time::getTimeString() << "]\t"

#define mParseMsgStrm(tag) \
    if ( !drv_.streamBlocked(true,tag) ) \
        mLogStrm << "\t" << (tag) << " [parse]: "

#define mParseStrm(warn)        mParseMsgStrm( warn ? "WARN" : "ERROR" )
#define mParseErrStrm           mParseStrm( false )
#define mParseWarnStrm          mParseStrm( true )

#define mWinMsgStrm(tag) \
    if ( !drv_.streamBlocked(false,tag) ) \
        mLogStrm << "\t" << (tag) << " [" << drv_.curWinTitle() << "]:\n\t\t"

#define mWinStrm(warn)  mWinMsgStrm( warn ? "WARN " : "ERROR" )
#define mWinErrStrm     mWinStrm( false )
#define mWinWarnStrm    mWinStrm( true )


mExpClass(uiCmdDriver) ModalStatus
{
public:
    bool                        operator==(const ModalStatus&) const;
    bool                        operator!=(const ModalStatus&) const;

    uiMainWin::ActModalTyp      activetype_;
    uiMainWin*                  activewin_;
    uiTaskRunner*               uitaskrunner_;
    int                         nrmodalwins_;
    BufferStringSet             signatures_;
};


mExpClass(uiCmdDriver) Action
{
public:
                                Action(const char* line)
                                    : line_(line), gotoidx_(-1)
                                    , insertidx_(-1)                    {}

    BufferString                line_;
    int                         gotoidx_;
    int                         insertidx_;
};


mExpClass(uiCmdDriver) MenuInfo
{
public:
    int                         nrchildren_;
    int                         siblingnr_;
    int                         ison_;
    BufferString                text_;
};


enum WinStateType { NoState=0, Existent, Inexistent, Accessible, Inaccessible };


mExpClass(uiCmdDriver) CmdDriver : public CallBacker
{ mODTextTranslationClass(CmdDriver)
public:
    
    enum FlowStackTag { IfTag, ElseTag, DefTag, DoTag, DoWhileTag, ForTag };
                    mDeclareEnumUtils(FlowStackTag);

    friend class        Command;
    friend class        ExprInterpreter;
    friend class        Function;
    friend class        MenuTracer;

                        CmdDriver(uiMainWin& applwin);
                        ~CmdDriver();

    bool                getActionsFromFile(const char*);
    bool                insertActionsFromFile(const char*);

    bool                execute();
    void                abort()                         { abort_ = true; }
    void                pause(bool yn=true);
    const uiString      errMsg() const                  { return errmsg_;}

    const char*         outputDir() const               { return outdir_; }
    void                setOutputDir(const char* od)    { outdir_ = od; }

    static const char*  defaultLogFilename();
    const char*         logFileName() const             { return logfnm_; }
    void                setLogFileName(const char* fnm) { logfnm_ = fnm; }
    void                clearLog()                      { logstream_.close(); }

    enum                LogModeTag { LogBasic, LogNormal, LogAll };
    void                setLogMode(LogModeTag tag)      { logmode_ = tag; }

    enum                OnErrorTag { Stop, Recover };
    void                setOnError(OnErrorTag tag)      { onerror_ = tag; }

    void                setCaseSensitive(bool yn)   { casesensitive_ = yn; }
    void                skipGreyOuts(bool yn=true)  { skipgreyouts_ = yn; }

    bool                isCaseSensitive() const     { return casesensitive_; }
    OnErrorTag          onError() const             { return onerror_; }
    bool                greyOutsSkipped() const     { return skipgreyouts_; }

    void                setSleep(float time,
                                 bool regular=true);
    void                setWait(float time,
                                bool regular=true);

    static bool         nowExecuting();

    enum                RecoveryTag { NoClue, CloseCurWin, NextCmd,
                                      NextAssertion };

    enum                InterceptMode { Click, ItemInfo, NodeInfo };

    Notifier<CmdDriver> interactRequest;
    Notifier<CmdDriver> executeFinished;

protected:

    uiMainWin*          applwin_;
    uiMainWin*          applWin()                   { return applwin_; }
    const uiMainWin*    applWin() const     { return applwin_; }

    void                exitApplCB( CallBacker* );

    const uiObject*     localSearchEnv() const      { return localsearchenv_; }

    bool                doLocalAction(uiObject* localenv,const char* actstr);
    bool                tryAction(const char* identname,const char* actstr);

    void                prepareForResume();
    void                prepareForAbort();

    bool                abort_;
    bool                pause_;
    bool                resume_;

    bool                prepareActivate(Activator*);
    void                finishActivate();
    void                waitForClearance();

    void                prepareIntercept(const FileMultiString& mnupath,
                                         int onoff,InterceptMode=Click);
    bool                didInterceptSucceed(const char* objnm);
    const MenuInfo&     interceptedMenuInfo() const;

    void                reInit();

    CmdDriver&          drv_;
    BufferString        outdir_;
    BufferString        logfnm_;
    BufferString        cmdfnm_;
    uiString            errmsg_;
    Threads::Thread*    execthr_;
    od_ostream&         logstream_;
    File::Path&         outfp_;

    WildcardManager*    wcm_;
    WildcardManager&    wildcardMan()                   { return *wcm_; }

    IdentifierManager*  idm_;
    IdentifierManager&  identifierMan()                 { return *idm_; }

    const WildcardManager&      wildcardMan() const;
    const IdentifierManager&    identifierMan() const;

    ObjectSet<const char> tryoutstack_;
    int                 tryoutval_;

    ExprInterpreter*    eip_;
    ExprInterpreter&    exprInterpreter()               { return *eip_; }

    void                logErrMsg();
    void                updateLogStrm();
    LogModeTag          logmode_;

    bool                addActions(ObjectSet<Action>&,const char*);
    ObjectSet<Action>   actions_;
    int                 actionidx_;

    int                 curActionIdx() const            { return actionidx_; }
    bool                insertProcedure(int defidx);

    void                moveActionIdx(int nrlines);
    int                 lastActionIdxMove() const       { return lastmove_; }
    int                 lastmove_;

    void                end();
    void                jump(int extralines=0);
    bool                curactjumped_;

    void                mkThread(CallBacker*);
    bool                doAction(const char*);

    bool                casesensitive_;
    uiObject*           localsearchenv_;

    bool                skipgreyouts_;
    bool                uiobjchange_;
    bool                goingToChangeUiObj() const      { return uiobjchange_; }

    float               pendingsleep_;
    float               regularsleep_;

    float               pendingwait_;
    float               regularwait_;

    BufferString        winassertion_;
    bool                winassertcs_;
    bool                winassertsafe_;
    bool                verifyWinAssert(const char* newwinstr=0);

    BufferString        winstatewin_;
    WinStateType        winstatetype_;
    bool                verifyWinState(const char* newwinstr=0,
                                       WinStateType newwinstate=NoState);

    OnErrorTag          onerror_;
    bool                recover();
    RecoveryTag         recoverystep_;
    void                setRecoveryStep(RecoveryTag rt) { recoverystep_ = rt; }

    static const char*  locateCmdMark(const char* actstr);

    bool                switchCurWin(const uiMainWin*);
    WindowStack         winstack_;
    const uiMainWin*    curWin() const      { return winstack_.topWin(true); }

    bool                openqdialog_;
    bool                openQDlg() const                { return openqdialog_; }

    Threads::Lock       cmddrvlock_;
    bool                activityStopped(bool checkprocessing=true,
                                        bool checktimers=true);

    bool                waitForTimers();
    bool                waitForProcessing();
    int                 wildmodalclosedstamp_;

    void                getModalStatus(ModalStatus&);
    void                storeModalStatus();
    BufferStringSet     wildmodalsignatures_;

    ModalStatus         curmodalstat_;
    ModalStatus         prevmodalstat_;
    int                 prevnrproc_;

    void                activateDone(CallBacker* activator);
    void                timerStartsCB(CallBacker* timer);
    void                timerStoppedCB(CallBacker* timer);
    void                timerShootsCB(CallBacker* timer);
    void                timerShotCB(CallBacker* timer);

    void                forceQtToCatchUp();
                        // Delay to assure that Qt has finished all previous
                        // display, hide and outgrey tasks initiated by the
                        // GUI thread.

    enum                InterceptStatus { NoInterception, InterceptError,
                                          InterceptReady };
    InterceptStatus     interceptstatus_;
    FileMultiString     interceptmenupath_;
    InterceptMode       interceptmode_;
    int                 interceptonoff_;
    bool                interceptmenu_;
    MenuInfo            interceptmenuinfo_;

    void                dynamicMenuInterceptor(CallBacker*);
    bool                dispatchDynamicMenu(uiMenu*);

    void                interactCB(CallBacker*);
    void                executeFinishedCB(CallBacker*);
    void                killTaskRunnerCB(CallBacker*);

    const InteractSpec* interactspec_;
    void                interact(const InteractSpec*);

    ObjectSet<const CallBacker> activatorlist_;
    ObjectSet<const CallBacker> timerlist_;
    ObjectSet<const CallBacker> timeoutlist_;


public:
                        // interface for output stream macros
    od_ostream&         logStream()                      { return logstream_; }
    const char*         curWinTitle(int aliasnr=0) const;

    bool                streamBlocked(bool parse,const char* tag);
                        // Does tryout management as side-effect!

protected:

    void                preProcSubstitutionErrMsg(const int,const int,
                                                     const BufferString&);
    void                checkTailErrMsg(const int,const BufferString&);
    void                checkFlowErrMsg(const int,const char*,const char*);
    void                checkFlowStackErrMsg(TypeSet<int>, enum FlowStackTag);
    const uiString      sCheckFlowStackStr() 
                        { return tr("ended in the middle of","something"); }
};


}; // namespace CmdDrive