The <dialogs.h> Header File

Routines for creating dialogs

Functions

Dialog
Shows and activates a dialog box given a pointer to a dialog structure.
DialogAdd
Adds an item into a dialog box.
DialogAddDynamicPulldown
Adds a dynamic pulldown menu into a dialog box.
DialogAddDynamicRequest
Adds a request/edit box with a dynamic buffer into a dialog box.
DialogAddMenu
Adds a menu into a dialog box.
DialogAddPulldown
Adds a pulldown/popup menu into a dialog box.
DialogAddPulldownEx
Adds a pulldown/popup menu into a dialog box. Extended version.
DialogAddRequest
Adds a request/edit box into a dialog box.
DialogAddRequestEx
Adds a request/edit box into a dialog box. Extended version.
DialogAddScrollRegion
Adds a rectangular item-scrolling region to a dialog box.
DialogAddStaticPulldown
Adds a static pulldown/popup menu into a dialog box.
DialogAddText
Adds a text into a dialog box.
DialogAddTextEx
Adds a text, an image, or a custom item into a dialog box.
DialogAddTitle
Adds a title bar and up to two buttons into a dialog box.
DialogAddTitleEx
Adds a title/header bar and up to two buttons into a dialog box. Extended version.
DialogAddXFlags
Adds extended dialog properties into a dialog box.
DialogDo
Activates and shows a dialog box.
DialogNew
Creates a new dialog box which can interact with the user program.
DialogNewSimple
Creates a new dialog box.
DlgMessage
Displays a message dialog box.
HI_WORD
Returns the high word from a long value.
LO_WORD
Returns the low word from a long value.
NoCallBack
Dummy callback function doing nothing.
VarNew
Displays the standard "New" dialog.
VarOpen
Displays the standard "Open" dialog.
VarSaveAs
Displays the standard "Save Copy As" dialog.

Constants

CENTER
A constant to describe a centered position for dialogs.
DialogMessages
An enumeration to describe messages used by a Dialog's Callback.
H_NULL
A null-handle value.
NULL
A null-pointer value.

Predefined Types

Bool
An enumeration to describe true or false values.
Buttons
An enumeration to describe possible button types.
Dialog_Callback_t
Callback function type for dialogs.
Dialog_GetHandle_t
Callback function type returning a handle for a dialog item.
DIALOG_ITEM
A scructure for defining dialog items.
DIALOG
A scructure for defining dialogs.
DialogFlags
An enumeration to describe possible item flags in a dialog box.
DialogTypes
An enumeration to describe possible item types in a dialog box.
DialogXFlags
An enumeration to describe possible XFlags in a dialog box.
ESQ
Represents a quantum within an expression.
HANDLE
Represents a handle associated with an allocated memory block.
HSym
A structure representing a symbol reference.
OWNER_DRAW_STRUCT
A scructure for defining an owner draw item.
SCR_RECT
A scructure for defining a rectangular area.
SCR_STATE
A structure for saving the state of the graphics system.
WINDOW
The main window-describing structure.

Other Identifiers

SIZED_DIALOG
A macro to help defining dialogs, it is nearly the same as DIALOG.

Note: If your program uses functions from this header file, you probably have to define SET_FILE_IN_USE_BIT.


Dialog

short Dialog (DIALOG *DialogPtr, short x, short y, char *RequestBuffer, short *PopupBuffer);

Shows and activates a dialog box given a pointer to a dialog structure.

Dialog works exactly like DialogDo, except instead of the handle, a pointer to the dialog structure is given as the parameter. DialogDo internally calls HeapDeref, then passes the returned pointer to the Dialog function. This function is mainly used internally in TIOS. Its advantage compared to DialogDo is the fact that the complete dialog structure may be given as a static pre-filled array of bytes, and you can give a pointer to such a structure to the Dialog function. It will save a lot of memory, because you do not need to call DialogNew and a lot of functions like DialogAddText etc.

If DialogPtr points to a dynamically created dialog box (i.e a dialog created with DialogNew or DialogAdd), the heap block that stores the dialog box must be locked because this routine may cause heap compression.

Dialog may return:

See also: DialogDo


DialogAdd

HANDLE DialogAdd (HANDLE Handle, short flags, short x, short y, short ItemType, ...);

Adds an item into a dialog box.

DialogAdd is a universal item-adding function. It is a very complicated function which accepts 6 to 12 parameters depending on the type of the item which will be added. This type is determined by the ItemType parameter. In fact, all other functions whose names begin with "DialogAdd..." (such as DialogAddTextEx, DialogAddTitleEx, DialogAddRequestEx, DialogAddPulldownEx, etc.) are implemented as macros which call DialogAdd with appropriate parameters (for easier usage), so you can mainly avoid this function. You can read the dialogs.h header file to see how exactly these macros are implemented.

The order of item creation is very important, as it automatically gives each item an identification number (the first created item will get an identification number of 0, the second one will get 1, and so on). Every function that creates an item (i.e. every function beginning with 'DialogAdd...') will increase this identification number.

DialogAdd returns H_NULL in case of an error, may return DB_MEMFULL if you used DF_SCREEN_SAVE, else returns Handle. This routine (as well as all other 'DialogAdd...' routines) may cause heap compression.

ItemType can be filled with one of the following commands, defined in the DialogTypes enum:

ItemType Appearance Additional Parameters Macro
D_HEADER Title bar, up to two buttons const char *title, unsigned short LeftButton, unsigned short RightButton DialogAddTitleEx
D_TEXT Text or personalized item const char *text DialogAddTextEx
D_EDIT_FIELD Request (edit) box const char *label, unsigned short offset, unsigned short MaxLen, unsigned short width DialogAddRequestEx
D_HEDIT Request (edit) box const char *label, unsigned short width DialogAddDynamicRequest
D_POPUP Pulldown menu const char *label, void *Popup, unsigned short buffer DialogAddStaticPulldown
D_DYNPOPUP AMS 2.00 or higher: Pulldown menu const char *label, Dialog_GetHandle_t GetPopup, unsigned short index DialogAddDynamicPulldown
D_HPOPUP Pulldown menu const char *label, HANDLE MenuHandle, unsigned short index DialogAddPulldownEx
D_MENU AMS 2.00 or higher: Main menu void *Menu, unsigned short MaxMenuWidth DialogAddMenu
D_SCROLL_REGION Scroll region unsigned short x1, unsigned short y1, unsigned short FirstItem, unsigned short LastItem, unsigned short NumDspItems, unsigned short TotNumItems, unsigned short ItemHeight DialogAddScrollRegion
D_XFLAGS AMS 2.00 or higher: Extended dialog properties unsigned short xFlags1, unsigned short xFlags2, unsigned short xFlags3, unsigned short xFlags4 DialogAddXFlags

The parameter flags depends on the type of element you are creating and can be a combination of the following flags, defined in the DialogFlags enum:

