# Quick Reference

## CommandObject

    //  CommandObject: "#include <v/v_defs.h>"

    typedef struct CommandObject
      {
        CmdType cmdType;    // what kind of item is this
        ItemVal cmdId;      // unique id for the item
        ItemVal retVal;     // value returned when picked
        char* title;        // string
        void* itemList;     // used when cmd needs a list
        CmdAttribute attrs; // list of attributes
        unsigned
           Sensitive : 1;   // if item is sensitive or not
        ItemVal cFrame;     // Frame used for an item
        ItemVal cRightOf;   // Item placed left of this id
        ItemVal cBelow;     // Item placed below this one
        int size;           // Optional - for size information
        char* tip;		// Optional tip string
      } CommandObject;

### CmdType

                       (with suggested prefix for id names)
        C_EndOfList:   Used to denote end of command list
        C_Blank:       filler to help RightOfs, Belows work (blk)
        C_BoxedLabel:  a label with a box (bxl)
        C_Button:      Button (btn)
        C_CheckBox:    Checked Item (chk)
        C_ColorButton: Colored button (cbt)
        C_ColorLabel:  Colored label (clb)
        C_ComboBox:    Popup combo list (cbx)
        C_Frame:       General purpose frame (frm)
        C_Icon:        a display only Icon (ico)
        C_IconButton:  a command button Icon (icb)
        C_Label:       Regular text label (lbl)
        C_List:        List of items (lst)
        C_ProgressBar: Bar to show progress (pbr)
        C_RadioButton: Radio button (rdb)
        C_Slider:      Slider to enter value (sld)
        C_Spinner:     Spinner value entry (spn)
        C_TextIn:      Text input field (txi)
        C_Text:        wrapping text out (txt)
        C_ToggleButton: a toggle button (tbt)
        C_ToggleFrame: a toggle frame (tfr)
        C_ToggleIconButton:  a toggle Icon button (tib)

### CmdAttribute

        CA_DefaultButton: Special Default Button
           [Used by: C_Button]
        CA_Hidden:        Starts out hidden
           [All controls]
        CA_Horizontal:    Horizontal orientation
           [C_ProgressBar, C_Slider]
        CA_Large:         Command larger than normal
           [C_List C_ProgressBar, C_Slider, C_Spinner, C_TextIn]
        CA_MainMsg:       Gets replacement message
           [C_Label]
        CA_NoBorder:      No border (frames, status bar)
           [C_Frame,C_ToggleFrame,C_Text,status bar]
        CA_NoLabel:       No label on progress bar
           [C_ProgressBar]
        CA_NoNotify:      Don't notify on all events
           [C_ComboBox,C_List,C_Spinner]
        CA_NoSpace:       No space between widgets
           [C_Frame,C_ToggleFrame]
        CA_None:          No special attributes
           [All controls]
        CA_Percent:       Use % on progress bar
           [C_ProgressBar]
        CA_Small:         Command smaller than normal
           [C_ProgressBar,C_TextIn]
        CA_Size:          Specify size
           [C_Button,C_List,C_Spinner]
        CA_Text:          A Text value box
           [C_Spinner]
        CA_Vertical:      Vertical orientation
           [C_ProgressBar, C_Slider]

### Useful symbolic values

        NoList:           No list used
        NoFrame:          Not a member of a frame
        isSens:           Is sensitive
        notSens:          Not sensitive
        isChk:            Is checked
        notChk:           Not checked
        notUsed:          Not used
        noIcon:           No icon

