---

Mguipp.h

Go to the documentation of this file.

/*
* This file is part of the MGUI library
* Copyright 1996-2000 Vincenzo Morello
*
* This file describes the C++ frame for the C MGUI library.
*
* MGUI Version 4.0.3
*
* DOC Version 2.1  Jan 21, 2003
*
*/

#ifndef _MGUIPP_H
#define _MGUIPP_H

#include "mgui.h"

class CmMGUI {
protected:
        virtual inline void beep(void);
        int getKeyboardState(void);
        const char *getSysDir(void);
        const char *getApplicationName(void);
        int     paletteMode(void);
        int     getScreenWidth(void);
        int     getScreenHeight(void);
        int     getNPlanes(void);
        long    getNColors(void);
        MTColor getBlackColor(void);
        MTColor getWhiteColor(void);

        void enableCustomizing(void);
        char *getStringOption(const char *obj_name, const char *opt_name);
        char *getTextOption(const char *obj_name);
        int  getIntOption(const char *obj_name, const char *opt_name, int *ret);
        int  getFontOption(const char *obj_name, MTFont *ret);
        int  getBGColorOption(const char *obj_name, int *pr, int *pg, int *pb);
        int  getFGColorOption(const char *obj_name, int *pr, int *pg, int *pb);
        int  getShadowOption(const char *obj_name, int *shadow, int *i_t, int *o_t);
        void setStringOption(const char *obj_name, const char *opt_name, const char *text);
        void setTextOption(const char *obj_name, const char *text);
        void setIntOption(const char *obj_name, const char *opt_name, int val);
        void setFontOption(const char *obj_name, MTFont font);
        void setBGColorOption(const char *obj_name, int r, int g, int b);
        void setFGColorOption(const char *obj_name, int r, int g, int b);
        void setShadowOption(const char *obj_name, int shadow, int in_t, int out_t);
        void saveOptions(void);

        void logInit(int level, int nr, int nvr, int nc, int nvc, const char *fname);
        void log(int level, const char *fmt, ...);
        void maskedLog(int level, CARD32 mask, const char *fmt, ...);
        void logSetLevel(int level);
        void logSetMask(CARD32 mask);
        CARD32 logGetMask(void);
        void logSetMaskBits(CARD32 mask);
        void logResetMaskBits(CARD32 mask);
        void setTraceFileName(const char *fname);
        void logSetTimeFormat(const char *strftime_format);
        void traceSetTimeFormat(const char *strftime_format);
        void trace(const char *fmt,...);
        void getDefaultBackgroundRGB(int *pr, int *pg, int *pb);
        void setDefaultBackgroundRGB(int r, int g, int b);
        void getDefaultForegroundRGB(int *pr, int *pg, int *pb);
        void setDefaultForegroundRGB(int r, int g, int b);
        int  textCharX(const char *text, MTFont font, int i);
        int  textHeight(const char *text, MTFont font);
        int  charHeight(char ch, MTFont font);
        int  textWidth(const char *text, MTFont font);
        int  textNWidth(const char *text, MTFont font, int n);
        int  charWidth(char ch, MTFont font);
        int spoolFile(const char *fname);
        int spoolTempFile(const char *fname);
        void mainLoop(void);
        void loopWhileFlag(int *pflag, int value);
        void loopWhileEvents(int discard);
        void nextEvent(MEvent *pe, int wait);
        void processEvent(MEvent *pe);
        int messageDialog(const char *title, const char *msg, const char *btn1,
                const char *btn2, ...);
        int inputPrompt(const char *title, const char *msg, char *text, int len,
                const char *ok_btn, const char *canc_btn);
        char *textPrompt(const char *title, const char *msg, const char *text,
                int w, int h, const char *ok_btn, const char *canc_btn);
        int  fileSelection(const char *title, char *filter, char *fname,
                char *dname, int change_cur_dir);
        int  fileBrowse(const char *title, char *filter, char *fname,
                char *dname, int change_cur_dir);
        inline const char *getCurrentDirectory(void);
        void setInputPromptRGB(int r, int g, int b);
        inline void setInputPromptFgRGB(int r, int g, int b);
        inline void setInputPromptFonts(MTFont text_font, MTFont edit_font, MTFont buttons_font);
        void setMessageDialogRGB(int r, int g, int b);
        void setFileSelectionRGB(int r, int g, int b);
        inline void setMessageDialogFgRGB(int r, int g, int b);
        inline void setMessageDialogFonts(MTFont text_font, MTFont buttons_font);
        void getInputPromptRGB(int *pr, int *pg, int *pb);
        inline void getInputPromptFgRGB(int *pr, int *pg, int *pb);
        inline void getInputPromptFonts(MTFont *text_font, MTFont *edit_font, MTFont *buttons_font);
        void getMessageDialogRGB(int *pr, int *pg, int *pb);
        inline void getMessageDialogFgRGB(int *pr, int *pg, int *pb);
        inline void getMessageDialogFonts(MTFont *text_font, MTFont *buttons_font);
        void getFileSelectionRGB(int *pr, int *pg, int *pb);
        void setFileSelectionTextStrings(
            char *file_list, char *dir_list, char *drive_list, char *filter,
            char *filename, char *curr_dir, char *ok_button, char *close_button);
};


class CmMenuItem;
class CmTreeNode;
class CmTimeout;
class CmSocketHandler;

typedef class CmMGUI CmCallback;


