%***********************************************************************
%***********************************************************************
%***********************************************************************

\chapter {Quick Reference}

%----------------------------------------------------------------
\Class{CommandObject}

\footnotesize
\begin{verbatim}
//  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
    int Sensitive;      // 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
  } CommandObject;
\end{verbatim}
\normalfont\normalsize

\subsection*{CmdType}

\footnotesize
\begin{verbatim}
                   (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)
\end{verbatim}
\normalfont\normalsize

\subsection*{CmdAttribute}

\footnotesize
\begin{verbatim}
    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]
\end{verbatim}
\normalfont\normalsize

\subsection*{Useful symbolic values}

\footnotesize
\begin{verbatim}
    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
\end{verbatim}
\normalfont\normalsize

%----------------------------------------------------------------
\Class{vApp}

\footnotesize
\begin{verbatim}
//  vApp:  "#include <v/vapp.h>"

    class vApp : public vBaseItem
      {
      public:  //---------------------------------------- public
        vApp(char* appName);
        virtual ~vApp();

        // Methods to override

        virtual void AppCommand(vWindow* win, ItemVal id,
                                ItemVal retval, CmdType ctype);
        virtual void CloseAppWin(vWindow* win);
        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

        int DefaultHeight();
        int DefaultWidth();
        int IsRunning();
        void SendWindowCommandAll(ItemVal id, int val, CmdType ctype);
        void SetValueAll(ItemVal id, int val, ItemSetType setType);
        void SetStringAll(ItemVal id, char* str);
        const char* name();

        vAppWinInfo *getAppWinInfo(vWindow* Win);

        // platform dependent

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

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

\end{verbatim}
\normalfont\normalsize

%----------------------------------------------------------------
\Class{vBrush}

\footnotesize
\begin{verbatim}
//  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 SetFillMode(int fillMode);
        void SetStyle(int style);
      };
\end{verbatim}
\normalfont\normalsize

%----------------------------------------------------------------
\Class{vCanvasPane}

\footnotesize
\begin{verbatim}
//  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 DrawPoint(int x, int y);
        virtual void DrawPolygon(int n, vPoint points[], int fillStyle = vAlternate);
        virtual void DrawRectangle(int x, int y, int width, int height);
        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();

        // Platform dependent
        Widget DrawingWindow();
      };
\end{verbatim}
\normalfont\normalsize

%----------------------------------------------------------------
\Class{vCmdWindow}

\footnotesize
\begin{verbatim}
//  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
      };
\end{verbatim}
\normalfont\normalsize

%----------------------------------------------------------------
\Class{vColor}

\footnotesize
\begin{verbatim}
//  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
\end{verbatim}
\normalfont\normalsize

%----------------------------------------------------------------
\Class{vDebugDialog}

\footnotesize
\begin{verbatim}
//  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();
      };
\end{verbatim}
\normalfont\normalsize

\subsection* {Command Line Switches}
\begin{description}
\item [-vDebug SU$<$list$>$] Turn on System or User (or both) 
debug messages in list.
\item [c] Command events (menu, dialog commands).
\item [m] Mouse events.
\item [w] Window events (resize, redraw).
\item [b] Build events.
\item [o] Other misc. events.
\item [v] Bad values.
\item [C] Constructors.
\item [D] Destructors.
\item [123] User items 1, 2, or 3.
\end{description}

%----------------------------------------------------------------
\Class{vDialog}

\footnotesize
\begin{verbatim}
//  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);
      };
\end{verbatim}
\normalfont\normalsize

%----------------------------------------------------------------
\Class{vFileSelect}

\footnotesize
\begin{verbatim}
//  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);
      };
\end{verbatim}
\normalfont\normalsize

%----------------------------------------------------------------
\Class{vFont}

\footnotesize
\begin{verbatim}
//  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
\end{verbatim}
\normalfont\normalsize


%----------------------------------------------------------------
\Class{vFontSelect}

\footnotesize
\begin{verbatim}
//  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
\end{verbatim}
\normalfont\normalsize

%----------------------------------------------------------------
\Class{vIcon}

\footnotesize
\begin{verbatim}
    // <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
      };
\end{verbatim}
\normalfont\normalsize

%----------------------------------------------------------------
\Class{vMenu}

\footnotesize
\begin{verbatim}
//  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;
\end{verbatim}
\normalfont\normalsize

\subsection*{Useful symbolic values}

\footnotesize
\begin{verbatim}
    isSens:           Is sensitive
    notSens:          Not sensitive
    noSub:            No submenu
    isChk:            Is checked
    notChk:           Not checked
    noKey:            No accelerator specified
    noKeyLbl:         No accelerator label
\end{verbatim}
\normalfont\normalsize

%----------------------------------------------------------------
\Class{vModalDialog}
\footnotesize
\begin{verbatim}
//  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
      };
\end{verbatim}
\normalfont\normalsize

%----------------------------------------------------------------
\Class{vNoticeDialog}

\footnotesize
\begin{verbatim}
//  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);
      };
\end{verbatim}
\normalfont\normalsize

%----------------------------------------------------------------
\Class{vPen}

\footnotesize
\begin{verbatim}
//  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();
      };
\end{verbatim}
\normalfont\normalsize

%----------------------------------------------------------------
\Class{vReplyDialog}

\footnotesize
\begin{verbatim}
//  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);
      };
\end{verbatim}
\normalfont\normalsize

%----------------------------------------------------------------
\Class{vStatus}

\footnotesize
\begin{verbatim}
//  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;
\end{verbatim}
\normalfont\normalsize

\subsection*{Useful symbolic values}

\footnotesize
\begin{verbatim}
    CA_NoBorder:      No border (frames, status bar)
    CA_None:          No special attributes
    isSens:           Is sensitive
    notSens:          Not sensitive
    noIcon:           No icon
\end{verbatim}
\normalfont\normalsize

%----------------------------------------------------------------
\Class{vTextCanvasPane}

\footnotesize
\begin{verbatim}
//  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);
      };
\end{verbatim}
\normalfont\normalsize

%----------------------------------------------------------------
\Class{vTimer}

\footnotesize
\begin{verbatim}
//  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);
      };
\end{verbatim}
\normalfont\normalsize

%----------------------------------------------------------------
\Class{V Utilities}

\footnotesize
\begin{verbatim}
//  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);
\end{verbatim}
\normalfont\normalsize

%----------------------------------------------------------------
\Class{vWindow}

\footnotesize
\begin{verbatim}
//  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);
      };
\end{verbatim}
\normalfont\normalsize
%----------------------------------------------------------------
\Class{vYNReplyDialog}

\footnotesize
\begin{verbatim}
//  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);
      };
\end{verbatim}
\normalfont\normalsize