## vApp

    //  vApp:  "#include <v/vapp.h>"

        class vApp : public vBaseItem
          {
          public:  //---------------------------------------- public
            vApp(VCONST char* appName, int simSDI = 0, int frameHeight = 0,
                int frameWidth = 0);      // constructor
            virtual ~vApp();

            // Methods to override

            virtual void AppCommand(vWindow* win, ItemVal id,
                                    ItemVal retval, CmdType ctype);
            virtual void CloseAppWin(vWindow* win);
            virtual void CloseLastCmdWindow(vWindow* win, int exitcode);
            virtual void Exit(void);
            virtual void KeyIn(vWindow* win, vKey key, unsigned int shift);
            virtual vWindow* NewAppWin(vWindow* win, char* name, int w, int h,
                                   vAppWinInfo* winInfo = 0);
            // Utility methods

            vFont GetDefaultFont(void);
            void GetVVersion(int& major, int& minor);
            int DefaultHeight();
            int DefaultWidth();
            int IsRunning();
            void SendWindowCommandAll(ItemVal id, int val, CmdType ctype);
            void SetAppTitle(char* title);
            void SetValueAll(ItemVal id, int val, ItemSetType setType);
            void SetStringAll(ItemVal id, char* str);
            void UpdateAllViews(vWindow* sender = NULL, int hint = 0,
                   void* pHint = NULL);
            const char* name();

            vAppWinInfo *getAppWinInfo(vWindow* Win);

            // Clipboard

            int ClipboardSetText(char* text);
            char* ClipboardGetText();
            int ClipboardCheckText();
            void ClipboardClear();

            // Tasking

    	void CheckEvents();

    	int EnableWorkSlice(long slice);
    	virtual void WorkSlice();

            // X platform dependent

            Display* display();           // To get the X display
            XtAppContext appContext();    // To get the context

            // MS-Windows platform dependent
            int simSDI();
          };

        extern vApp *theApp;     // Pointer to single global instance
        extern int AppMain(int argc, char** argv);  // Pseudo main program

## vAppWinInfo

    //  vAppWinInfo:  "#include <v/vawinfo.h>"
        class V_EXPORT vAppWinInfo
          {
          public:     //---------------------------------------- public

            vAppWinInfo(VCONST char* name = "", VCONST void* ptr = 0);
            virtual ~vAppWinInfo();

            virtual VCONST char* infoName() {return _infoName;}
            virtual VCONST void* getPtr() {return _ptr;}
          };

## vBrush

    //  vBrush:  "#include <v/vbrush.h>"
        class vBrush
          {
          public:       //-------------------------------- public
            vBrush(unsigned int r = 0, unsigned int g = 0, unsigned int b = 0,
                   int style = vSolid, int fillMode = vAlternate);
            ~vBrush();

            int operator ==(vBrush b2);
            int operator !=(vBrush b2);

            vColor GetColor();
            int GetFillMode();
            int GetStyle();
            void SetColor(vColor c);
            void SetColor(unsigned int r, unsigned int g, unsigned int b);
            void SetFillMode(int fillMode);
            void SetStyle(int style);
          };