typedef void (CmCallback::*VOID_CB)(void);
typedef void (CmCallback::*EVENT_CB)(MEvent *);
typedef void (CmCallback::*LONG_CB)(long);
typedef void (CmCallback::*INT_CB)(int);
typedef void (CmCallback::*MENUITEM_CB)(int);
typedef void (CmCallback::*ITEMSEL_CB)(CmMenuItem *);
typedef void (CmCallback::*STRING_CB)(char *);
typedef void (CmCallback::*NEWBLOCK_CB)(SBL_NEW_BLOCK *);
typedef void (CmCallback::*ITEMSEEK_CB)(SBL_ITEM_SEEK *);
typedef void (CmCallback::*EDITVAL_CB)(EDIT_VAL *);
typedef void (CmCallback::*EDITCURS_CB)(EDIT_CURS *);
typedef void (CmCallback::*EDITCHANGE_CB)(EDIT_CHANGE *);
typedef void (CmCallback::*LISTACT_CB)(LIST_ACT *);
typedef void (CmCallback::*LISTSEL_CB)(LIST_SEL *);
typedef void (CmCallback::*DRAWAREAPREF_CB)(DRAWAREA_PREF *);
typedef void (CmCallback::*SOCKETPP_CB)(unsigned);
typedef void (CmCallback::*SOCKETPP2_CB)(CmSocketHandler *, unsigned);
typedef void (CmCallback::*TIMEOUTPP2_CB)(CmTimeout *);
typedef void (CmCallback::*MTREENODE_CB)(CmTreeNode *);

class CmAppl : public CmMGUI {
        friend void MGUIMain(int argc, char **argv);
        static CmAppl *app_inst;
protected:
        CmAppl(void);
public:
        virtual void start(int argc, char **argv)=0;
        static void end(int code);
};

class CmTimeout : public CmMGUI {
        friend void _TimeoutCB_(TIMEOUT_ID id, void *ud);
        TIMEOUT_ID tid;
        CARD32  msec;
        int continuous;
        int stopped;
        VOID_CB callback;
        CmCallback *owner;

public:
        virtual ~CmTimeout(void);
        CmTimeout(CmCallback *owner, VOID_CB cb, CARD32 msec, int continuous=False);
        void start(CARD32 msec);
        void start(void);
        void stop(void);
};

class CmSocketHandler : public CmMGUI {
        friend void _SocketCB_(int s, unsigned events, void *ud);
        int sid;
        SOCKETPP_CB callback;
        SOCKETPP2_CB callback2;
        CmCallback *owner;

public:
        CmSocketHandler(int s, CmCallback *own, SOCKETPP_CB cb, unsigned events);
        CmSocketHandler(int s, CmCallback *own, SOCKETPP2_CB cb, unsigned events);
        virtual ~CmSocketHandler(void);
        void setEventsMask(unsigned events);
        unsigned getEventsMask(void);
        int getSocketId(void) { return sid; }
};


class CmColor {
protected:
        MTColor id;
public:
        CmColor(MTColor cc=0) { id = cc;}
        operator MTColor() { return id; }
        void getRGB(int *r, int *g, int *b);
};

class CmSharedColor : public CmColor {
public:
        virtual ~CmSharedColor(void);
        CmSharedColor(unsigned r, unsigned g, unsigned b);
        CmSharedColor(CmColor *c, int shift=100);
};

class CmRWColor : public CmColor {
public:
        virtual ~CmRWColor(void);
        CmRWColor(unsigned r, unsigned g, unsigned b);
        void setRGB(int r, int g, int b);
};

class CmImage : public MIMAGE_DESCR {
protected:
        void allocImage(int imgw, int imgh, int np);
public:
        virtual ~CmImage(void);
        static inline void addDefaultTypeGIF(void);
        static inline void addDefaultTypeTIFF(void);
        static inline void addDefaultTypeJPEG(void);
        static inline void addDefaultTypePNG(void);
        static inline void addPath(const char *path);
        static inline void removePath(const char *path);
        CmImage(const char *fname);
        CmImage(int imgw, int imgh, int np);

        void install(void);
        void uninstall(void);
        int  getWidth(void)   { return img_w; }
        int  getHeight(void)  { return img_h; }
        int  getNColors(void) { return ncolors; }
        int  getNPlanes(void) { return nplanes; }
        void getPixelRGB(int x, int y, int *pr, int *pg, int *pb);
        void setPixelRGB(int x, int y, int r, int g, int b);
        int  getPixelIndex(int x, int y);
        void setPixelIndex(int x, int y, int i);
        void getCMapEntry(int i, int *pr, int *pg, int *pb);
        void setCMapEntry(int i, int r, int g, int b);
        void merge(CmImage *src, int xo, int yo, int transparent);
        void setMask(CmImage *mask);
        inline void setMaskByCMapIndex(int id);
        inline void setMaskByPixel(int x, int y);
        inline void setMaskByRGB(int r, int g, int b);
        inline void addAlphaChannel(void);
        inline int  getPixelAlpha(int x, int y);
        inline void setPixelAlpha(int x, int y, CARD8 alpha);
        CmImage *clone(void);
        CmImage *createImageMaskByCMapIndex(int index);
        CmImage *createImageMaskByRGB(int r, int g, int b);
        CmImage *createImageMaskByPixel(int x, int y);
        void computeBackgroundRGB(int *pr, int *pg, int *pb);
};

class CmCursor {
        MTCursor cur;
public:
        operator MTCursor() { return cur;}
        CmCursor(CmImage *bits, int xs, int ys) {cur=MCreateCursor(bits,xs,ys);}
};

class CmFont {
        MTFont font;
        int loaded;
public:
        operator MTFont() { return font;}
        CmFont(int ff=DEFAULT_FONT)
                { font = ff; loaded=0;}
        CmFont(const char *family, int h, int bold=0, int italic=0);
        ~CmFont();
        static const char *getFirstFamily(void);
        static const char *getNextFamily(void);
};

class CmShell;
class CmForm;
class CmContainer;
class CmObject;