Flag Item Type Description
DF_SCREEN_SAVE (any) When applied to the first item in the dialog, the dialog code saves the area underneath the dialog box when it is started. DialogAdd returns DB_MEMFULL if there is not enough memory to do this.
DF_SKIP (any) This item is skipped when browsing through items with the arrow keys. For example, all text items should have this flag set.
DF_SCROLLABLE (any) Set this flag if you want this item to be scrollable in a scroll region.
DF_TAB_ELLIPSES Request box, pulldown menu Lines the item up on the right side of the dialog, and draws '......' between the item and its label. This flag is used in the TIOS 'MODE' dialog, for example. It is the default on AMS 1.xx.
DF_TAB_SPACES Request box, pulldown menu AMS 2.00 or higher: Like DF_TAB_ELLIPSES, but does not draw any dots.
DF_OWNER_DRAW Text AMS 2.00 or higher: The callback function (see DialogNew for more information) is responsible for drawing this item (which can be text, an image, or anything else). This can only be done if the dialog was created with DialogNew and not DialogNewSimple.
DF_POPUP_RADIO Pulldown menu AMS 2.00 or higher: If this flag is set, the item looks like a normal pulldown menu that you can select, but when you press the right arrow key, it does not pop up as usual, but returns control to the dialog callback function. This enables the programmer to do whatever he/she wants. For example, in the 'MODE' dialog, setting custom units pops up another dialog instead of a pulldown menu.
DF_MAX_MENU_WIDTH Main menu AMS 2.00 or higher: Passes MBF_MAX_MENU_WIDTH to MenuBegin when the menu is drawn.
DF_CLR_ON_REDRAW Scroll region Clears the entire visible scroll region when redrawn. If you do not set this flag, the scroll region will not be cleared before being redrawn, and you might still see the previously drawn items underneath the new ones.

Note: If you want your program to work in AMS 1.xx, you cannot pass D_MENU, D_DYNPOPUP, and D_XFLAGS to this function. Nevertheless, you can initialize a DIALOG structure with these items, and the program will still work on AMS 1.xx.

See also: DialogDo, DialogNew, DIALOG


DialogAddDynamicPulldown

AMS 2.00 or higher

HANDLE DialogAddDynamicPulldown (HANDLE Handle, short flags, short x, short y, const char *label, Dialog_GetHandle_t GetPopup, unsigned short index);

Adds a dynamic pulldown menu into a dialog box.

DialogAddDynamicPulldown adds a pulldown item to the dialog box associated with the handle Handle at the position (x,y), where the coordinates are relative to the top-left corner of the dialog box.

When the pulldown is opened, the function passed to the GetPopup parameter is called (with the identification number of the newly created item as the value of the ID parameter), and it must return the handle of the actual popup menu (usually created using PopupNew). See menus.h for more information about creating popups.

An optional label label will appear in front of the request box; an empty string is used to indicate that no label should be drawn. The parameter index determines where the result value of executing the pulldown menu will be stored, and also indicates what the initially selected option will be. See DialogDo for information on how and where the result values are actually stored.

The order of item creation is very important, as it automatically gives each item an identification number (the first created item will get an identification number of 0, the second one will get 1, and so on). Every function that creates an item (i.e. every function beginning with 'DialogAdd...') will increase this identification number.

The parameter flags can be a combination of the following, defined in the DialogFlags enumeration:
DF_SCROLLABLE Set this flag if you want this item to be scrollable in a scroll region.
DF_SKIP This item is skipped when browsing through items with the arrow keys.
DF_SCREEN_SAVE The dialog code saves the area underneath the dialog box when it is started, DB_MEMFULL returned if it cannot. If you wish to use this flag, you must then set it with the first item you created in the dialog box.
DF_TAB_ELLIPSES Lines the item up on the right side of the dialog, and draws '......' between the item and its label. This flag is used in the TIOS 'MODE' dialog, for example. It is the default on AMS 1.xx.
DF_TAB_SPACES AMS 2.00 or higher: Like DF_TAB_ELLIPSES, but does not draw any dots.
DF_POPUP_RADIO AMS 2.00 or higher: If this flag is set, the item looks like a normal pulldown menu that you can select, but when you press the right arrow key, it does not pop up as usual, but returns control to the dialog callback function. This enables the programmer to do whatever he/she wants. For example, in the 'MODE' dialog, setting custom units pops up another dialog instead of a pulldown menu.

DialogAddDynamicPulldown returns H_NULL in case of an error, may return DB_MEMFULL if you used DF_SCREEN_SAVE, else returns Handle. This routine (as well as all other 'DialogAdd...' routines) may cause heap compression.

DialogAddDynamicPulldown is in fact a macro created for your convenience. It calls DialogAdd with D_DYNPOPUP as the ItemType parameter.


DialogAddDynamicRequest

HANDLE DialogAddDynamicRequest (HANDLE Handle, short flags, short x, short y, const char *label, unsigned short width);

Adds a request/edit box with a dynamic buffer into a dialog box.

DialogAddDynamicRequest adds a request box (i.e. an input line edit box) with a dynamic buffer to the dialog structure associated with the handle Handle at the position (x,y), where the coordinates are relative to the top-left corner of the dialog box. An optional label label will appear in front of the request box. An empty string, "", is used to indicate no label.

Items created with DialogAddDynamicRequest doesn't use the RequestBuffer array passed to the Dialog function, so they do not need the offset and MaxLen values like normal edit items as described in DialogAddRequestEx. Instead, the callback function (see DialogNew for more information) is called with the first parameter equal to DB_GET_EDIT_HANDLE and the second parameter equal to the item's identification number. The callback should then return the handle of an edit buffer of at least width bytes long. width determines the actual width of the request box (This is very useful when you need to prevent the user from overstepping a special size such as file names). It will be such that the widest string made of width characters may fit into the box. So, the real width of box in pixels will be width*6, because the widest character 'M' is 6 pixels wide. If you try to enter a string with more than width characters, the system will prevent you from doing so. If width is wider than the actually available width of the dialog box, the request box will be truncated at the edge of the dialog box.

The order of item creation is very important, as it automatically gives each item an identification number (the first created item will get an identification number of 0, the second one will get 1, and so on). Every function that creates an item (i.e. every function beginning with 'DialogAdd...') will increase this identification number.

The parameter flags can be a combination of the following, defined in the DialogFlags enumeration:
DF_SCROLLABLE Set this flag if you want this item to be scrollable in a scroll region.
DF_SKIP This item is skipped when browsing through items with the arrow keys.
DF_SCREEN_SAVE The dialog code saves the area underneath the dialog box when it is started, DB_MEMFULL returned if it cannot. If you wish to use this flag, you must then set it with the first item you created in the dialog box.
DF_TAB_ELLIPSES Lines the item up on the right side of the dialog, and draws '......' between the item and its label. This flag is used in the TIOS 'MODE' dialog, for example. (It is the default on AMS 1.xx. See the note below for more information.)
DF_TAB_SPACES AMS 2.00 or higher: Like DF_TAB_ELLIPSES, but does not draw any dots.