## vCanvasPane

    //  vCanvasPane:  "#include <v/vcanvas.h>"

        class vCanvasPane
          {
          public:   //---------------------------------------- public

            vCanvasPane(PaneType pt = P_Canvas);
            virtual ~vCanvasPane();

            virtual void ShowPane(int OnOrOff);

            // Cursor
            void SetCursor(VCursor id);
            VCursor GetCursor();
            void UnSetCursor(void);

            // Scrolling
            virtual void HPage(int Shown, int Top);
            virtual void VPage(int Shown, int Top);
            virtual void HScroll(int step);
            virtual void VScroll(int step);
            virtual void SetHScroll(int Shown, int Top);
            virtual void SetVScroll(int Shown, int Top);
            virtual int GetHScroll(int& Shown, int& Top);
            virtual int GetVScroll(int& Shown, int& Top);
            virtual void ShowHScroll(int OnOff);
            virtual void ShowVScroll(int OnOff);

            // Change messages
            virtual void FontChanged(vFont vf);

            // Events
            virtual void MouseDown(int x, int y, int button);
            virtual void MouseUp(int x, int y, int button);
            virtual void MouseMove(int x, int y, int button);
            virtual void EnterFocus();
            virtual void LeaveFocus();

            // Expose/redraw events
            virtual void Redraw(int x, int y, int width , int height);
            virtual void Resize(int newW, int newH);

            // Information
            virtual int GetWidth();
            virtual int GetHeight();

            // Drawing
            void Clear(void);
            virtual void ClearRect(int left, int top, int width, int height);
            virtual void DrawAttrText(int x, int y, char* text, const ChrAttr attr);
            virtual void DrawColorPoints(int x, int y, int nPoints, vColor* pts);
            virtual void DrawText(int x, int y, char* text);
            virtual void DrawEllipse(int x, int y, int width, int height);
            virtual void DrawIcon(int x, int y, vIcon& icon);
            virtual void DrawLine(int x, int y, int xend , int yend);
            virtual void DrawLines(vLine* lineList, int count);
            virtual void DrawPoint(int x, int y);
            virtual void DrawPoints(vPoint* pointList, int count);
            virtual void DrawPolygon(int n, vPoint points[], int fillStyle = vAlternate);
            virtual void DrawRectangle(int x, int y, int width, int height);
            virtual void DrawRectangles(vRect* rectList, int count);
            virtual void DrawRoundedRectangle(int x, int y, int width, int height, int radius);
            virtual void DrawRubberLine(int x, int y, int xend, int yend);
            virtual void DrawRubberEllipse(int x, int y, int width, int height);
            virtual void DrawRubberRectangle(int x, int y, int width, int height);
            virtual vBrush GetBrush(void);
            virtual void SetBrush(vBrush brush);
            virtual vFont GetFont(void);
            virtual void SetFont(vFont fnt);
            virtual int TextWidth(char* str);
            virtual int TextHeight(int& ascent, int& descent);
            vDC* GetDC();

            // Appearance
            virtual void SetScale(int mult, int div);
            virtual void GetScale(int& mult, int& div);
            virtual void SetBackground(vColor color);
            virtual void SetPen(vPen pen);
            vPen GetPen();
            void SetTranslate(int x, int y);
            void SetTransX(int x);
            void SetTransY(int y);
            void GetTranslate(int& x, int& y);
            int GetTransX();
            int GetTransY();

            // X Platform dependent
            Widget DrawingWindow();
    	// Windows Platform dependent
    	HWND DrawingWindow();
          };

## vCmdWindow

    //  vCmdWindow:  "#include <v/vcmdwin.h>"

        class vCmdWindow : public vWindow
          {
          public:           //----------------------------------- public
            vCmdWindow(char* name = "+", int width = 0, int height = 0);
            virtual ~vCmdWindow();                         // Destructor

            virtual void CloseWin(void);    // callback for close button
          };

## vColor

    //  vColor:  "#include <v/vcolor.h>"

    // Message constants for use in Color buttons (for color buttons, etc.)

            M_Black, M_Red, M_DimRed, M_Green, M_DimGreen, M_Blue, M_DimBlue,
            M_Yellow, M_DimYellow, M_Magenta, M_DimMagenta, M_Cyan, M_DimCyan,
            M_DarkGray, M_MedGray, M_White,
            M_ColorFrame

    // Index constants into V "standard" color arrays: vStdColors, vColorNames.

            vC_Black, vC_Red, vC_DimRed, vC_Green, vC_DimGreen, vC_Blue, vC_DimBlue,
            vC_Yellow, vC_DimYellow, vC_Magenta, vC_DimMagenta, vC_Cyan, vC_DimCyan,
            vC_DarkGray, vC_MedGray, vC_White

        class vColor
          {
          public:    //---------------------------------------- public
            vColor(unsigned int rd = 0, unsigned int gr = 0, unsigned int bl = 0);
            ~vColor();

            int operator ==(vColor c2);
            int operator !=(vColor c2);
            int BitsOfColor();
            ResetColor(unsigned int rd = 0, unsigned int gr = 0, unsigned int bl = 0);
            Set(unsigned int rd = 0, unsigned int gr = 0, unsigned int bl = 0);
            Set(vColor& c);
            void SetR(unsigned int rd = 0);
            void SetG(unsigned int gr = 0);
            void SetB(unsigned int bl = 0);

            unsigned int r();
            unsigned int g();
            unsigned int b();
          };

        extern vColor vStdColors[16];       // 16 "standard" colors
        extern char* vColorNames[16];       // and their names