class CmObject : public CmMGUI {

        friend class CmOptionEdit;
        friend void _ObjectDestroyCB_(MOBJECT p, void *a, void *ud);
        friend void _EventPreProcessCB_(MOBJECT p, MEvent *pe, void *ud);

        void *user_data; 

protected:
        MOBJECT  obj;
        EVENT_CB eventCB;

        void reserved(void);
        virtual ~CmObject(void);
public:
        operator MOBJECT() {return obj; };

        inline void drawText(int x, int y, int w, int h, const char *text,
                        MTFont font, CmColor *fgc, int alignment);
        inline void drawNText(int x, int y, int w, int h, const char *text,
                        MTFont font, CmColor *fgc, int alignment, int n);
        inline void drawBGText(int x, int y, int w, int h, const char *text,
                        MTFont font, CmColor *bgc, CmColor *fgc, int alignment);
        inline void drawBGNText(int x, int y, int w, int h, const char *text,
                        MTFont font, CmColor *bgc, CmColor *fgc, int alignment, int n);
        inline void drawShadowedText(int x, int y, int w, int h, const char *text,
                        MTFont font, int sh, CmColor *fg1, CmColor *fg2, int alignment);
        inline void drawShadowedNText(int x, int y, int w, int h, const char *text,
                        MTFont font, int sh, CmColor *fg1, CmColor *fg2, int alignment, int n);
        inline void drawPoint(int x, int y, CmColor *col);
        inline void drawLine(int x1, int y1, int x2, int y2, CmColor *col);
        inline void drawPolyline(MPOINT *points, int n, CmColor *col);
        inline void drawFilledPolyline(MPOINT *points, int n, CmColor *col);
        inline void drawBox(int x, int y, int w, int h, CmColor *bgc);
        inline void drawFilledBox(int x, int y, int w, int h, CmColor *bgc);
        inline void drawCircle(int x, int y, int r, CmColor *col);
        inline void drawFilledCircle(int x, int y, int r, CmColor *col);
        inline void drawArc(int x, int y, int r, int a1, int a2, CmColor *col);
        inline void drawFilledArc(int x, int y, int r, int a1, int a2, CmColor *c);
        inline void drawImage(CmImage *gi, int img_x, int img_y, int w, int h,
                        int x, int y);
        inline void drawWindow(void);
        inline void drawShadow(void);
        inline void drawSubShadow(int x, int y, int w, int h, CmColor *tsc, CmColor *bsc, int thick);
        inline void drawBorder(int x, int y, int w, int h, CmColor *col, int thick);

        inline void drawXorLine(int x1, int y1, int x2, int y2);
        inline void drawXorBox(int x, int y, int w, int h);

        inline void setSensitive(void);
        inline void setUnsensitive(void);
        inline void setSensitivity(int true_false);
        inline void setSelectable(void);
        inline void setUnselectable(void);
        inline void setAutoScrollWhenSelected(int TrueFalse);
        inline void setBackgroundColor(CmColor *bgc);

        inline void setForegroundColor(CmColor *fgc);

        inline void setColor(CmColor *bgc, CmColor *fgc);

        inline void setBGColorFromParent(int true_false, int percentage);

        inline void setFGColorFromParent(int true_false);
        inline void setBackgroundRGB(unsigned r, unsigned g, unsigned b);
        inline void setForegroundRGB(unsigned r, unsigned g, unsigned b);
        inline void setText(const char *text);
        inline void setName(const char *name);
        inline void setFont(MTFont font, int resize_obj=0);
        inline void setShadow(int type, int in=0, int out=0);
        inline void setResize(int resize_w, int resize_h);
        inline void setSize(int width, int height);
        inline void setMinSize(int width, int height);
        inline void setWidth(int width);
        inline void setHeight(int height);
        inline void setCompositeSize(int width, int height);
        inline void setCompositeWidth(int width);
        inline void setCompositeHeight(int height);
        inline void setPosition(int x, int y);
        inline void setX(int x);
        inline void setY(int y);
        inline void setBackgroundImage(CmImage *gi, int mode);
        inline void setBackgroundImageFile(const char *fname, int mode);
        inline void setColorFromBackgroundImage(void);
        inline void setBGImageMaskByCMapIndex(int id);
        inline void setBGImageMaskByPixel(int x, int y);
        inline void setBGImageMaskByRGB(int r, int g, int b);
        inline void setSolid(void);
        inline void setTransparent(void);
        inline void setTransparency(CARD8 level);
        inline CARD8 getTransparency(void);
        inline void setAttachment(int top, int bottom, int left, int right);
        inline void setOffset(int t_off, int b_off, int l_off, int r_off);
        inline void setCursor(MTCursor cursor);
        inline void setPopupHelp(const char *str, int delay, int duration);
        inline void setLabelHelp(const char *str, CmObject *label);
        inline void setUserData(void *ud) { user_data = ud; };
        inline void changePopupHelpText(const char *str);
        inline void changeLabelHelpText(const char *str);
        inline void topAttach(int att_type, int off, CmObject *obj);
        inline void bottomAttach(int att_type, int off, CmObject *obj);
        inline void leftAttach(int att_type, int off, CmObject *obj);
        inline void rightAttach(int att_type, int off, CmObject *obj);
        inline void align(int h_align, int v_align);

        inline void getText(char *text);
        inline const char *getName(void);
        inline void *getUserData(void) { return user_data; };
        inline MTFont getFont(void);
        inline void getShadow(int *type, int *in, int *out);
        inline int isSensitive(void);
        inline int isSelectable(void);
        inline int isMapped(void);
        inline int getWidth(void);
        inline int getHeight(void);
        inline int getCompositeWidth(void);
        inline int getCompositeHeight(void);
        inline int getX(void);
        inline int getY(void);
        inline int usesFGColorFromParent(void);
        inline int usesBGColorFromParent(int *percentage_ret);
        CmColor *getBackgroundColor(void);

