SI/AP_Interface.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Side Effects Software Inc
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        AP_Interface.h ( SI Library, C++)
 *
 * COMMENTS:
 */

#ifndef __AP_Interface__
#define __AP_Interface__

#include "SI_API.h"
#include <stdio.h>
#include <UI/UI_Object.h>
#include <UT/UT_Signal.h>
#include <UT/UT_PtrArray.h>
#include <UT/UT_String.h>

class AP_Interface;
class UI_Value;
class UI_Manager;
class UT_SymbolTable;
class UI_Feel;

class SI_API AP_Interface : public UI_Object {
public:
    AP_Interface();
    AP_Interface(const char *myname,
                 const char *const *names,
                 UI_EventMethod const *methods);

    virtual ~AP_Interface();

    const UT_String     &getName() const { return myName; }
    void                 wireInterface(UI_Manager *uims);
    void                 unwireInterface(UI_Manager *uims);

    /// Turns a .ui file into UI gadgets. If quiet is true, no errors or
    /// warnings are printed. If defines is specified, this allows you to
    /// pass CPP style symbols to the parser, in the form "SYMBOL=VALUE".
    /// =VALUE may be omitted.
    int                  parseUI(const char *filename,
                                 bool quiet = false);
    int                  parseUI(FILE *input, const char *inputname,
                                 bool quiet = false);

    void                 setValueSymbol(const char *symbol, UI_Value *value,
                                int warn = 1);
    UI_Value            *getValueSymbol(const char *symbol, int create = 1);

    int                  getValueSymbols(UT_PtrArray<const char *> &symbols,
                                 UT_PtrArray<UI_Value *> &values) const;

    void                 setObjectSymbol(const char *symbol, UI_Object  *who,
                                         int warn = 1);
    UI_Object           *getObjectSymbol(const char *symbol) const;
    UI_Feel             *getFeelSymbol(const char *symbol) const;
    void                 removeObjectSymbol(const char *symbol);

    virtual void initApplication(UI_Manager *uims,
                                 int argc,
                                 const char **argv);
            void resetApplication();
    
    virtual void handleEvent(UI_Event *event);

    // These are methods which are called only if the APP is "the"
    //  registered main application in the program.  By default, they
    //  do nothing.
    virtual int          saveAppData(const char *filename); // ret 1 on success
    virtual int          loadAppState();        // Allows app to load context
    virtual int          saveAppState();        // Allows app to save context
    virtual void         saveOnCoreDump();      // To do stuff when...yikes!
    virtual bool         getCoreDumpFileName(char *buffer, int unique=0);

    // Helper functions for preference files
    static FILE         *createPreferenceFile(const char *filename);
    static FILE         *openPreferenceFile(const char *filename);

    // Utility methods for managing the common ui.pref file
    // Load the UI pref file; should be used by Main.C only.
    bool                 loadUIInitPrefs();
    // Save the current UI state to the pref file. The layout level is 
    // the desired level to be saved.
    void                 saveUIInitPrefs(const char * layout_level);
    // Restore UI prefs from file. Similar to load but does not explicitly
    // set the layout level, which can only be done by Main.C; so this method
    // is used everywhere else to load the prefs from file.
    bool                 restoreUIInitPrefs();

    // If a function key is pressed and a script is attached to it,
    // this will return the script.
    //
    bool                 getFunctionKeyScript(UI_Event *event,
                                             UT_String &script);

    // These static methods will get/set the exit code that the UI application
    // will exit with.  The default exit code is 0.  Note that these methods
    // are implemented in AP_Main.C.
    static void          setAppExitCode(int exit_code);
    static int           getAppExitCode();

protected:
    //
    //  Set the application to run in the fore or background.  This MUST
    //  be called from a static constructor (i.e. before main is run).
    //
    void                 setForegroundOption(int onOff);
    void                 setXTermOption(int onOff);

    void                 setTheMainApplication(AP_Interface *app)
                         {
                            theMainApplication = app;
                         }
    AP_Interface         *getMainApplication() { return theMainApplication; }

    UT_String                    myName;
    const char * const          *myValueNames;
    UI_EventMethod const        *myMethods;

    UT_SymbolTable      *getValueTable (void) const { return myValueTable;  }
    UT_SymbolTable      *getObjectTable(void) const { return myObjectTable; }

    // Returns true if the -geometry arg was parsed out and false otherwise
    bool                 getWindowGeometry(float &width, float &height, 
                                           float &left, float &bottom);

    virtual void         getSignalList(int *signals, int max_signals);

private:
    void                  installSignalHandlers();
    void                  assignUIInitPrefs();

    static void           coredumpHandler(UTsignalHandlerArg sig_arg);
    static void           powerFailHandlerSignalHandler(UTsignalHandlerArg);
    static void           powerFailHandler();
    static void           terminationWarning(uint nseconds);

    UT_SymbolTable       *myValueTable;
    UT_SymbolTable       *myObjectTable;

    static AP_Interface  *theMainApplication;
};

extern void     APregister  (AP_Interface *app);
extern void     APderegister(AP_Interface *app);

// These template functions allow you to get & cast to the appropriate
// object/value type in one step, ie:
//
// UI_Button   *button = UIgetObject<UI_Button>(this, "button.gad");
// UI_StringList *menu = UIgetValue<UI_StringList>(this, "rmb.menu");

template<class ObjectClass> inline
ObjectClass *SIgetObject(const AP_Interface *app, const char *name)
{
    return dynamic_cast<ObjectClass *>(app->getObjectSymbol(name));
}
                                                          
template<class ValueClass> inline
ValueClass *SIgetValue(const AP_Interface *app, const char *name)
{
    return dynamic_cast<ValueClass *>(app->getValueSymbol(name, 0));
}
                                                          


#endif

---