## vDebugDialog

    //  vDebugDialog:  "#include <v/vdebug.h>"

        class vDebugDialog : public vModalDialog
          {
          public:    //---------------------------------------- public
            vDebugDialog(vBaseWindow* bw,char* title = "Debugging Options");
            vDebugDialog(vApp* aw,char* title = "Debugging Options");
            ~vDebugDialog();
            void SetDebug();
          };

### Command Line Switches

-vDebug SU < list >
  Turn on System or User (or both) debug messages in list.
c
  Command events (menu, dialog commands).
m
  Mouse events.
w
  Window events (resize, redraw).
b
  Build events.
o
  Other misc. events.
v
  Bad values.
C
  Constructors.
D
  Destructors.
123
  User items 1, 2, or 3.

## vDialog

    //  vDialog:  "#include <v/vdialog.h>"

        class vDialog
          {
          public:             //------------------------------------ public

            vDialog(vBaseWindow* creator, int modal = 0, char* title = "");
            vDialog(vApp* creator, int modal = 0, char* title = "");
            ~vDialog();

            WindowType wType();

            virtual void AddDialogCmds(CommandObject* cList);
            virtual void CancelDialog(void);
            virtual void CloseDialog(void);
            virtual void SetDialogTitle(char * title);
            virtual void DialogCommand(ItemVal id, ItemVal retval, CmdType ctype);
            virtual int GetTextIn(ItemVal id, char* strout, int maxlen);
            virtual int GetValue(ItemVal id);
            virtual void SetValue(ItemVal id, ItemVal val, ItemSetType setType);
            virtual void SetString(ItemVal id, char* str);
            int IsDisplayed(void);
            virtual void ShowDialog(const char* msg);
          };

## vFileSelect

    //  vFileSelect:  "#include <v/vfilesel.h>"

        class vFileSelect : protected vModalDialog
          {
          public:     //---------------------------------------- public
            vFileSelect(vBaseWindow* bw, char* title = "File Select");
            vFileSelect(vApp* aw, char* title = "File Select");
            ~vFileSelect();

            int FileSelect(const char* msg, char* filename,
                const int maxlen, char** filter);
            int FileSelectSave(const char* msg, char* filename,
                const int maxlen, char** filter);
          };

## vFont

    //  vFont:  "#include <v/vfont.h>"
        enum vFontID                // various font related ids
          {
            vfDefaultSystem,        // the default system font
            vfDefaultFixed,         // the system default fixed font
            vfDefaultVariable,      // the system default variable font
            vfSerif,                // serifed font - TimesRoman
            vfSansSerif,            // SansSerif - Swiss or Helvetica
            vfFixed,                // fixed font - Courier
            vfDecorative,           // decorative - dingbat
            vfOtherFont,            // for all other fonts
            vfNormal,               // normal style, weight
            vfBold,                 // boldface
            vfItalic,               // italic style
            vfEndOfList
          };

        class vFont         // make the font stuff a class to make it portable
          {
          public:           //---------------------------------------- public
            vFont(vFontID fam = vfDefaultFixed, int size = 10,
               vFontID sty = vfNormal, vFontID wt = vfNormal, int und = 0,
               int angle = 0);
            ~vFont();

            vFontID GetFamily() { return _family; }
            int GetPointSize() { return _pointSize; }
            vFontID GetStyle() { return _style; }
            vFontID GetWeight() { return _weight; }
            int GetUnderlined() { return _underlined; }
            void SetFontValues(vFontID fam = vfDefaultFixed, int size = 10,
               vFontID sty = vfNormal, vFontID wt = vfNormal, int und = 0);
          };
    #endif