        CmColor *getForegroundColor(void);

        CmContainer *getParent(void);
        CmShell *getShell(void);
        inline CmImage *getBackgroundImage(void);

        inline void resize(int w, int h);
        inline void redraw(void);
        inline void select(void);
        inline void map(void);
        inline void unmap(void);
        inline void enableOptions(const char *name, CARD32 mask);
        inline void saveOptions(void);
        inline void unlink(int resize_obj);
        inline void focusLink(CmObject *obj_to_link);
        void reparent(CmContainer *new_parent, CmObject *where);
        void link(CmContainer *parent, CmObject *where, int resize_parent);
        inline void sendEvent(MEvent *pe);
        void setEventCallback(CmCallback *pp, EVENT_CB ff, CARD32 mask);
#ifdef WIN_MGUI

        inline void print(DOC_ID, MPRINT_OPTIONS *);
#endif
};

class CmContainer : public CmObject {
public:
        virtual void addChild(CmObject *child)=0;

        CmObject *getSelectedObject(void);
        CmObject *getFirstChild(void);
        CmObject *getNextChild(void);
        int       getNChildren(void);
        inline void enableSmartDrawing(void);
        inline void disableSmartDrawing(void);
        void addKeyCallback(CmCallback *, int, MVALUE_CB);
};

class CmShell : public CmContainer {
        friend void _WMCloseCB_(MOBJECT p, void *a, void *ud);
        VOID_CB closeCB;
public:
        ~CmShell(void);
        CmShell(const char *text=0, int flags=0);

        inline Window getWindow(void);

        inline void realize(void);
        inline void realize(int x, int y);
        inline void realize(int x, int y, int w, int h);
        inline void unrealize(void);
        inline void raise(void);
        void addChild(CmObject *child);

        void setWMCloseCallback(CmCallback *pp, VOID_CB ff);
};

class CmForm : public CmContainer {
protected:
        CmForm(void){};
public:
        inline void setSpacing(int offset);
        inline void setFocusWrap(int true_false);
        inline void setFocusHighlight(int true_false);
        inline void selectFirstChild(void);
        inline void selectLastChild(void);
        void addChild(CmObject *object);
        void setChildSelectCallback(CmCallback *, INT_CB);
};

class CmPosForm : public CmForm {
public:
        CmPosForm(CmContainer *parent);
};

class CmRowForm : public CmForm {
public:
        CmRowForm(CmContainer *parent);
};

class CmColForm : public CmForm {
public:
        CmColForm(CmContainer *parent);
};

class CmAbsTableForm : public CmForm {
public:
    inline void showGrid(void);
    inline void hideGrid(void);
    inline void setRowHeight(int row, int height);
    inline void setColWidth(int col, int width);
    inline void setColFont(int col, MTFont f);
    inline void setColAlign(int col, int al);
    inline void setRowAlign(int row, int al);
    inline void setColBackgroundRGB(int col, int r, int g, int b);
    inline void setColForegroundRGB(int col, int r, int g, int b);
    inline void setCellText(int x, int y, const char *text);
    inline void getCellText(int x, int y, char *text);
    inline void setCellFont(int x, int y, MTFont f);
    inline void setCellAlign(int x, int y, int h_al, int v_al);
    inline void setCellBackgroundRGB(int x, int y, int r, int g, int b);
    inline void setCellForegroundRGB(int x, int y, int r, int g, int b);
    CmObject *getCellObject(int x, int y);
    inline void deleteRow(int row);
    inline void deleteDataRows(void);
};

class CmTableForm : public CmAbsTableForm {
public:
    CmTableForm(CmContainer *parent, int n_columns);
};


class CmScrolledTableForm : public CmAbsTableForm {
public:
    CmScrolledTableForm(CmContainer *parent, int n_columns,
        int clip_w, int clip_h, int head_rows=0, int head_cols=0);
};

class CmAbsPagedForm : public CmForm {
        friend void _NewPageCB_(MOBJECT p, MVALUE a, void *ud);
        INT_CB newPageCB;
public:
        inline void setActivePage(int page);
        inline int  getActivePage(void);
        inline void setNPages(int npages);
        inline void disablePageKeys(void);
        inline void enablePageKeys(void);
        void setActivePageCallback(CmCallback *, INT_CB);
};

class CmAbsTabbedForm : public CmAbsPagedForm {
public:
        inline void setTabText(int page, const char *text);
        inline void getTabText(int page, char *text);
};

class CmPagedPosForm : public CmAbsPagedForm {
public:
        CmPagedPosForm(CmContainer *parent, int n_pages);
};

class CmPagedRowForm : public CmAbsPagedForm {
public:
        CmPagedRowForm(CmContainer *parent, int n_pages);
};

class CmPagedColForm : public CmAbsPagedForm {
public:
        CmPagedColForm(CmContainer *parent, int n_pages);
};

class CmPagedPosFormExt : public CmAbsPagedForm {
public:
        CmPagedPosFormExt(CmContainer *parent, int n_pages);
};

class CmPagedRowFormExt : public CmAbsPagedForm {
public:
        CmPagedRowFormExt(CmContainer *parent, int n_pages);
};

class CmPagedColFormExt : public CmAbsPagedForm {
public:
        CmPagedColFormExt(CmContainer *parent, int n_pages);
};

class CmTabbedPosForm : public CmAbsTabbedForm {
public:
        CmTabbedPosForm(CmContainer *parent, int n_pages, MTFont f=HELV_SMALL);
};