Note: On AMS 1.xx, all request boxes in one dialog box will be aligned according to the request box which has the longest label, except when the label string finishes with a '`' character (code 96). In such case, the request box will start immediately after the label string ('`' is a special character, which will not be displayed). When the label doesn't end with '`', it can be padded with '.' characters up to the length of the longest label, except if the label finishes with ':': In that case, the label will be padded with space characters (':' will also be displayed).

DialogAddDynamicRequest returns H_NULL in case of an error, may return DB_MEMFULL if you used DF_SCREEN_SAVE, else returns Handle. This routine (as well as all other 'DialogAdd...' routines) may cause heap compression.

DialogAddDynamicRequest is in fact a macro created for your convenience. It calls DialogAdd with D_HEDIT as the ItemType parameter.


DialogAddMenu

AMS 2.00 or higher

HANDLE DialogAddMenu (HANDLE Handle, short flags, short x, short y, void *Menu, unsigned short MaxMenuWidth);

Adds a menu into a dialog box.

DialogAddMenu adds the menu Menu, with a maximum width of MaxMenuWidth (or zero to automatically calculate the width) at the position (x,y) to the dialog structure associated with the handle Handle, where the coordinates are relative to the top-left corner of the dialog box.

A menu item is defined by a pointer Menu to a toolbar menu structure created statically (i.e. you must include a pre-filled static menu in your source code) or dynamically with MenuNew (in this case the caller must ensure the structure remains locked while in use in the dialog box, i.e. use HLock in the same way as for MenuBegin). The menu is drawn by an internal call to MenuBegin. When a menu key is pressed, the callback's (see DialogNew for more information) Message value will be the item's identification number and Value will be passed the menu handle returned from MenuBegin in the high word and the key code in the low word. You can specify a maximum width for your menu in MaxMenuWidth or zero if you want it to be automatically calculated. Each dialog box can have at most one menu. The creation of menus is explained in the header file menus.h. Note that if you want a menu, you must write a callback function, else you will not be able to do anything but dispaying it!

The order of item creation is very important, as it automatically gives each item an identification number (the first created item will get an identification number of 0, the second one will get 1, and so on). Every function that creates an item (i.e. every function beginning with 'DialogAdd...') will increase this identification number.

The parameter flags can be a combination of the following, defined in the DialogFlags enumeration:
DF_SCREEN_SAVE The dialog code saves the area underneath the dialog box when it is started, DB_MEMFULL returned if it cannot. If you wish to use this flag, you must then set it with the first item you created in the dialog box.
DF_MAX_MENU_WIDTH AMS 2.00 or higher: Passes MBF_MAX_MENU_WIDTH to MenuBegin when the menu is drawn.


DialogAddMenu returns H_NULL in case of an error, may return DB_MEMFULL if you used DF_SCREEN_SAVE, else returns Handle. This routine (as well as all other 'DialogAdd...' routines) may cause heap compression.

DialogAddMenu is in fact a macro created for your convenience. It calls DialogAdd with D_MENU as the ItemType parameter.


DialogAddPulldown

HANDLE DialogAddPulldown (HANDLE Handle, short x, short y, const char *prompt, HANDLE MenuHandle, unsigned short index);

Adds a pulldown/popup menu into a dialog box.

DialogAddPulldown works exactly as DialogAddPulldownEx, but doesn't have the flags parameter available. This routine is in fact a macro using DialogAdd with D_HPOPUP passed as a command and zero passed as the flags. All the parameters are explained in DialogAddPulldownEx.


DialogAddPulldownEx

HANDLE DialogAddPulldownEx (HANDLE Handle, short flags, short x, short y, const char *label, HANDLE PopupMenu, unsigned short index);

Adds a pulldown/popup menu into a dialog box. Extended version.

DialogAddPulldownEx adds the pulldown menu PopupMenu to the dialog structure associated with the handle Handle at the position (x,y), where the coordinates are relative to the top-left corner of the dialog box.

label is the label which will appear in front of the popup menu (or "" if you don't want any name), and MenuHandle is the handle of the associated menu which needs to be created using the PopupNew function (the same functions are used for creating pulldown and popup menus). See menus.h for more info about creating popups. The text must fit into one line of the dialog box.

The parameter index determines where the result value of executing the pulldown menu will be stored, and also indicates what the initially selected option will be. See DialogDo for information on how and where the result values are actually stored.

The order of item creation is very important, as it automatically gives each item an identification number (the first created item will get an identification number of 0, the second one will get 1, and so on). Every function that creates an item (i.e. every function beginning with 'DialogAdd...') will increase this identification number.

The parameter flags can be a combination of the following, defined in the DialogFlags enumeration:
DF_SCROLLABLE Set this flag if you want this item to be scrollable in a scroll region.
DF_SKIP This item is skipped when browsing through items with the arrow keys.
DF_SCREEN_SAVE The dialog code saves the area underneath the dialog box when it is started, DB_MEMFULL returned if it cannot. If you wish to use this flag, you must then set it with the first item you created in the dialog box.
DF_TAB_ELLIPSES Lines the item up on the right side of the dialog, and draws '......' between the item and its label. This flag is used in the TIOS 'MODE' dialog, for example. It is the default on AMS 1.xx.
DF_TAB_SPACES AMS 2.00 or higher: Like DF_TAB_ELLIPSES, but does not draw any dots.
DF_POPUP_RADIO AMS 2.00 or higher: If this flag is set, the item looks like a normal pulldown menu that you can select, but when you press the right arrow key, it does not pop up as usual, but returns control to the dialog callback function. This enables the programmer to do whatever he/she wants. For example, in the 'MODE' dialog, setting custom units pops up another dialog instead of a pulldown menu.

DialogAddPulldownEx returns H_NULL in case of an error, may return DB_MEMFULL if you used DF_SCREEN_SAVE, else returns Handle. This routine (as well as all other 'DialogAdd...' routines) may cause heap compression.

DialogAddPulldownEx is in fact a macro created for your convenience. It calls DialogAdd with D_HPOPUP as the ItemType parameter. Note that DialogAddPulldownEx is the same macro as DialogAddPulldown except for the parameter flags which is always set to zero in DialogAddPulldown.


DialogAddRequest

HANDLE DialogAddRequest (HANDLE Handle, short x, short y, const char *prompt, unsigned short offset, short MaxLen, short width);

Adds a request/edit box into a dialog box.

DialogAddRequest works exactly as DialogAddRequestEx, but doesn't have the flags parameter available. This routine is in fact a macro using DialogAdd with D_EDIT_FIELD passed as a command and zero passed as the flags. All the parameters are explained in DialogAddRequestEx.


DialogAddRequestEx

HANDLE DialogAddRequestEx (HANDLE Handle, short flags, short x, short y, const char *label, unsigned short offset, short MaxLen, short width);

Adds a request/edit box into a dialog box. Extended version.

DialogAddRequestEx adds a request box (i.e. an input line edit box) to the dialog structure associated with the handle Handle at the position (x,y), where the coordinates are relative to the top-left corner of the dialog box. An optional label label will appear in front of the request box. An empty string, "", is used to indicate no label.

The maximal number of characters which may be entered is determined by the parameter MaxLen (MaxLen must at most have the size of the RequestBuffer given to DialogDo), and width determines the actual display width of the request box (MaxLen can be very usefull when you need to prevent the user from overstepping a special size such as file names). It will be such that the widest string made of width characters may fit into the box. So, the real display width of box in pixels will be width*6, because the widest character 'M' is 6 pixels wide. If you try to enter a string with more than width characters, the content of the request box will scroll, and if you try to have a string longer than MaxLen, the system will prevent you from doing so. If width is wider than the actually available width of the dialog box, the request box will be truncated at the edge of the dialog box.

The parameter offset determines what will be the initial content of the request box, and where the entered characters will be stored. See DialogDo for information on how and where the entered characters are actually stored.

The order of item creation is very important, as it automatically gives each item an identification number (the first created item will get an identification number of 0, the second one will get 1, and so on). Every function that creates an item (i.e. every function beginning with 'DialogAdd...') will increase this identification number.

The parameter flags can be a combination of the following, defined in the DialogFlags enumeration:
DF_SCROLLABLE Set this flag if you want this item to be scrollable in a scroll region.
DF_SKIP This item is skipped when browsing through items with the arrow keys.
DF_SCREEN_SAVE The dialog code saves the area underneath the dialog box when it is started, DB_MEMFULL returned if it cannot. If you wish to use this flag, you must then set it with the first item you created in the dialog box.
DF_TAB_ELLIPSES Lines the item up on the right side of the dialog, and draws '......' between the item and its label. This flag is used in the TIOS 'MODE' dialog, for example. (It is the default on AMS 1.xx. See the note below for more information.)
DF_TAB_SPACES AMS 2.00 or higher: Like DF_TAB_ELLIPSES, but does not draw any dots.

Note: On AMS 1.xx, all request boxes in one dialog box will be aligned according to the request box which has the longest label, except when the label string finishes with a '`' character (code 96). In such case, the request box will start immediately after the label string ('`' is a special character, which will not be displayed). When the label doesn't end with '`', it can be padded with '.' characters up to the length of the longest label, except if the label finishes with ':': In that case, the label will be padded with space characters (':' will also be displayed).