## vFontSelect

    //  vFontSelect:  "#include <v/vfontsel.h>"

        class vFontSelect : protected vModalDialog
          {
          public:       //---------------------------------------- public
            vFontSelect(vBaseWindow* bw, char* title = "Select Font");
            vFontSelect(vApp* aw, char* title = "Select Font");
           ~vFontSelect();

           int FontSelect(vFont& font, const char* msg = "Select Font" );
          };
    #endif

## vIcon

        // <v/vicon.h>

        class vIcon     // an icon
          {
          public:             //---------------------------------------- public
            vIcon(unsigned char* ic, int h, int w, int d = 1);
            ~vIcon();
            int height;             // height in pixels
            int width;              // width in pixels
            int depth;              // bits per pixel
            unsigned char* icon;    // ptr to icon array

          protected:        //--------------------------------------- protected
          private:          //--------------------------------------- private
          };

## vMenu

    //  vMenu:  "#include <v/v_menu.h>"

        typedef struct vMenu
          {
            char* label;       // The label on the menu
            ItemVal menuId;    // A User assigned unique id
            unsigned
              sensitive : 1,   // If item is sensitive or not
              checked : 1;     // If item is checked or not
            char* keyLabel;    // Label for an accelerator key
            vKey accel;        // Value of accelerator key
            vMenu* SubMenu;    // Ptr to a submenu
          } MenuItem;

### Useful symbolic values

        isSens:           Is sensitive
        notSens:          Not sensitive
        noSub:            No submenu
        isChk:            Is checked
        notChk:           Not checked
        noKey:            No accelerator specified
        noKeyLbl:         No accelerator label

## vModalDialog

    //  vModalDialog:  "#include <v/vmodald.h>"

        class vModalDialog : public vDialog
          {
          public:   //---------------------------------------- public

            vModalDialog(vBaseWindow* creator, char* title = "");
            vModalDialog(vApp* creator, char* title = "");
            virtual ~vModalDialog();

            virtual ItemVal ShowModalDialog(const char* msg, ItemVal& retval);

            // rest are inherited from vDialog
          };

## vNoticeDialog

    //  vNoticeDialog:  "#include <v/vnotice.h>"

        class vNoticeDialog : protected vModalDialog
          {
          public:    //---------------------------------------- public
            vNoticeDialog(vBaseWindow* bw, char* title = "Notice");
            vNoticeDialog(vApp* aw, char* title = "Notice");
            ~vNoticeDialog();

            void Notice(char* msg);
          };

## vPen

    //  vPen:  "#include <v/vpen.h>"

        class vPen
          {
          public:    //---------------------------------------- public
            vPen(unsigned int r = 0, unsigned int g = 0,
                 unsigned int b = 0, int width = 1, int style = vSolid);
            ~vPen();

            int operator ==(vPen p2);
            int operator !=(vPen p2);

            void SetStyle(int style);
            int GetStyle(void);
            void SetWidth(int width);
            int GetWidth();
            void SetColor(vColor c);
            vColor GetColor();
          };

## vReplyDialog

    //  vReplyDialog:  "#include <v/vreply.h>"

        class vReplyDialog : protected vModalDialog
          {
          public:   //---------------------------------------- public
            vReplyDialog(vBaseWindow* bw, char* title = "Reply");
            vReplyDialog(vApp *aw, char* title = "Reply");

            int Reply(const char* msg, char* reply, const int maxlen);
          };

## vStatus

    //  vStatus:  "#include <v/v_defs.h>"

        typedef struct vStatus      // for status bars
          {
            char* label;            // text label
            ItemVal statId;         // id
            CmdAttribute attrs;     // attributes - CA_NoBorder, CA_None
            unsigned sensitive : 1; // if button is sensitive or not
            int width;              // to specify width (0 for default)
          } vButton;