class CmTabbedRowForm : public CmAbsTabbedForm {
public:
        CmTabbedRowForm(CmContainer *parent, int n_pages, MTFont f=HELV_SMALL);
};

class CmTabbedColForm : public CmAbsTabbedForm {
public:
        CmTabbedColForm(CmContainer *parent, int n_pages, MTFont f=HELV_SMALL);
};

class CmAbsCForm : public CmForm {
public:
        inline void setClipX(int clip_x);
        inline void setClipY(int clip_y);
        inline int      getClipX(void);
        inline int      getClipY(void);
        inline void setSliderColor(CmColor *cc);
        inline void setSliderColorShift(int perc);
};

class CmAbsScrolledForm : public CmAbsCForm {
public:
        inline void setIncr(int h_inc, int v_inc);
        inline void setSliderColor(CmColor *cc);
        inline void setSliderColorShift(int perc);
};

class CmScrolledPosForm : public CmAbsScrolledForm {
public:
        CmScrolledPosForm(CmContainer *parent, int w, int h);
};

class CmScrolledRowForm : public CmAbsScrolledForm {
public:
        CmScrolledRowForm(CmContainer *parent, int w, int h);
};

class CmScrolledColForm : public CmAbsScrolledForm {
public:
        CmScrolledColForm(CmContainer *parent, int w, int h);
};

class CmClippedPosForm : public CmAbsCForm {
public:
        CmClippedPosForm(CmContainer *parent, int w, int h);
};

class CmClippedRowForm : public CmAbsCForm {
public:
        CmClippedRowForm(CmContainer *parent, int w, int h);
};

class CmClippedColForm : public CmAbsCForm {
public:
        CmClippedColForm(CmContainer *parent, int w, int h);
};

class CmLabel : public CmObject {
public:
        CmLabel(CmContainer *parent, const char *text=0, MTFont font=DEFAULT_FONT);
        void setMargin(int wm, int hm);
        void setHSpacing(int hs);
        void setAlignment(int alignment);
};

class CmAbsEdit : public CmObject {
        friend void _EditNewValueCB_(MOBJECT p, char *text, void *ud);
        friend void _EditValueChangeCB_(MOBJECT p, EDIT_CHANGE *ec, void *ud);
        STRING_CB newValueCB;
        EDITCHANGE_CB valueChangeCB;
protected:
        CmAbsEdit(void){};
public:
        void changeText(int off, int len, const char *new_t, int chg_len);
        void getSubString(int start, int end, char *str);
        int  findSubStringForward(int off, const char *str, int icase);
        int  findSubStringBackward(int off, const char *str, int icase);
        void setSelection(int start, int end);
        void getSelection(int *pstart, int *pend);
        char *getAllocatedText(void);
        void setCursorPos(int pos);
        int  getCursorPos(void);

        void setNewValueCallback(CmCallback *, STRING_CB);
        void setValueChangeCallback(CmCallback *, EDITCHANGE_CB);
};

class CmAbsEditField : public CmAbsEdit {
        friend void _EditActCB_(MOBJECT p, char *text, void *ud);
        friend void _EditValCB_(MOBJECT p, EDIT_VAL *ev, void *ud);
        friend void _EditHotKeyCB_(MOBJECT p, void *a, void *ud);
        STRING_CB  activateCB;
        EDITVAL_CB validateCB;
        VOID_CB    hotKeyCB;
protected:
        CmAbsEditField(void){};
public:
        inline void setMargin(int w_margin, int h_margin);
        void setFilter(int filter, const char *extra_chars);
        void setTextExt(const char *text, int validated, int notify);
        void setValidatedColors(CmColor *bgc, CmColor *fgc);
        void setInvalidatedColors(CmColor *bgc, CmColor *fgc);
        void setValidationStatus(int validated);
        void selectForReplace(void);
        inline void disableEditing(void);
        inline void enableEditing(void);
        const char *text(void);
        int  getFilter(void);
        int  isValidated(void);

        void setActivateCallback(CmCallback *, STRING_CB);
        void setHotKeyCallback(CmCallback *, VOID_CB, int);
        void setValidateCallback(CmCallback *, EDITVAL_CB);
};

class CmEditField : public CmAbsEditField {
public:
        CmEditField(CmContainer *parent, const char *text, int len,
                int clip_len=-1, MTFont font=DEFAULT_FONT);
};

class CmHiddenEditField : public CmAbsEditField {
public:
        CmHiddenEditField(CmContainer *parent, const char *text, int len,
                int clip_len=-1, MTFont font=DEFAULT_FONT, char shown='*');
};

class CmSpinEditField : public CmAbsEditField {
        friend void _SpinCB_(MOBJECT p, MVALUE a, void *ud);
        INT_CB spinCB;
public:
        CmSpinEditField(CmContainer *parent, const char *text, int len,
                int clip_len, MTFont font,
                CmCallback *owner, INT_CB cb);
};

class CmAbsEditWindow : public CmAbsEdit {
        friend void _EditCursorCB_(MOBJECT p, EDIT_CURS *ec, void *ud);
        EDITCURS_CB cursCB;
public:
        void setCursorXY(int x, int y);
        void getCursorXY(int *px, int *py);
        void setAutoIndent(int on_off);
        void setTabSize(int size);
        void setClipWindow(int clip_w, int clip_h);
        void setCursorCallback(CmCallback *, EDITCURS_CB);
};

class CmEditWindow : public CmAbsEditWindow {
public:
        CmEditWindow(CmContainer *parent, const char *text, int width, int height,
                MTFont font=DEFAULT_FONT);
};