DialogAddRequestEx returns H_NULL in case of an error, may return DB_MEMFULL if you used DF_SCREEN_SAVE, else returns Handle. This routine (as well as all other 'DialogAdd...' routines) may cause heap compression.

DialogAddRequestEx is in fact a macro created for your convenience. It calls DialogAdd with D_EDIT_FIELD as the ItemType parameter. Note that DialogAddRequestEx is the same macro as DialogAddRequest except for the parameter flags which is always set to zero in DialogAddRequest.


DialogAddScrollRegion

HANDLE DialogAddScrollRegion (HANDLE Handle, short flags, short x, short y, unsigned short x1, unsigned short y1, unsigned short FirstItem, unsigned short LastItem, unsigned short NumDspItems, unsigned short TotNumItems, unsigned short ItemHeight);

Adds a rectangular item-scrolling region to a dialog box.

DialogAddScrollRegion adds a rectangular item-scrolling region to the dialog structure associated with the handle Handle from the (x, y) position to the (x1, y1) position, where all coordinates are relative to the top-left corner of the dialog box.

A scroll region defines a group of items that will scroll as the user moves through the items. The identification number of the first scrollable should be set in FirstItem and the last scrollable item in LastItem. NumDspItems defines the number of items that are displayed at one time. The total number of scrollable item should be set in TotNumItems and the height of each item in ItemHeight. Every scrollable item must be defined contiguously and have the DF_SCROLLABLE flag set and must not be of MENU, HEADER or XFLAGS type. The coordinates of the scrollable items are relative to the dialog box except that they may extend beyond the bottom coordinate of the dialog box. They are defined assuming a virtual scroll region.