### Useful symbolic values

        CA_NoBorder:      No border (frames, status bar)
        CA_None:          No special attributes
        isSens:           Is sensitive
        notSens:          Not sensitive
        noIcon:           No icon

## vTextCanvasPane

    //  vTextCanvasPane:  "#include <v/vtextcnv.h>"

        class vTextCanvasPane : public vCanvasPane
          {
          public:  //---------------------------------------- public
            vTextCanvasPane();
            virtual ~vTextCanvasPane();

            // Window management/drawing

            virtual void Clear(void);
            virtual void ClearRow(const int r, const int c);
            virtual void ClearToEnd(const int r, const int c);
            int GetCols();
            int GetRows();
            void GetRC(int& r, int& c);
            void GotoRC(const int r, const int c);
            virtual void DrawAttrText(const char* text, const ChrAttr attr);
            virtual void DrawChar(const char chr, const ChrAttr attr);
            virtual void DrawText(const char* text);
            void HideTextCursor(void);
            void ShowTextCursor(void);

            // Scrolling
            void ScrollText(const int lineCount);

            // Events
            virtual void ResizeText(const int rows, const int cols);
            virtual void TextMouseDown(int row, int col, int button);
            virtual void TextMouseUp(int row, int col, int button);
            virtual void TextMouseMove(int row, int col, int button);
          };

## vTimer

    //  vTimer:  "#include <v/vtimer.h>"

        class vTimer
          {
          public:   //---------------------------------------- public
            vTimer();
            virtual ~vTimer();

            virtual int TimerSet(long interval);
            virtual void TimerStop(void);
            virtual void TimerTick(void);
          };

## V Utilities

    //  V Utilities:  "#include <v/vutil.h>"

        extern void LongToStr(long intg, char* str);
        extern void IntToStr(int intg, char* str);
        extern void vGetLocalTime(char* tm);
        extern void vGetLocalDate(char* tm);

## vWindow

    //  vWindow:  "#include <v/vwindow.h>"

        enum WindowType
          { WINDOW, CMDWINDOW, DIALOG };  // Types of windows

        class vWindow
          {
          public:           //-------------------------------- public
            vWindow(char *name = "+", int width = 0, int height = 0,
               WindowType wintype = WINDOW);    // Constructor

            virtual ~vWindow();                 // Destructor

            // Methods to Override

            virtual void KeyIn(vKey keysym, unsigned int shift);
            virtual void MenuCommand(ItemVal id);
            virtual void WindowCommand(ItemVal id, ItemVal retval, CmdType ctype);

            // Utility Methods

            const Widget vHandle();         // X only - native handle
            const char* name();             // the name set
            virtual void ShowWindow(void);
            WindowType wType();          // what kind of window we are

            virtual void AddPane(vPane* add_pane);
            virtual void CloseWin(void);
            virtual int GetValue(ItemVal id);
            virtual void RaiseWindow(void);
            virtual void SetString(ItemVal id, char* str);
            virtual void SetStringAll(ItemVal id, char* str);
            virtual void SetTitle(char* title);
            virtual void SetValue(ItemVal id, int val, ItemSetType setType);
            virtual void SetValueAll(ItemVal id, int val, ItemSetType setType);
            void ShowPane(vPane* wpane, int OnOrOff);
          };

## vYNReplyDialog

    //  vYNReplyDialog:  "#include <v/vynreply.h>"

        class vYNReplyDialog : protected vModalDialog
          {
          public:     //---------------------------------------- public
            vYNReplyDialog(vBaseWindow* bw, char* title = "Yes or No");
            vYNReplyDialog(vApp* aw, char* title = "Yes or No");
            ~vYNReplyDialog();

            int AskYN(const char* msg);
          };