class CmScrolledEditWindow : public CmAbsEditWindow {
public:
        CmScrolledEditWindow(CmContainer *parent, const char *text, int width, int height,
                MTFont font=DEFAULT_FONT);
        inline void setSliderColor(CmColor *cc);
        inline void setSliderColorShift(int perc);
};

class CmAbsButton : public CmObject {
public:
        void setImages(const char *normal, const char *arm=0, const char *unsens=0);
        void changeImageFiles(const char *normal, const char *arm, const char *unsens,
                const char *norm_on, const char *arm_on, const char *uns_on);
        inline CmImage *changeNormalImage(CmImage *new_normal);
        inline CmImage *changeArmedImage(CmImage *new_armed);
        inline CmImage *changeUnsensitiveImage(CmImage *new_unsens);
        inline CmImage *changeNormalOnImage(CmImage *new_normal_on);
        inline CmImage *changeArmedOnImage(CmImage *new_armed_on);
        inline CmImage *changeUnsensitiveOnImage(CmImage *new_unsens_on);
        inline void setTextVsImageAlignment(CARD8 align);
        inline void setOnMouseOverForegroundColor(CmColor *fgc);
        inline void setOnMouseOverForegroundRGB(int r, int g, int b);
        inline void setShadowOnMouseOver(int thick);
        inline void setAccelerator(int key);
        inline void setImageMaskByCMapIndex(int id);
        inline void setImageMaskByPixel(int x, int y);
        inline void setImageMaskByRGB(int r, int g, int b);
        inline void unsetOnMouseOverForeground(void);
        inline void unShadowOnMouseOver(void);
};

class CmPushButton : public CmAbsButton {
        friend void _PushButtonActivateCB_(MOBJECT p, void *a, void *ud);
        VOID_CB activateCB;
public:
        CmPushButton(CmContainer *p, const char *text, MTFont font=DEFAULT_FONT);
        CmPushButton(CmContainer *p, CmImage *norm, CmImage *arm=0, CmImage *uns=0);
        CmPushButton(CmContainer *p, const char *norm, const char *arm, const char *uns=0);
        CmPushButton(CmContainer *p, 
                CmImage *norm, CmImage *arm, CmImage *uns,
                CmImage *norm_on, CmImage *arm_on, CmImage *uns_on);
        CmPushButton(CmContainer *p,
                const char *norm, const char *arm, const char *uns,
                const char *norm_on, const char *arm_on, const char *uns_on);
        CmPushButton(CmContainer *p, const char *text, MTFont font, 
                CmImage *norm, CmImage *arm, CmImage *uns,
                CmImage *norm_on, CmImage *arm_on, CmImage *uns_on);
        CmPushButton(CmContainer *p, const char *text, MTFont font,
                const char *norm, const char *arm, const char *uns,
                const char *norm_on, const char *arm_on, const char *uns_on);
        void setRepeatDelay(int first, int repeat);
        void setMargin(int wm, int hm);
        void setHSpacing(int hs);
        void setAlignment(int alignment);
        void setAccelerator(int key);
        void setCallback(CmCallback *owner, VOID_CB cb);
};

class CmToggleButton : public CmAbsButton {
        friend void _ToggleButtonActivateCB_(MOBJECT p, MVALUE a, void *ud);
        INT_CB activateCB;
public:
        CmToggleButton(CmContainer *par, const char *text, MTFont font=DEFAULT_FONT);
        CmToggleButton(CmContainer *p, CmImage *n, CmImage *arm=0, CmImage *uns=0);
        CmToggleButton(CmContainer *par, const char *normal, const char *on_arm, const char *uns=0);
        CmToggleButton(CmContainer *p, 
                CmImage *norm, CmImage *arm, CmImage *uns,
                CmImage *norm_on, CmImage *arm_on, CmImage *uns_on);
        CmToggleButton(CmContainer *p,
                const char *norm, const char *arm, const char *uns,
                const char *norm_on, const char *arm_on, const char *uns_on);
        CmToggleButton(CmContainer *p, const char *text, MTFont font, 
                CmImage *norm, CmImage *arm, CmImage *uns,
                CmImage *norm_on, CmImage *arm_on, CmImage *uns_on);
        CmToggleButton(CmContainer *p, const char *text, MTFont font,
                const char *norm, const char *arm, const char *uns,
                const char *norm_on, const char *arm_on, const char *uns_on);
        void arm(void);
        void disarm(void);

        int isArmed(void);

        void setCallback(CmCallback *owner, INT_CB cb);
};

class CmRadioButton : public CmAbsButton {
        friend void _RadioButtonActivateCB_(MOBJECT p, MVALUE a, void *ud);
        INT_CB activateCB;
public:
        CmRadioButton(CmContainer *par, const char *text, MTFont font=DEFAULT_FONT);
        CmRadioButton(CmContainer *p, CmImage *norm, CmImage *arm=0, CmImage *uns=0);
        CmRadioButton(CmContainer *par, const char *normal, const char *on_arm, const char *when_unsens=0);
        CmRadioButton(CmContainer *p, 
                CmImage *norm, CmImage *arm, CmImage *uns,
                CmImage *norm_on, CmImage *arm_on, CmImage *uns_on);
        CmRadioButton(CmContainer *p,
                const char *norm, const char *arm, const char *uns,
                const char *norm_on, const char *arm_on, const char *uns_on);
        CmRadioButton(CmContainer *p, const char *text, MTFont font, 
                CmImage *norm, CmImage *arm, CmImage *uns,
                CmImage *norm_on, CmImage *arm_on, CmImage *uns_on);
        CmRadioButton(CmContainer *p, const char *text, MTFont font,
                const char *norm, const char *arm, const char *uns,
                const char *norm_on, const char *arm_on, const char *uns_on);
        void arm(void);
        void disarm(void);