It's very easy to cause display bugs using this function (of course, that won't crash your calculator, but the dialog can easily become ugly), so here is a method you can use to avoid those bugs: First, the standard item height is the height of the biggest item (often the EDIT item which is 10 pixel high), so the minimum value in ItemHeight should be 10 in most cases. Then, to avoid any display bugs, the y axis should be the y value of your first displayed item - 2 and y1 axis should be the y value of your last displayed item + 8. I.e. if you wish to scroll 8 items and only display items 3 by 3 (but please use the available screen space: don't just restrict the items displayed at a time to 3 just because everyone else does it), and the first scrollable item is item number 4 (the last displayed item at the beginning is therefore item 6), the calculation should be: y=(item 4 y axis)-2 and y1=(item 6 y axis)+8). The difference x1-x should also be greater than the width of the largest item (else it will result in display bugs). I don't really understand the utility of such a TotNumItems parameter as it should always be equal to LastItem-FirstItem+1. The flag DF_CLR_ON_REDRAW is very useful and should be set in most cases (see below).

Note: If you use a SCROLL_REGION, it must be the first item defined in the dialog box. A dialog box can therefore have at most one scroll region.

The order of item creation is very important, as it automatically gives each item an identification number (the first created item will get an identification number of 0, the second one will get 1, and so on). Every function that creates an item (i.e. every function beginning with 'DialogAdd...') will increase this identification number.

The parameter flags can be a combination of the following, defined in the DialogFlags enumeration:
DF_SKIP This item is skipped when browsing through items with the arrow keys.
DF_SCREEN_SAVE The dialog code saves the area underneath the dialog box when it is started, DB_MEMFULL returned if it cannot. If you wish to use this flag, you must then set it with the first item you created in the dialog box.
DF_CLR_ON_REDRAW Clears the entire visible scroll region when redrawn. If you do not set this flag, the scroll region will not be cleared before being redrawn, and you might still see the previously drawn items underneath the new ones.


DialogAddScrollRegion returns H_NULL in case of an error, may return DB_MEMFULL if you used DF_SCREEN_SAVE, else returns Handle. This routine (as well as all other 'DialogAdd...' routines) may cause heap compression.

DialogAddScrollRegion is in fact a macro created for your convenience. It calls DialogAdd with D_SCROLL_REGION as the ItemType parameter.


DialogAddStaticPulldown

HANDLE DialogAddStaticPulldown (HANDLE Handle, short flags, short x, short y, const char *label, void *Popup, unsigned short index);

Adds a static pulldown/popup menu into a dialog box.

DialogAddStaticPulldown uses the pointer Popup to a static pre-filled popup menu structure (popup menus and dialog pulldowns are in fact the same structure) and adds this pulldown menu to the dialog structure associated with the handle Handle at the position (x,y), where the coordinates are relative to the top-left corner of the dialog box.

label is the label which will appear in front of the popup menu (or "" if you don't want any name), and Popup is a prefilled static popup structure (i.e. you must write this popup in your source code; for dynamic pop-ups use DialogAddPulldownEx) of the associated menu. See menus.h for more info about creating static popups. The text must fit into one line of the dialog box.

The parameter index determines where the result value of executing the pulldown menu will be stored, and also indicates what the initially selected option will be. See DialogDo for information on how and where the result values are actually stored.

The order of item creation is very important, as it automatically gives each item an identification number (the first created item will get an identification number of 0, the second one will get 1, and so on). Every function that creates an item (i.e. every function beginning with 'DialogAdd...') will increase this identification number.

DialogAddStaticPulldown works like DialogAddPulldownEx, but only accepts a static pre-filled dialog Popup instead of a handle.

The parameter flags can be a combination of the following, defined in the DialogFlags enumeration:
DF_SCROLLABLE Set this flag if you want this item to be scrollable in a scroll region.
DF_SKIP This item is skipped when browsing through items with the arrow keys.
DF_SCREEN_SAVE The dialog code saves the area underneath the dialog box when it is started, DB_MEMFULL returned if it cannot. If you wish to use this flag, you must then set it with the first item you created in the dialog box.
DF_TAB_ELLIPSES Lines the item up on the right side of the dialog, and draws '......' between the item and its label. This flag is used in the TIOS 'MODE' dialog, for example. It is the default on AMS 1.xx.
DF_TAB_SPACES AMS 2.00 or higher: Like DF_TAB_ELLIPSES, but does not draw any dots.
DF_POPUP_RADIO AMS 2.00 or higher: If this flag is set, the item looks like a normal pulldown menu that you can select, but when you press the right arrow key, it does not pop up as usual, but returns control to the dialog callback function. This enables the programmer to do whatever he/she wants. For example, in the 'MODE' dialog, setting custom units pops up another dialog instead of a pulldown menu.

DialogAddStaticPulldown returns H_NULL in case of an error, may return DB_MEMFULL if you used DF_SCREEN_SAVE, else returns Handle. This routine (as well as all other 'DialogAdd...' routines) may cause heap compression.

DialogAddStaticPulldown is in fact a macro created for your convenience. It calls DialogAdd with D_POPUP as the ItemType parameter.


DialogAddText

HANDLE DialogAddText (HANDLE Handle, short x, short y, const char *text);

Adds a text into a dialog box.

DialogAddText works exactly as DialogAddTextEx, but doesn't have the flags parameter available. This routine is in fact a macro using DialogAdd with D_TEXT passed as a command and zero passed as the flags. All the parameters are explained in DialogAddTextEx.


DialogAddTextEx

HANDLE DialogAddTextEx(HANDLE Handle, short flags, short x, short y, const char *text);

Adds a text, an image, or a custom item into a dialog box.

DialogAddTextEx gives two possibilities:

The first one (if, as is the case of DialogAddText, the flags parameter doesn't contain the DF_OWNER_DRAW flag) is to add the text text to the dialog structure associated with the handle Handle at the position (x, y), where the coordinates are relative to the top-left corner of the dialog box.

The second possibility (when the flags parameter contains the DF_OWNER_DRAW flag) is that DialogAddText can add any kind of item to the dialog structure associated with the handle Handle at the position (x, y), where the coordinates are relative to the top-left corner of the dialog box. (This position can later be ignored so owner draw items will not necessarily have to stick to this position.) You can create every kind of item you wish with this function (such as text, buttons, bitmaps...) as far as you create a callback function (see DialogNew for more details on the CallBack function). See the DF_OWNER_DRAW flag below for more information.

The order of item creation is very important, as it automatically gives each item an identification number (the first created item will get an identification number of 0, the second one will get 1, and so on). Every function that creates an item (i.e. every function beginning with 'DialogAdd...') will increase this identification number.

The parameter flags can be a combination of the following, defined in the DialogFlags enumeration (DF_OWNER_DRAW is very important as it can increase the numbers of possible items in dialogs):
DF_SCROLLABLE Set this flag if you want this item to be scrollable in a scroll region.
DF_SCREEN_SAVE The dialog code saves the area underneath the dialog box when it is started, DB_MEMFULL returned if it cannot. If you wish to use this flag, you must then set it with the first item you created in the dialog box.
DF_OWNER_DRAW AMS 2.00 or higher: The callback function (see DialogNew for more information) is responsible for drawing this item (which can be text, an image, or anything else). The parameters text, x and y will in this case be ignored. This can only be done if the dialog was created with DialogNew and not DialogNewSimple.

If the DF_OWNER_DRAW flag is set, then the callback is passed the item identification number and a pointer to an OWNER_DRAW_STRUCT structure. The first value Item in this structure is a direct pointer to the DIALOG_ITEM structure for the item to be drawn. The second value pW is a pointer to the WINDOW structure for the dialog box. Using this pointer, the callback can draw anything and anywhere to the dialog box (all clipped to the dialog box window).


Note: By default, the DF_SKIP flag is set whenever you try to create text or owner draw items so you will not be able to focus on them.

DialogAddTextEx returns H_NULL in case of an error, may return DB_MEMFULL if you used DF_SCREEN_SAVE, else returns Handle. This routine (as well as all other 'DialogAdd...' routines) may cause heap compression.

DialogAddTextEx is in fact a macro created for your convenience. It calls DialogAdd with D_TEXT as the ItemType parameter. Note that DialogAddTextEx is the same macro as DialogAddText except for the parameter flags which is always set to zero in DialogAddText.


DialogAddTitle

HANDLE DialogAddTitle (HANDLE Handle, const char *title, short left_button, short right_button);

Adds a title bar and up to two buttons into a dialog box.

DialogAddTitle works exactly as DialogAddTitleEx, but doesn't have the flags parameter available. This routine is in fact a macro using DialogAdd with D_HEADER passed as a command and zero passed as the flags. All the parameters are explained in DialogAddTitleEx.


DialogAddTitleEx

HANDLE DialogAddTitleEx (HANDLE Handle, short flags, const char *title, short left_button, short right_button);

Adds a title/header bar and up to two buttons into a dialog box. Extended version.

DialogAddTitleEx adds a title/header bar with the text title and up to two buttons to the dialog structure associated with the handle Handle.

The parameters left_button and right_button determine the type of the left and right buttons which eventually will appear at the bottom of the dialog box (by giving BT_NONE as the parameter, you can skip adding a button). The set of possible buttons is very limited. See DlgMessage for information about possible types. If you wish to have buttons without having a title bar, then you must use an owner draw item (see DialogAddTextEx and the explanation on owner draw items given with DialogNew for more information).

The parameter flags can be zero or DF_SCREEN_SAVE if you wish the dialog code to save the area underneath the dialog box when it is started, DB_MEMFULL is returned if it cannot. Note that if you use this flag, the title item must be the first one to be created. These flags are defined in the DialogFlags enumeration.

The order of item creation is very important, as it automatically gives each item an identification number (the first created item will get an identification number of 0, the second one will get 1, and so on). Every function that creates an item (i.e. every function beginning with 'DialogAdd...') will increase this identification number.

DialogAddTitleEx returns H_NULL in case of an error, may return DB_MEMFULL if you used DF_SCREEN_SAVE, else returns Handle. This routine (as well as all other 'DialogAdd...' routines) may cause heap compression.

DialogAddTitleEx is in fact a macro created for your convenience. It calls DialogAdd with D_HEADER as the ItemType parameter. Note that DialogAddTitleEx is the same macro as DialogAddTitle except for the parameter flags which is always set to zero in DialogAddTitle. In both functions, zero is passed to the x and y parameters. (These parameters are ignored when you use D_HEADER as the ItemType.)


DialogAddXFlags

AMS 2.00 or higher

HANDLE DialogAddXFlags (HANDLE Handle, short flags, unsigned short xFlags1, unsigned short xFlags2, unsigned short xFlags3, unsigned short xFlags4);

Adds extended dialog properties into a dialog box.

DialogAddXFlags adds extended dialog properties to the dialog structure associated with the handle Handle.
The XFLAGS item defines an array of four extended unsigned short flags (i.e. xFlags1, xFlags2, xFlags3, xFlags4.) Currently only xFlags1 is used: the three remaining values should always be set to zero for future compatibility.

The order of item creation is very important, as it automatically gives each item an identification number (the first created item will get an identification number of 0, the second one will get 1, and so on). Every function that creates an item (i.e. every function beginning with 'DialogAdd...') will increase this identification number.

The parameter xFlags1 may contain a combination of the following flags, defined in the DialogXFlags enumeration:
XF_ALLOW_VARLINK Setting this extended xflag allows all EDIT (=request) items in the dialog box to allow the [VAR-LINK] key to be activated within the dialog box and to paste results to the edit item. If this xflag or XF_VARLINK_SELECT_ONLY is not set, then when [VAR-LINK] is pressed in a dialog box, the dialog will be closed and VAR-LINK will be activated.
XF_NO_ALPHA_LOCK On the TI-89, Alpha-Lock is turned on for all dialog boxes with edit items. Setting this extended xflag disables this feature.
XF_VARLINK_SELECT_ONLY This xflag is similar to XF_ALLOW_VARLINK except thet the user may not make any variable changes inside VAR-LINK (like deleting, copying, renaming, or locking variables).
XF_TE_REPAINT This xflag is unknown for the moment. Do not use.

The parameter flags can be zero or DF_SCREEN_SAVE if you wish the dialog code to save the area underneath the dialog box when it is started and to return DB_MEMFULL if it cannot. Note that if you use this flag, the item must be the first one to be created. These flags are defined in the DialogFlags enumeration.

DialogAddXFlags returns H_NULL in case of an error, may return DB_MEMFULL if you used DF_SCREEN_SAVE, else returns Handle. This routine (as well as all other 'DialogAdd...' routines) may cause heap compression.

DialogAddXFlags is in fact a macro created for your convenience. It calls DialogAdd with D_XFLAGS as the ItemType parameter and with zero passed to the x and y parameters. (These parameters are ignored when you use D_XFLAGS as the ItemType.)


DialogDo

short DialogDo (HANDLE Handle, short x, short y, char *RequestBuffer, short *PulldownBuffer);

Activates and shows a dialog box.

DialogDo activates and shows on the screen the dialog associated with handle Handle. The top-left corner of the dialog will be at the position (xy), where coordinates are absolute screen coordinates. x, y or both may also have a special value CENTER which means "center the dialog on the screen in x, y or both directions". DialogDo returns KEY_ENTER or KEY_ESC, depending on whether the user exits the dialog by pressing ENTER or ESC key (note that structures pointed to by RequestBuffer and PulldownBuffer will be modified regardless of whether the user exits the dialog by pressing ENTER or ESC). It also may return a negative number in a case of error (e.g. not enough memory to display the dialog box). After the execution is finished, the original content of the screen will be restored. This routine may cause heap compression.

Parameter RequestBuffer is the pointer to the buffer where character entered into request boxes will be stored. This buffer may store more than one string; the characters entered into a request box will be stored starting from address RequestBuffer + offset, where offset is the parameter given with the DialogAddRequest command which created this request box. Each stored string will be zero terminated. This buffer may be pre-filled with the initial content which will appear in request boxes. Namely, initial content of any request box will be a sequence of characters starting from address RequestBuffer + offset up to the first zero ('\0') character (where offset is the parameter given when the request box is created). If the dialog does not contain any request boxes, RequestBuffer may be NULL.

Parameter PulldownBuffer is the pointer to the buffer where return values of execution of pulldown menus will be stored. This buffer is, in fact, an array of integers; the return value of executing a pulldown menu will be stored in PulldownBuffer[index], where index is the parameter given with the DialogAddPulldown command which created this pulldown menu. This array may be pre-filled with the ordinal numbers of initial option in pulldown menus. Namely, initially selected option content of any pulldown menu will be an option with ordinal number PulldownBuffer[index] (where index is the parameter given when the pulldown menu was created). If the dialog does not contain any pulldown menus, PulldownBuffer may be NULL.

Here is a concrete example (called "Dialog Test"), which creates a dialog which asks the user for his name, then displays a message box with a greeting message in which the user's name is included, except if the user pressed the ESC key:

// Display a simple dialog box and let the user enter a name

#define USE_TI89              // Compile for TI-89
#define USE_TI92PLUS          // Compile for TI-92 Plus
#define USE_V200              // Compile for V200

#define OPTIMIZE_ROM_CALLS    // Use ROM Call Optimization
#define MIN_AMS 100           // Compile for AMS 1.00 or higher

#include <tigcclib.h>         // Include All Header Files

// Main Function
void _main(void)
{
  char buffer[27] = "Hello ";
    // 6 bytes "Hello ", max. 20 bytes name, 1 zero byte
  HANDLE handle = DialogNewSimple (140, 55);
  DialogAddTitle (handle, "EXAMPLE", BT_OK, BT_CANCEL);
  DialogAddText (handle, 3, 20, "Enter name (max. 20 chars)");
  DialogAddRequest (handle, 3, 30, "Your name", 6, 20, 14);
  if (DialogDo (handle, CENTER, CENTER, buffer, NULL) == KEY_ENTER)
    DlgMessage ("GREETINGS", buffer, BT_OK, BT_NONE);
  HeapFree (handle);
}

DialogNew

HANDLE DialogNew (short Width, short Height, Dialog_Callback_t Callback);

Creates a new dialog box which can interact with the user program.

DialogNew acts like DialogNewSimple, but accepts a pointer to a user callback function Callback as a third parameter (i.e. you must pass the pointer of a function you wrote in your source code which contains the parameter types defined by Dialog_Callback_t). This function is called more than once during the dialog's execution.

Such a user function allows for interaction between the dialog box and the user program, and permits the creation of dialog boxes which dynamically change their contents during execution. This is a kind of event-driven programming: When an event occurs in the dialog, the Callback function will be called with a specific Message parameter Message that should be processed so as to know what data the parameter Value contains. Events are only sent on a few occasions, which include:

This function has to return a value, whose meaning also depends on the input Message parameter. However, in simple dialog boxes without any dynamic elements, you may always pass TRUE, which is the same as DB_CONTINUE, i.e. the standard return value. Note that if you do not want to take care of the Callback function at all (i.e. if you do not want to write such a function) you can use the already written NoCallBack function, which does nothing but return TRUE whatever the entering message is (but in that case, the best thing is to use DialogNewSimple, which in fact is a macro using both DialogNew and NoCallBack).

Note that if you choose not to create a CallBack function, some of the items (such as D_MENU) and the DF_OWNER_DRAW flag will not be very useful for you as they need to be handled in the callback function.

The following table shows what the Message value can be, when events occur and what you should return from Callback. The constants are defined in the enum DialogMessages:

A nonnegative value This occurs when the user pressed ENTER to activate an item, or to return from an activated item.
This nonnegative value is in fact the identification number of an item in a dialog. This identification number is created automatically when you use one of the creation functions DialogAdd, DialogAddText, DialogAddPulldown, and all other functions starting with "DialogAdd". A value of 0 represents the first item you created in the dialog box, 1 is the second one, 2 the third one, and so on.
The meaning of the Value parameter depends on the type of the item. See below for a list of possible meanings.
The return value should be a message from the enum DialogMessages:
DB_CONTINUE Process the key pressed by the user, but do not redraw the dialog box.
DB_REDRAW Redraw the dialog box and ignore the key pressed by the user.
DB_REDRAW_AND_CONTINUE Redraw the dialog box, then process the key pressed by the user.
DB_EXIT You can return this value if you want the dialog box to stop its execution immediately.
DB_QACTIVE Query the status of an item (enabled/disabled).
This occurs whenever an item in the dialog box is created, gets the focus, or whenever the dialog box needs to update the state of the item. In this case, the value passed through Value is the identification number of an item in the dialog (0 for the first one, 1 for the second one, and so on). You should return TRUE if the item is enabled and should not be grayed out, or FALSE if the item is disabled and must be grayed out). Note that static items such as D_TITLE and D_TEXT are not even drawn if they are disabled.
DB_GET_TITLE Query the title of a dynamic header.
This event occurs when a special title bar which may be added to the dialog using DialogAdd with ItemType set to D_DYNHEADER is created. The Value parameter will be zero, and the callback function must return the text for the title of the dialog box.
Note: as statically created dynamic titles are not known very well for the moment, in most cases you do not have to care about this value.
DB_GET_EDIT_HANDLE Query the text buffer of a dynamic edit field.
This event occurs when a special request box which may be added to the dialog using DialogAdd with ItemType set to D_HEDIT (or using DialogAddDynamicRequest) is created or gets the focus. The value contained in Value is the identification number of this edit box item in the dialog. The callback function must return a handle which points to a buffer from where this request box will get its initial value, and where the contents of the request box will be stored. You may need the HeapAlloc function to get a new handle and HeapDeref to access the associated buffer (see the example below).
Note: See DialogAddDynamicRequest for more details about this special feature.

The following table shows what the Value parameter is if Message is a nonnegative value, depending on the item type:

Pulldown If the item identified by Message is a pulldown menu (i.e. if this item has been created using DialogAddPulldown or DialogAddPulldownEx, or DialogAdd with ItemType set to D_POPUP, D_HPOPUP or D_DYNPOPUP), the value contained in Value is the identification number of the item selected in the pulldown menu (not one of a dialog item). The event occurs only when the user selects an item and presses ENTER.
Request If the item identified by Message is a request item (i.e. if this item has been created using DialogAddRequest or DialogAddRequestEx, or DialogAdd with ItemType set to D_HEDIT or D_EDIT_FIELD), the value contained in Value is a pointer pointing to the data the user just entered.
Menu If the item identified by Message is a menu (i.e. if this item has been added using DialogAddMenu or DialogAdd with ItemType set to D_MENU), the value contained in Value is in fact the composition of two values: the 16 most significant bits (the high word) of Value contain the execution handle of the menu (the dialog box code calls MenuBegin initially to get a handle for the menu) and the 16 least significant bits (the low word) contain the key pressed by the user to activate the menu (for your convenience, common key values are defined in the CommonKeys enum). The macros LO_WORD and HI_WORD have been created to get both values easily. The callback function may activate the menu or change anything in it if needed. See MenuKey for more details on activating a menu.
Note: The return value of a menu differs from that of any other element: Returning a positive value will select (focus on) the dialog item whose identification number is equal to the value you returned. (This feature is mainly used in the TIOS 'MODE' dialog where pressing F1, F2 or F3 changes the page displayed, which is achieved by changing the focus.) With AMS 2.xx the return value can also be one of DB_REDRAW, DB_REDRAW_AND_CONTINUE or DB_EXIT, but not DB_CONTINUE, since that value is positive.
Owner Draw Text If the item identified by Message is an owner draw text/image (i.e. if this item has been created using DialogAdd with ItemType set to D_TEXT and Flags containing DF_OWNER_DRAW), the value contained in Value is a pointer to an OWNER_DRAW_STRUCT structure. The Item field in this structure is a direct pointer to the DIALOG_ITEM structure for the item to be drawn (this is not normally used). The pW field is a pointer to the WINDOW structure for the dialog box. Using this pointer, the callback function can draw anything anywhere to the dialog box (clipped to the window of the dialog box). For example, you can draw simple text using the WinStrXY function, or draw a standard button using DrawStaticButton, or a bitmap using WinBitmapPut, etc. In general, you will be able to use any of the functions from wingraph.h.

All other item types cannot be activated; Callback will not be called with their identification number as the Message parameter.

After pressing ENTER in a request box or after execution of a pulldown menu, the DB_QACTIVE message will be sent to all items in the dialog. This permits the user to create dialogs in which the selection of various options in pulldown menus enables or disables some other items.

Note: It might be useful for you to know that dereferencing the handle returned by DialogNew with HeapDeref or with HLock returns a pointer to the dialog's DIALOG structure.

See also: DialogDo, Dialog, DialogAdd, DIALOG


DialogNewSimple

HANDLE DialogNewSimple (short width, short height);

Creates a new dialog box.

DialogNewSimple allocates memory for a dialog box with dimensions width x height, initializes allocated block with necessary structures and returns a handle to it (or H_NULL in case of error). This routine may cause heap compression. DialogNewSimple in fact calls DialogNew with NoCallBack as third parameter.

Note: You can later free the memory by calling HeapFree.


DlgMessage

short DlgMessage (const char *title, const char *message, short left_button, short right_button);

Displays a message dialog box.

DlgMessage displays a message dialog box, where title is the title string (pass NULL for no title), and message is the content of the message. Both title and message must fit into one screen line, else the calculator will crash (however, on AMS 2.xx, a long message will simply be wrapped in the dialog box). Parameters left_button and right_button determine the type of the left and right buttons which will appear at the bottom of the dialog box. The set of possible buttons is very limited, and possible types are defined in enum Buttons (any other values will cause a crash). The meanings of these constants are:

BT_NONENo button at all
BT_OKButton "Enter=OK"
BT_SAVEButton "Enter=SAVE"
BT_YESButton "Enter=YES"
BT_CANCELButton "Esc=CANCEL"
BT_NOButton "ESC=NO"
BT_GOTOButton "Enter=GOTO"

DlgMessage returns KEY_ENTER or KEY_ESC, depending on whether the user exits the dialog by pressing the ENTER or ESC key. This routine may cause heap compression.


HI_WORD

short HI_WORD(long);

Returns the high word from a long value.

This function returns the highest short value (the 16 most significant bits) of a long value. This macro function was created for DialogNew.


LO_WORD

short LO_WORD (long);

Returns the low word from a long value.

This function returns the lowest short value (the 16 least significant bits) of a long value. This macro function was created for DialogNew.


NoCallBack

short NoCallBack (short Message, long Value);

Dummy callback function doing nothing.

NoCallBack is a dummy function which does nothing, and always returns 1 as result. The purpose of this function lies in the fact that it may be given as a third parameter to the function DialogNew, when there is no need for an interaction with the user program during the execution of the dialog (i.e. no "calling back"). DialogNewSimple does exactly this: it calls DialogNew with NoCallBack as a third parameter.

Note: This routine was in TIOS jump table up to AMS 1.xx. In AMS 2.xx it is not in the jump table! Here, NoCallBack is implemented on such whay that it can be used on any version of AMS.


VarNew

HSym VarNew (const ESQ *FileTypes, ...);

Displays the standard "New" dialog.

VarNew implements the standard "New" dialog. The user may select a type to create as well as the folder to create the new variable in, and then may type in a variable name.

FileTypes is a pointer to a zero-terminated array of types that are supported (see VarOpen for more info). VarNew returns the HSym descriptor of the newly created symbol, or H_NULL if the user presses 'ESC' or in case of an error.

This function may cause heap compression.

See also: VarOpen, VarSaveAs


VarOpen

HSym VarOpen (const ESQ *FileTypes, ...);

Displays the standard "Open" dialog.

VarOpen implements the standard "Open" dialog. The user may select a type, the folder to look in, and finally a symbol in the selected folder which matches the selected type.

FileTypes is a pointer to a zero-terminated array of types that are supported. These types are, in fact, tags (see the Tags enum for more info). Supported tags are: EQ_TAG (expression), STR_TAG (string), LIST_TAG (list), MATRIX_TAG (matrix), PRGM_ITAG (program), FUNC_ITAG (function), DATA_TAG (data), GDB_TAG (Graph Database), PIC_TAG (picture), TEXT_TAG (text), FIG_TAG (geometry figure), MAC_TAG (geometry macro), ASM_TAG (assembly program), and OTH_TAG (custom-type file). Each value in the FileTypes list will be presented to the user in a pulldown menu, unless there is only one value in the list (then it will be a static field).

VarOpen returns the HSym descriptor of the selected symbol, or HS_NULL if the user pressed 'ESC' or in case of an error.

If the FileTypes list contains OTH_TAG items, an extra parameter of type char ** is required. This parameter is an array of strings (more precisely, of char pointers). There must be exactly one char pointer for each OTH_TAG item in the FileTypes list, and these pointers should point to the text to display in the pulldown menu for these custom types.

This function may cause heap compression.

See also: VarNew, VarSaveAs


VarSaveAs

HSym VarSaveAs (const ESQ *FileTypes, const char *TitleSym, ...);

Displays the standard "Save Copy As" dialog.

VarSaveAs implements the standard "Save Copy As" dialog. The user may select a type as well as the folder to save the symbol in, and finally has to enter the symbol name.

FileTypes is a pointer to a zero-terminated array of types that are supported (see VarOpen for more info). TitleSym is a string that will be placed in the title of the dialog box (the title will have the form "SAVE COPY OF TitleSym AS"). Alternatively, TitleSym may be NULL if no such title is wanted.

VarSaveAs returns the HSym descriptor of the newly created symbol, or H_NULL if the user pressed 'ESC' or in case of an error. This function is essentially the same as VarNew, only the different dialog type is used.

This function may cause heap compression.

See also: VarNew, VarOpen


CENTER

#define CENTER (-1)

A constant to describe a centered position for dialogs.

When used in the DialogDo or PopupDo command as a parameter, CENTER means "center the dialog or popup menu on the screen in x, y or both directions," depending on which parameter CENTER is used as.


DialogMessages

enum DialogMessages {
DB_CONTINUE =1, DB_MEMFULL = -1, DB_QACTIVE = -2, DB_REDRAW = -3, DB_REDRAW_AND_CONTINUE = -4, DB_UNKNOWN = -5,DB_GET_EDIT_HANDLE = -6, DB_GET_TITLE = -7, DB_EXIT = -8
};

An enumeration to describe messages used by a Dialog's Callback.


Buttons

enum Buttons {BT_NONE = 0, BT_OK = 1, BT_SAVE = 2, BT_YES = 3, BT_CANCEL = 4, BT_NO = 5, BT_GOTO = 6};

An enumeration to describe possible button types.

Describes the button types used in DlgMessage.


Dialog_Callback_t

typedef CALLBACK short (*Dialog_Callback_t) (short Message, long Value);

Callback function type for dialogs.

Dialog_Callback_t is used in DialogNew and in the DIALOG structure to provide a callback mechanism for events in the dialog box.

Deprecated alias: DialogNew_t


Dialog_GetHandle_t

typedef CALLBACK HANDLE (*Dialog_GetHandle_t) (short ID);

Callback function type returning a handle for a dialog item.

Dialog_GetHandle_t is used in DialogAddDynamicPulldown to let the program generate the menu handle on demand.


DIALOG_ITEM

typedef struct {
unsigned char Type;
unsigned char Flags;
unsigned char x0, y0;
union {
struct {
void *Menu;
unsigned char MaxMenuWidth;
} dMenu;
struct {
short oText;
void *PopUp;
unsigned short oIndex;
} dPopUp;
struct {
short oText;
HANDLE (*GetPopUp)(unsigned short);
unsigned short oIndex;
} dDynPopUp;
struct {
short oText;
HANDLE hPopUp;
unsigned short dummy;
unsigned short oIndex;
} dHPopUp;
struct DEditType {
short oText;
unsigned short bOffset;
unsigned short Flen;
unsigned char Dlen;
} dEdit;
struct {
short oText;
} dText;
struct {
short oText;
unsigned char lButton, rButton;
} dHeader;
struct {
short oIcon;
} dIcon;
struct {
unsigned char x1, y1;
unsigned char Index0, Index1;
unsigned char NumDspFields, TotNumFields;
unsigned char FieldHeight;
} dScrollR;
struct {
unsigned short xFlags[4];
} dFlags;
} f;
} DIALOG_ITEM;

A scructure for defining dialog items.

This is the structure that defines an item in a DIALOG structure.

Note: To declare an Item of type D_END, which is all zeros, you can write:

DIALOG_ITEM empty={.f={}};

Deprecated alias: DIALOG_ITEMS

See also: DIALOG, DialogAdd, SIZED_DIALOG, DialogTypes


DIALOG

typedef struct {
unsigned short TextOffset;
unsigned short NumItems;
unsigned char Width, Height;
Dialog_Callback_t CallBack;
DIALOG_ITEM Fields[];
} DIALOG;

A scructure for defining dialogs.

DIALOG is the structure to define a pre-filled dialog box, to be used as the first argument to the Dialog function. It enables making a dialog without using DialogNew, DialogAddTitle, and all the other macros that use DialogAdd.

There is a constraint in this structure which cannot be described within a C data type: The last item in the Fields array must be an item of type D_END, and all other fields of this item must be filled with zero.

TextOffset is used to know where the strings that the dialog uses are. Most dialog fields (of type DIALOG_ITEM) have a member oText, which is of type unsigned short as well. For each item, both numbers will be added to the address of the DIALOG structure, and the result must be the address of the string. Offsets are shorts and therefore they cannot be greater than 65535, so having a DIALOG structure on the stack with strings on the heap or vice versa certainly will not work. Even if both the dialog structure and the strings are on the stack, you must be sure that the addresses of all strings are greater than the address of the DIALOG structure; for example because both the DIALOG structure and the strings are contained in a larger structure.

NumItem must be set to the number of items without the terminating D_END item. Width, Height and Callback are the same as the arguments for DialogNew.

For most of the DIALOG_ITEM structures, the structures' members are the same as the arguments used by the corresponding macro made with DialogAdd, just care about using offsets instead of pointers for strings, and add the flag DF_SKIP to ScrollRegions, Menus, Titles and text.

The order in wich you place the items is very important. Usually, the order should be the same as the visual order of the items, because it defines the order in which you move between items with the arrow keys. It also defines each item's identification number, which is passed to the callback function.

Note that this is not really a static structure, since the value of Callback depends on where the program is placed in memory, and the handles or pointers to each pulldown can vary at each execution. If you store this structure as a static structure or in a data file, think about changing the values of pointers and handles each time you execute your program. (The pointer to the callback can be relocated at load time by AMS though.) Also, DIALOG contains a variable-size array of items, and variable-size arrays cannot be initialized with non-constant values. However, a DIALOG instance is usually non-constant. See the SIZED_DIALOG macro, which was created to avoid this problem.

See also: Dialog, DialogAdd, DIALOG_ITEM, DialogNew, SIZED_DIALOG


DialogFlags

enum DialogFlags {DF_TAB_ELLIPSES = 0x01, DF_MAX_MENU_WIDTH = 0x01, DF_SCROLLABLE = 0x02, DF_CLR_ON_REDRAW = 0x04, DF_TAB_SPACES = 0x04, DF_OWNER_DRAW = 0x08, DF_POPUP_RADIO = 0x20, DF_SCREEN_SAVE = 0x40, DF_SKIP = 0x80};

An enumeration to describe possible item flags in a dialog box.

This enumeration describes all the possible item flags in a dialog box. See DialogAdd for more informations.


DialogTypes

enum DialogTypes {D_END = 0, D_MENU = 1, D_EDIT_FIELD = 2, D_SCROLL_REGION = 3, D_OPTION = 4, D_RADIO = 5, D_BUTTON = 6, D_TEXT = 7, D_HEADER = 8, D_POPUP = 10, D_DYNPOPUP = 11, D_HEDIT = 12, D_DYNHEADER = 13, D_HPOPUP = 14, D_XFLAGS = 15};

An enumeration to describe possible item types in a dialog box.

This enumeration describes all the possible item types in a dialog box. See DialogAdd for more informations.

See also: DialogAdd, DIALOG_ITEM


DialogXFlags

AMS 2.00 or higher

enum DialogXFlags {
XF_ALLOW_VARLINK = 0x0001, XF_TE_REPAINT = 0x0002, XF_NO_ALPHA_LOCK = 0x0004, XF_VARLINK_SELECT_ONLY = 0x8001
};

An enumeration to describe possible XFlags in a dialog box.

This enumeration describes all the possible XFlags in a dialog box. See DialogAddXFlags for more informations.


OWNER_DRAW_STRUCT

typedef struct {
DIALOG_ITEM *Item;
WINDOW *pW;
} OWNER_DRAW_STRUCT;

A scructure for defining an owner draw item.

This structure defines an owner draw item. A pointer to this structure is given to the callback function when an owner draw item is (re)created. See DialogNew for more informations.


SIZED_DIALOG

#define SIZED_DIALOG(NumbItems,StrLen) struct {
unsigned short TextOffset;
unsigned short NumItems;
unsigned char Width, Height;
Dialog_Callback_t Callback;
DIALOG_ITEM Fields[(NumbItems)+1];
char String[StrLen];
}

A macro to help defining dialogs, it is nearly the same as DIALOG.

There are two main difficulties one encounters using the DIALOG structure:
First there is a variable size array, and variable size arrays can't be initialized with non constant value.
Secondly it doesn't include strings, which should better be placed just after the DIALOG in memory.
SIZED_DIALOG avoids both of these problems: It needs two argument : the number of Items NumbItems and the size of the all the strings together StrLen, and defines a struct from this, wich is the same as DIALOG but with some place for the strings: you can define a dilalog using SIZED_DIALOG(NumbItems,StrLen)={/*Dialog definition*/}. It is done in the given examples. If you use that macro, it will fill to the right number of Item, and If you forget to add an item with type D_END after the last used Item, it is automatically done.

Using SIZED_DIALOG also helps to get the offset of the strings. You can initialize it with offsetof(SIZED_DIALOG(ItemsNum,0),String)


Return to the main index