        int isArmed(void);

        void setCallback(CmCallback *owner, INT_CB cb);
};

class CmPixmap : public CmObject {
public:
        CmPixmap(CmContainer *par, CmImage *normal);
        CmPixmap(CmContainer *par, const char *fname);

        void setImage(CmImage *normal);
        void setImage(const char *fname);
};

class CmDrawArea : public CmObject {
        friend void _DrawAreaExposeCB_(MOBJECT, MEvent *, void *);
        friend void _DrawAreaInputCB_(MOBJECT, MEvent *, void *);
        friend void _DrawAreaResizeCB_(MOBJECT, DRAWAREA_PREF *, void *);
        EVENT_CB exposeCB;
        EVENT_CB inputCB;
        DRAWAREAPREF_CB resizeCB;
public:
        CmDrawArea(CmContainer *parent, int w, int h);

        void setExposeCallback(CmCallback *, EVENT_CB);
        void setInputCallback(CmCallback *, EVENT_CB);
        void setResizeCallback(CmCallback *, DRAWAREAPREF_CB);
};

class CmStatusBar : public CmObject {
public:
        CmStatusBar(CmContainer *parent, const char *text=0, int max=10, MTFont font=DEFAULT_FONT);

        void setMax(int max);
        void setWidth(int width);
        void setPos(int pos);
        inline void setSliderColor(CmColor *col);
        inline void setSliderColorShift(int perc);
        inline void setSliderRGB(int r, int g, int b);
};

class CmSplitter : public CmObject {
public:
        CmSplitter(CmContainer *parent);
};

class CmScrollBar : public CmObject {
        friend void _ScrollBarValueCB_(MOBJECT p, MVALUE a, void *ud);
        LONG_CB changeCB;
public:
        CmScrollBar(CmContainer *parent, int type, long n, long max);

        void setMax(long max);
        void setPos(long pos);
        void setN(long n);
        void setIncr(int incr);
        inline void setSliderColor(CmColor *cc);
        void setValues(long max, long n, long pos);
        long getMax(void);
        long getPos(void);
        long getN(void);

        void setCallback(CmCallback *, LONG_CB);
};

class CmSFile : public CmObject {
public:
        CmSFile(CmContainer *parent, const char *fname, MTFont font=DEFAULT_FONT,
                int nrow=10, int ncol=20);

        void setFile(const char *fname);
        void CmSFile::setHMargin(int hm);
};

class CmAbsList : public CmObject {
        friend class CmOptionEdit;
        friend void _ListActivateCB_(MOBJECT p, LIST_ACT *la, void *ud);
        friend void _ListPickCB_(MOBJECT p, LIST_ACT *la, void *ud);
        friend void _ListSelectionCB_(MOBJECT p, LIST_SEL *la, void *ud);
        LISTACT_CB activateCB;
        LISTACT_CB pickCB;
        LISTSEL_CB selectionCB;
protected:
        CmAbsList(void){};
public:
        void setSortCallback(STRCMP_CB cb);
        void setHead(const char *text);
        void setHeadColor(CmColor *bgc, CmColor *fgc);
        void setHMargin(int hm);
        void setItemCheckStatus(const char *item, int status);
        void setHighLightColors(CmColor *bgc, CmColor *fgc);
        inline void setHighLightFGColor(CmColor *fgc);
        inline void setSliderColor(CmColor *cc);
        inline void setSliderColorShift(int perc);

        LIST_ACT *getFirstItem(void);
        LIST_ACT *getFirstSelectedItem(void);
        LIST_ACT *getNextItem(void);
        LIST_ACT *getNextSelectedItem(void);
        LIST_ACT *getFirstUnselectedItem(void);
        LIST_ACT *getNextUnselectedItem(void);
        long      getNItem(void);
        LIST_ACT *getItem(const char *item);
        LIST_ACT *getElement(long n);
        LIST_ACT *getSelected(void);
        int       getItemCheckStatus(const char *item);
        void      getHead(char *buff);

        void selectItem(const char *item);
        void deselectItem(const char *item);
        void selectElement(long n);
        void deselectElement(long n);
        void freeze(void);
        void thaw(void);
        void reset(void);
        void clear(void);
        int  addItem(const char *item, void *data);
        int  delItem(const char *item);
        int  addElement(long n, const char *item, void *data);
        int  delElement(long n);
        void changeItem(const char *old, const char *new_item, void *u_data);
        void changeElement(long n, const char *new_item, void *u_data);
        void enableMultiSelection(void);
        inline void disableMultiSelection(void);
        inline void disableItemMotion(void);
        inline void enableItemMotion(void);
        void setCallback(CmCallback *, LISTACT_CB);
        void setPickCallback(CmCallback *, LISTACT_CB);
        void setSelectionCallback(CmCallback *, LISTSEL_CB);
};

class CmSList : public CmAbsList {
public:
        CmSList(CmContainer *parent, MTFont font, int row_len,
                int nrow, int ncol);
};

class CmEditList : public CmAbsList {
public:
        CmEditList(CmContainer *parent, MTFont font, EL_TEMPLATE *elt,
                int ne, int nrow, int ncol);
        int     addItem(char **argv, void *u_data);
        int     addItemFromEdits(void *u_data);
        void    changeElement(long n, char **new_ele, void *data);
        void    delElement(long n);
        void    seekItem(char **argv, long *pos, void **u_data);
        void    getItemField(const char *item, int ii, char *buff);
        void    getEditText(int ii, char *buff);
        void    setEditText(int ii, const char *buff);
};

class CmClippedSList : public CmAbsList {
        friend void _ClippedListNewBlockCB_(MOBJECT, SBL_NEW_BLOCK *, void *);
        friend void _ClippedListItemSeekCB_(MOBJECT, SBL_ITEM_SEEK *, void *);
        NEWBLOCK_CB newBlockCB;
        ITEMSEEK_CB itemSeekCB;
public:
        CmClippedSList(CmContainer *parent,
                CmCallback *owner, NEWBLOCK_CB nb, ITEMSEEK_CB is,
                MTFont font, int nrow, int ncol, int xc, long xn=0);
};

class CmOptionEdit : public CmAbsEditField {
        CmAbsList *slist;
public:
        ~CmOptionEdit(void);
        CmOptionEdit(CmContainer *parent, const char *text, int len, int clip_len=-1,
                int nrow=10, MTFont font=DEFAULT_FONT);
        CmAbsList *getSList(void) { return slist; };
        void setListCallback(CmCallback *pp, LISTACT_CB cb);
};

class CmMenuBar : public CmObject {
public:
        CmMenuBar(CmContainer *parent, MTFont font);
        void setAcceleratorKey(int key);
        void setHighLightColors(CmColor *bgc, CmColor *fgc);
        void setHighLightFGColor(CmColor *fgc);

};

class CmMenu;

class CmMenuLine : public CmMGUI {
protected:
        friend class CmMenu;
        MENU_ITEM id;
        MOBJECT pdobj;
        CmMenuLine *next;
        virtual ~CmMenuLine(void) {}
};

class CmMenuSeparator : public CmMenuLine {
public:
        CmMenuSeparator(CmMenu *pd);
};

class CmAbsMenuItem : public CmMenuLine {
        friend class CmMenu;
        friend void _MenuItemActivateCB_(MENU_ITEM item, MVALUE status, void *ud);
        MENUITEM_CB itemCB;
        CmCallback *owner;
protected:
        CmAbsMenuItem(CmMenu *pd, CmCallback *ff, MENUITEM_CB cb);
public:
        void setText(const char *text);
        void setSensitive(void);
        void setUnsensitive(void);
        void setAcceleratorKey(int key, const char *a_text=0);
        int  setCheckStatus(int true_false);
        int  getCheckStatus(void);
        const char *getText(void);
        CmMenu *getMenu(void);
        int  toggleCheckStatus(void);
};

class CmMenuItem : public CmAbsMenuItem {
public:
        CmMenuItem(CmMenu *pd, const char *text, CmCallback *ff=0, MENUITEM_CB cb=0, int acc=0, const char *at=0);
};

class CmMenuRadioItem : public CmAbsMenuItem {
public:
        CmMenuRadioItem(CmMenu *pd, const char *text, CmCallback *ff=0, MENUITEM_CB cb=0, int acc=0, const char *at=0);
};

class CmMenuToggleItem : public CmAbsMenuItem {
public:
        CmMenuToggleItem(CmMenu *pd, const char *text, CmCallback *ff=0, MENUITEM_CB cb=0, int acc=0, const char *at=0);
};

class CmMenu : public CmObject {
        friend class CmMenuSeparator;
        friend class CmAbsMenuItem;
        CmMenuLine *list;
        ITEMSEL_CB itemSelCB;
public:
        virtual ~CmMenu(void);
        CmMenu(CmMenuBar *menu, const char *title);
        CmMenu(CmMenuItem *it);
        CmMenu(MTFont font=HELV_MEDIUM);
        void setText(const char *text);
        const char *getText(void);
        void popup(int x, int y);
        void setHighLightColors(CmColor *bgc, CmColor *fgc);
        void setHighLightFGColor(CmColor *fgc);
        void setItemSelectionCallback(CmCallback *, ITEMSEL_CB);
};

class CmTreeNode;

class CmTree : public CmObject {
        MTREENODE_CB openCB;
        MTREENODE_CB closeCB;
        MTREENODE_CB selectCB;
public:
        CmTree(CmContainer *parent, MTFont font, int width, int height, int n_types);

        inline void setImages(int type, const char *norm, const char *open, const char *sel);

        inline void setImages(int type, CmImage *norm, CmImage *open, CmImage *sel);

        inline void setHighLightColors(CmColor *bgc, CmColor *fgc);

        inline void setHighLightFGColor(CmColor *fgc);

        inline void setLineColor(CmColor *color);

        inline void setSliderColor(CmColor *color);

        inline void setSliderColorShift(int percentage);

        CmTreeNode *getSelectedNode(void);

        CmTreeNode *getFirstNode(void);

        void setOpenCallback(CmCallback *owner, MTREENODE_CB cb);
        void setCloseCallback(CmCallback *owner, MTREENODE_CB cb);
        void setSelectCallback(CmCallback *owner, MTREENODE_CB cb);
};

class CmTreeNode : public CmMGUI {
        MTNODE node;
        MTREENODE_CB openCB;
        MTREENODE_CB closeCB;
        MTREENODE_CB selectCB;
public:
        CmTreeNode(CmTree *tree, CmTreeNode *parent, CARD16 type, CARD16 flags,
                                           const char *text);

        inline void destroyContainee(int notify);

        inline void open(int notify);

        inline void close(int notify);

        inline void select(int notify);

        CmTreeNode *getNext(void);
        CmTreeNode *getFirstChild(void);
        CmTreeNode *getParent(void);

        inline char *getPath(char separator, char *buff);

        inline void setImages(CmImage *norm, CmImage *open, CmImage *sel);

        inline void setText(const char *text);

        inline char *getText(char *text);

        inline CARD16 getType(void);

        void setOpenCallback(CmCallback *owner, MTREENODE_CB cb);

        void setCloseCallback(CmCallback *owner, MTREENODE_CB cb);

        void setSelectCallback(CmCallback *owner, MTREENODE_CB cb);
};


#endif

---