Include Files
DCCUSTOM.CH..........The User-Defined, "custom" command set
DCSTD.CH.............The "Standard" command set
DCPRINT.CH...........The "Printer" Command set
DCDIALOG.CH..........The "Robust Dialogue" command set
DCDIR.CH.............The "Directory Dialogue" command set
DCTREE.CH............The "Array-Tree Dialogue" command set
DCUDC.CH.............The "User-Defined Command" template
DCAPP.CH.............The "Application Dialogue" command set
EXPRESS.CH...........The "Clipper Compatabile" Command Set
DCXTOC.CH............The Xbase to Clipper Interface definitions
DIALOG GETLIST.......The Dialog Get-List Array
DIALOG OPTIONS.......The Dialog Get Options Array
DCCUSTOM.CH
The User-Defined, "custom" command set
Description:
The DCCUSTOM.CH file is an "include" file that is used to
pre-process user-defined dot-prompt commands.
DCCUSTOM.CH is automatically loaded the first time a command is
entered at the dot-prompt. This file must exist in your
INCLUDE=<þincludeþ> path or an error window will be displayed
the first time you try to enter a command.
User-defined commands that are entered in this file will be
available at the dot-prompt.
NOTE: It is recommended that you place all your user-defined
commands in your own *.CH files and then #include these files
in DCCUSTOM.CH.
CAUTION: If there are any syntax errors in the *.CH files you
#include in DCCUSTOM.CH, an error window will be displayed the
first time you try to enter a dot-prompt command.
Source/Library:
DCCUSTOM.CH
See Also:
DCSTD.CH
DCSTD.CH
The "Standard" command set
Description:
The DCSTD.CH file is an "include" file that is used to
pre-process miscellaneous commands and dot-prompt commands.
This is the "standard" command set that is basically equivalent
to Alaska's STD.CH. This command set overloads some commands
in STD.CH to provide extra functionality, such as progress
bars in database commands.
DCSTD.CH is automatically loaded the first time a command is
entered at the dot-prompt. This file must exist in your
INCLUDE=<þincludeþ> path or an error window will be displayed
the first time you try to enter a command.
Source/Library:
DCSTD.CH
See Also:
DC_Dot()
DCPRINT.CH
The "Printer" Command set
Description:
The DCPRINT.CH file is an "include" file that is used to
preprocess Clipper and Xbase++ @SAY.. style print commands
to use the eXPress++ Printer class rather than the
text-based system.
The printer class creates a printed page that is similar
to the text-based printer page supported by SET DEVICE TO
PRINT, except that it allows for any number of rows and
columns on the page and provides a printer dialog setup
system for the operator to choose the printer device, the
default font, number of copies, etc.
The printer class allows for both text-based coordinates
and pixel-based coordinates in the same print project.
This allows for existing Clipper reports to be embellished
with graphics, lines, font-changes, etc. without requiring
the writing of an entirely new report.
Examples:
#include "dcprint.ch"
PROCEDURE XTest( lPreview )
LOCAL aFor_Sale, oPrinter, i, nLineCount, cMemo, cMemoLine, cScrn
lPreview := IIF( Valtype(lPreview)='L',lPreview,.t.)
USE collect NEW
aFor_Sale := { 'No','Yes','Not Sure' }
BEGIN SEQUENCE
IF lPreview
DCPRINT ON SIZE 60,100 TO oPrinter FONT '12.Courier' PREVIEW
ELSE
DCPRINT ON SIZE 60,100 TO oPrinter FONT '12.Courier'
ENDIF
IF Valtype(oPrinter) # 'O' .OR. !oPrinter:lActive
BREAK
ENDIF
DC_Gui(.t.)
IF !lPreview
cScrn := DC_WaitOn()
ENDIF
DO WHILE !Eof()
@ 2,0,20,45 DCPRINT BITMAP COLLECT->bitmap1
@ 2,50,20,95 DCPRINT BITMAP COLLECT->bitmap2
DCPRINT FONT '12.Courier'
@ 23, 5, 37, 90 DCPRINT BOX
@ 24,10 DCPRINT SAY ' Description:'
@ 25,10 DCPRINT SAY ' Type:'
@ 26,10 DCPRINT SAY ' Sub-Type:'
@ 27,10 DCPRINT SAY ' Condition:'
@ 28,10 DCPRINT SAY ' Location:'
@ 29,10 DCPRINT SAY ' For Sale?:'
@ 30,10 DCPRINT SAY ' Original Date:'
@ 31,10 DCPRINT SAY ' Acquired Date:'
@ 32,10 DCPRINT SAY ' Original Price:'
@ 33,10 DCPRINT SAY 'Appraised Value:'
@ 34,10 DCPRINT SAY ' Comments:'
@ 35,10 DCPRINT SAY ' Bit Map 1:'
@ 36,10 DCPRINT SAY ' Bit Map 2:'
DCPRINT FONT '14.Terminal'
@ 24,32 DCPRINT SAY COLLECT->descrip
@ 25,32 DCPRINT SAY COLLECT->type
@ 26,32 DCPRINT SAY COLLECT->sub_type
@ 27,32 DCPRINT SAY COLLECT->condition
@ 28,32 DCPRINT SAY COLLECT->location
@ 29,32 DCPRINT SAY aFor_Sale[COLLECT->for_sale+1]
@ 30,32 DCPRINT SAY COLLECT->date_orig
@ 31,32 DCPRINT SAY COLLECT->date_acqu
@ 32,32 DCPRINT SAY COLLECT->orig_price
@ 33,32 DCPRINT SAY COLLECT->appr_value
@ 34,32 DCPRINT SAY COLLECT->comments
@ 35,32 DCPRINT SAY COLLECT->bitmap1
@ 36,32 DCPRINT SAY COLLECT->bitmap2
DCPRINT FONT '12.Arial'
cMemo := Alltrim(COLLECT->memo)
nLineCount := MLCount(cMemo)
FOR i := 1 TO nLineCount - 1
cMemoLine := MemoLine( cMemo, nil, i )
IF Empty(cMemoLine)
EXIT
ENDIF
@ 40+i,10 DCPRINT SAY cMemoLine
NEXT
DCPRINT EJECT
SKIP
ENDDO
IF !lPreview
DC_Impl(cScrn)
ENDIF
END SEQUENCE
DCPRINT OFF
RETURN
Source/Library:
DCPRINT.CH
See Also:
dc_printer()
DCPRINT ON
DCDIALOG.CH
The "Robust Dialogue" command set
Description:
The DCDIALOG.CH file is an "include" file that is used to
preprocess text-based and pixel-based dialog commands. Each
command parses the properties of the dialog item into the
Getlist array which is later passed to the eXPress++ GUI reader.
It is highly recommended that you use DCDIALOG.CH instead of
EXPRESS.CH because it contains a much more robust set of commands
that allows you to utilize the full power of the GUI dialogue
system. These commands are "structurally" similar to the commands
in EXPRESS.CH except @ .. SAY is changed to @ .. DCSAY and all
other commands start with DC*. This was done so as to prevent
conflicts with the standard Xbase++ command set and allow
you to mix standard non-GUI @ SAY..GET commands and
eXpress++ GUI @ DCSAY..GET commands in the same source
code.
The eXPress GUI reader accepts a GetList array that contains
the properties of Xbase Parts which can be combined into a
complex dialogue system with very simple commands. This
command system makes it easy to build dialogues using a
simple procedural approach that is familiar to Clipper
programmers rather than complicated object-oriented
programming. You can combine @ SAY..GETs, ComboBoxes,
ListBoxes, Multiline Gets, Icons, Bitmaps, Toolbars,
CheckBoxes, RadioButtons, Pushbuttons, TabPages, 3-State
objects, etc. all in a single Getlist to be passed to the
GUI reader as a complete dialog.
Examples:
/*
This is an example of a dialogue with 3 tab pages. The first
tab page has a Get and a set of combo-boxes with picklist
choices. The second tabpage has a date field with a pop-up
calendar and two numeric fields with pop-up calculator.
The third tabpage has a multi-line get for editing a memo.
*/
#include 'dcdialog.ch'
PROCEDURE Xtest()
LOCAL oTabPage1, oTabPage2, oTabPage3, cDesc := Space(30),;
aType := {'Star-Trek','Hollywood','Sports','Other'},;
cType := Space(15), dDateOrig := Date(), dDateAcqu := Date(),;
nOrigPrice := 0, nApprValue := 0, cMemo := '', ;
GetList := {}
/* ---- Tab Page #1 ---- */
@ 0,0 DCTABPAGE oTabPage1 CAPTION 'Collection' ;
SIZE 72,15 PREOFFSET 0 POSTOFFSET 85
@ 3,2 DCSAY "Description" GET cDesc SAYRIGHT PARENT oTabPage1
@ 5,10 DCSAY "Type" PARENT oTabPage1 SAYSIZE 8
@ 6,10 DCCOMBOBOX cType LIST aType SIZE 12,6 PARENT oTabPage1
/* ---- Tab Page #2 ---- */
@ 0,0 DCTABPAGE oTabPage2 CAPTION 'Financial' ;
RELATIVE oTabPage1
@ 4,2 DCSAY " Original Date" GET dDateOrig PICT '99/99/9999' ;
PARENT oTabPage2 SAYRIGHT
@ 6,2 DCSAY " Acquired Date" GET dDateAcqu PICT '99/99/9999' ;
PARENT oTabPage2 SAYRIGHT
@ 8,2 DCSAY " Acquired Price" GET nOrigPrice PICT '9999.99' ;
PARENT oTabPage2 SAYRIGHT
@ 10,2 DCSAY "Appraised Value" GET nApprValue PICT '9999.99' ;
PARENT oTabPage2 SAYRIGHT
/* ---- Tab Page #3 ---- */
@ 0,0 DCTABPAGE oTabPage3 CAPTION 'Memo' ;
RELATIVE oTabPage2
@ 5,2 DCMULTILINE cMemo PARENT oTabPage3 SIZE 65,8 ;
FONT "10.Courier.Bold"
DCREAD GUI ;
TITLE 'Tab-Page Demo' ;
FIT ;
ADDBUTTONS
RETURN
See Also:
DIALOG GETLIST
DCDIR.CH
The "Directory Dialogue" command set
Description:
The DCDIR.CH file is an "include" file that is used to
preprocess eXPress++ "directory" commands for use by
the GUI reader system. Directory commands are commands
which create directory and/or file choice dialogues via the
eXPress++ GetList-style GUI reader. This include file
contains commands like DCDIRTREE which is used to display
a dialog that uses the XbpTreeView class to create a means for
choosing a file from a directory tree.
The eXPress GUI reader accepts a GetList array that contains
The properties of Xbase Parts can can be combined into a
complex dialogue system with very simple commands. This
command system makes it easy to build dialogues using a
simple procedural approach that is familiar to Clipper
programmers rather than complicated object-oriented
programming. You can combine @ SAY..GETs, ComboBoxes,
ListBoxes, Multiline Gets, Icons, Bitmaps, Toolbars,
CheckBoxes, RadioButtons, Pushbuttons, TabPages, 3-State
objects, etc. all in a single Getlist to be passed to the
GUI reader as a complete dialog.
Examples:
#include "dcdir.ch"
PROCEDURE XTest( )
LOCAL GetList := {}, oDirs, oFiles, cFileName, ;
oFileName, cDirectory
cFileName := Space(30)
cDirectory := ''
@ 2,1 DCGET cFileName GETSIZE 40 GETOBJECT oFileName
@ 3.5,1 DCDIRTREE ;
DIRS oDirs VAR cDirectory ;
FILES oFiles VAR cFileName DATALINK {||oFileName:SetData()} ;
SIZE 40,10.5 ;
EXT '*.ICO','*.BMP','*.JPG','*.*'
DCREAD GUI ;
TITLE 'eXPress++ Demo Program' ;
FIT ;
ADDBUTTONS
RETURN
See Also:
DIALOG GETLIST
DCTREE.CH
The "Array-Tree Dialogue" command set
Description:
The DCTREE.CH file is an "include" file that is used to
preprocess eXPress++ "array tree" commands for use by
the GUI reader system. Array-Tree commands are commands
which create array-browser dialogues via the eXPress++
GetList-style GUI reader. This include file contains commands
like DCARRAYTREE which is used to display a dialog that uses the
XbpTreeView class to create a means for browsing multiple
dimensional arrays with various options.
The eXPress GUI reader accepts a GetList array that contains
The properties of Xbase Parts can can be combined into a
complex dialogue system with very simple commands. This
command system makes it easy to build dialogues using a
simple procedural approach that is familiar to Clipper
programmers rather than complicated object-oriented
programming. You can combine @ SAY..GETs, ComboBoxes,
ListBoxes, Multiline Gets, Icons, Bitmaps, Toolbars,
CheckBoxes, RadioButtons, Pushbuttons, TabPages, 3-State
objects, etc. all in a single Getlist to be passed to the
GUI reader as a complete dialog.
Examples:
#include "dcdir.ch"
PROCEDURE XTest( )
LOCAL GetList := {}, oDirs, oFiles, cFileName, ;
oFileName, cDirectory
cFileName := Space(30)
cDirectory := ''
@ 2,1 DCGET cFileName GETSIZE 40 GETOBJECT oFileName
@ 3.5,1 DCDIRTREE ;
DIRS oDirs VAR cDirectory ;
FILES oFiles VAR cFileName DATALINK {||oFileName:SetData()} ;
SIZE 40,10.5 ;
EXT '*.ICO','*.BMP','*.JPG','*.*'
DCREAD GUI ;
TITLE 'eXPress++ Demo Program' ;
FIT ;
ADDBUTTONS
RETURN
See Also:
DIALOG GETLIST
DCUDC.CH
The "User-Defined Command" template
Description:
The DCUDC.CH file is an "include" file that is used to
preprocess eXPress++ "User Defined Commands" for use by
the GUI reader system. Use this file as a "template" or an
example for creating custom commands.
The eXPress GUI reader accepts a GetList array that contains
The properties of Xbase Parts can can be combined into a
complex dialogue system with very simple commands. This
command system makes it easy to build dialogues using a
simple procedural approach that is familiar to Clipper
programmers rather than complicated object-oriented
programming. You can combine @ SAY..GETs, ComboBoxes,
ListBoxes, Multiline Gets, Icons, Bitmaps, Toolbars,
CheckBoxes, RadioButtons, Pushbuttons, TabPages, 3-State
objects, etc. all in a single Getlist to be passed to the
GUI reader as a complete dialog.
Examples:
#include "dcdir.ch"
PROCEDURE XTest( )
LOCAL GetList := {}, oDirs, oFiles, cFileName, ;
oFileName, cDirectory
cFileName := Space(30)
cDirectory := ''
@ 2,1 DCGET cFileName GETSIZE 40 GETOBJECT oFileName
@ 3.5,1 DCDIRTREE ;
DIRS oDirs VAR cDirectory ;
FILES oFiles VAR cFileName DATALINK {||oFileName:SetData()} ;
SIZE 40,10.5 ;
EXT '*.ICO','*.BMP','*.JPG','*.*'
DCREAD GUI ;
TITLE 'eXPress++ Demo Program' ;
FIT ;
ADDBUTTONS
RETURN
Source/Library:
DCUDC.CH
See Also:
USER-DEFINED COMMANDS
DIALOG GETLIST
DCAPP.CH
The "Application Dialogue" command set
Description:
The DCAPP.CH file is an "include" file that is used to preprocess
eXPress++ "application" commands for use by the GUI reader system.
Application commands are commands which are compatible with
Xbase++ "application parts" like APPEDIT, APPBROWSE and APPFIELD.
The GetList version of these commands are DCAPPEDIT, DCAPPBROWSE
and DCAPPFIELD, respectively, and are functionally equivalent.
The eXPress GUI reader accepts a GetList array that contains
the properties of Xbase Parts which can be combined into a
complex dialogue system with very simple commands. This
command system makes it easy to build dialogues using a
simple procedural approach that is familiar to Clipper
programmers rather than complicated object-oriented
programming. You can combine @ SAY..GETs, ComboBoxes,
ListBoxes, Multiline Gets, Icons, Bitmaps, Toolbars,
CheckBoxes, RadioButtons, Pushbuttons, TabPages, 3-State
objects, etc. all in a single Getlist to be passed to the
GUI reader as a complete dialog.
Examples:
#include "dcapp.ch"
#include "xbp.ch"
#include "gra.ch"
#include "appevent.ch"
PROCEDURE Xtest()
LOCAL GetList := {}, GetOptions, oTabPage1, oTabPage2, oTabPage3, ;
oStatic1, oStatic2, oStatic3, oToolBar, oAppEdit1, oAppEdit2, ;
oAppEdit3
USE COLLECT NEW SHARED
/* ---- Tab Page #1 ---- */
@ 0,0 DCTABPAGE oTabPage1 CAPTION 'Plain' ;
SIZE 80,20.5 PREOFFSET 0 POSTOFFSET 85 ;
COLOR GRA_CLR_BLUE
@ 1.5,1 DCSTATIC XBPSTATIC_TYPE_RAISEDBOX SIZE 78,18.5 ;
GROUP oStatic1 PARENT oTabPage1
DCAPPEDIT INTO oAppEdit1 STYLE PLAIN POSITION 0,0 PARENT oStatic1
/* ---- Tab Page #2 ---- */
@ 0,0 DCTABPAGE oTabPage2 CAPTION '3D' ;
RELATIVE oTabPage1 ;
COLOR GRA_CLR_RED
@ 1.5,1 DCSTATIC XBPSTATIC_TYPE_RAISEDBOX SIZE 78,18.5 ;
GROUP oStatic2 PARENT oTabPage2
DCAPPEDIT INTO oAppEdit2 STYLE 3D POSITION 0,0 PARENT oStatic2
/* ---- Tab Page #3 ---- */
@ 0,0 DCTABPAGE oTabPage3 CAPTION 'Fancy' ;
RELATIVE oTabPage2 ;
COLOR GRA_CLR_YELLOW
@ 1.5,1 DCSTATIC XBPSTATIC_TYPE_RAISEDBOX SIZE 78,18.5 ;
GROUP oStatic3 PARENT oTabPage3
DCAPPEDIT INTO oAppEdit3 STYLE FANCY POSITION 0,0 PARENT oStatic3
/* ---- Tool Bar ---- */
DCTOOLBAR oToolBar ALIGN TOOLBAR_RIGHT SIZE 7.1
DCADDBUTTON CAPTION '&Exit' ;
PARENT oToolBar ;
SIZE 7,1 ;
ACTION {||DC_ReadGuiEvent(DCGUI_EXIT_OK)}
DCGETOPTIONS WINDOW HEIGHT 440 ;
WINDOW WIDTH 620
DCREAD GUI ;
OPTIONS GetOptions ;
TITLE 'Application Edit Demo'
CLOSE collect
RETURN
See Also:
DIALOG GETLIST
EXPRESS.CH
The "Clipper Compatabile" Command Set
Description:
The EXPRESS.CH file is an "include" file that is used to
preprocess standard text-based Clipper and Xbase++ @SAY..GET
commands and other screen-oriented, text-based command to use
eXPress++ GUI and text-based readers rather than the standard
Clipper-compatible reader.
It is highly recommended that once you get familiarized
with the eXpress++ concept, that you use DCDIALOG.CH
instead of EXPRESS.CH because it contains a much more
robust set of commands that allows you to utilize the full
power of the GUI dialogue system. These commands are
"structurally" similar to the commands in EXPRESS.CH
except @ .. SAY is changed to @ .. DCSAY and all other
commands start with DC*. This was done so as to prevent
conflicts with the standard Xbase++ command set and allow
you to mix standard non-GUI @ SAY..GET commands and
eXpress++ GUI @ DCSAY..GET commands in the same source
code.
The eXPress GUI reader accepts a GetList array that contains
the properties of Xbase Parts which can be combined into a
complex dialogue system with very simple commands. This
command system makes it easy to build dialogues using a
simple procedural approach that is familiar to Clipper
programmers rather than complicated object-oriented
programming. You can combine @ SAY..GETs, ComboBoxes,
ListBoxes, Multiline Gets, Icons, Bitmaps, Toolbars,
CheckBoxes, RadioButtons, Pushbuttons, TabPages, 3-State
objects, etc. all in a single Getlist to be passed to the
GUI reader as a complete dialog.
Source/Library:
EXPRESS.CH
DCXTOC.CH
The Xbase to Clipper Interface definitions
Description:
The DCXTOC.CH file is an "include" file that contains definitions
for the array that is passed to DC_XCCall(). This array is used
to setup a call to the X2CLIP interface for calling a Clipper
program to accomplished faster database operations.
Examples:
#include "dcxtoc.ch"
PROCEDURE XTest()
/*
This example demonstrates a re-indexing
progress bar which using the X2CLIP interface.
This interface spawns a Clipper
program to create the index.
*/
LOCAL aParams, nHandle, lStatus := .t., aIndex, oDlg, ;
oSay, oProgress, bEval, lOk := .t., GetList := {}, ;
i, nSeconds
nHandle := DC_XCOpen()
IF nHandle <= 0
RETURN .f.
ENDIF
@ 1,1 DCSAY 'Creating Indexes'
@ 2,1 DCSAY '' SAYOBJECT oSay SAYSIZE 40
@ 4,1 DCPROGRESS oProgress SIZE 40,1.2 ;
COLOR GRA_CLR_RED PERCENT ;
EVERY IIF( nMode=1,100,1 )
DCREAD GUI EXIT FIT PARENT @oDlg ;
TITLE "Indexing Example"
BEGIN SEQUENCE
aParams := DC_XCArray()
aParams[XC_ARRAY_DEFAULT] := 'C:\express\sample'
aParams[XC_ARRAY_DATABASE] := 'XTEST.DBF'
aParams[XC_ARRAY_RDD] := 'DBFCDX'
aParams[XC_ARRAY_OPERATION] := XC_OPENDATA
IF !DC_XCCall( nHandle, aParams )
lOk := .f.
BREAK
ENDIF
aIndex := { ;
{ 'AREACODE','AREACODE',nil,.f.,.f.}, ;
{ 'EXCHANGE','EXCHANGE',nil,.f.,.f.}, ;
{ 'CITY', 'CITY',nil,.f.,.f.} ;
}
bEval := {|nCurr,nMax|DC_GetProgress(oProgress,nCurr,nMax)}
nSeconds := Seconds()
FOR i := 1 TO Len(aIndex)
oSay:setCaption('Creating Tag ' + aIndex[i,2])
aParams := DC_XCArray()
aParams[XC_ARRAY_DEFAULT] := 'C:\express\sample'
aParams[XC_ARRAY_INDEX] := 'XTEST.CDX'
aParams[XC_ARRAY_OPERATION] := XC_CREATEINDEX
aParams[XC_ARRAY_TAG] := aIndex[i,1]
aParams[XC_ARRAY_KEY] := aIndex[i,2]
aParams[XC_ARRAY_FOR] := aIndex[i,3]
aParams[XC_ARRAY_UNIQUE] := aIndex[i,4]
aParams[XC_ARRAY_DESCEND] := aIndex[i,5]
IF !DC_XCCall( nHandle, aParams, bEval, 5 )
lOk := .f.
BREAK
ENDIF
NEXT
END SEQUENCE
oDlg:Destroy()
DC_XCClose( nHandle )
RETURN lOk
Source/Library:
DCXTOC.CH
See Also:
X2CLIP.EXE
DIALOG GETLIST
The Dialog Get-List Array
Description:
The eXPress++ dialogue system is based on a "Get-List" concept,
similar to the one employed in Clipper and in Xbase++ text mode.
The advantages of this concept are multifold:
1. A dialog screen can be designed as a simple set of commands.
2. The dialog can be saved to databases or arrays and used in
data-driven applications.
3. A dialog can be easily passed from one application to another
or from one function to another in the same application.
4. The dialog can be easily modified.
The Get-List is simply an array of dialog objects. eXPress++
commands are used to add objects to the Get-List. These commands
are included in DCDIALOG.CH. Before using any DCDIALOG.CH
commands you must first initialize the Getlist as an empty array
like so:
LOCAL GetList := {}
You may add as many commands as you wish to the Getlist and
create complicated dialogue screens with multiple tabpages,
static groups, browses, etc.
Use the function DC_READGETS(GetList) to invoke the Text or GUI
reader. NOTE: some commands are only available in GUI mode so
will be ignored the the text reader.
Each DC* command adds a sub-array of 61 elements to the main
GetList array, with the exception of @ ..SAY..GET which adds two
sub-arrays, one for the SAY and one for the GET. Each sub-array
consists of the following items:
nGETLIST_TYPE
This is the type of object to paint on the dialogue screen. The
supported types are defined in DCDIALOG.CH and are listed below:
GETLIST_DIALOG - DIALOG, XbpDialog()
GETLIST_STATIC - STATIC, XbpStatic()
GETLIST_GET - GET, XbpGet()
GETLIST_MLE - MULTI-LINE GET, XbpMLE()
GETLIST_3STATE - 3-STATE, Xbp3State()
GETLIST_CHECKBOX - CHECKBOX, XbpCheckBox()
GETLIST_COMBOBOX - COMBOBOX, XbpCombobox()
GETLIST_LISTBOX - LIST BOX, XbpListBox()
GETLIST_PUSHBUTTON - PUSHBUTTON, XbpPushButton()
GETLIST_RADIOBUTTON - RADIO BUTTON, XbpRadioButton()
GETLIST_SAY - SAY, XbpStatic() text
GETLIST_ADDBUTTON - RADIO BUTTON, XbpStatic() on Toolbar
GETLIST_SPINBUTTON - SPIN BUTTON, XbpSpinButton()
GETLIST_GROUPBOX - GROUP BOX, XbpStatic()
GETLIST_TABPAGE - TAB PAGE, XbpTabPage()
GETLIST_SCROLLBAR - SCROLL BAR, XbpScrollBar()
GETLIST_BITMAP - BIT MAP, XbpBitMap(), XbpPresSpace()
GETLIST_METAFILE - METAFILE, XbpMetaFile()
GETLIST_TOOLBAR - TOOLBAR, XbpStatic()
GETLIST_MENUBAR - MENUBAR, XbpMenu()
GETLIST_SUBMENU - SUB MENU, XbpMenu()
GETLIST_MENUITEM - MENU ITEM, XbpMenu():additem
GETLIST_BROWSE - BROWSE, XbpBrowse()
GETLIST_BROWSECOL - BROWSE COLUMN, XbpColumn()
GETLIST_MESSAGEBOX - MESSAGE AREA, XbpStatic()
GETLIST_CUSTOM - CUSTOM OBJECT, Anything
GETLIST_APPCRT - Application CRT Window - XbpCrt()
GETLIST_APPEDIT - Application EDIT Window - APPEDIT
GETLIST_APPBROWSE - Application BROWSE Window - APPBROWSE
GETLIST_APPFIELD - Application FIELD - APPFIELD
GETLIST_DIRTREE - Directory Tree DIALOG - XbpTreeView()
GETLIST_STATUS - Status Bar
GETLIST_PROGRESS - Progress Bar, XbpStatic()
GETLIST_HOTKEY - Hot Key accelerator
GETLIST_PICKLIST - Special Pick-List Dialog
GETLIST_USER - User-Defined Commands (Start Offset)
GETLIST_DATASTORE - Reserved for storage of Static Data
nGETLIST_SUBTYPE
This is used only on objects that have a sub-type such as
DCSTATIC objects. Sub-Types are usually defined in XBP.CH.
cGETLIST_CAPTION
This is used on objects that have a caption like DCSTATIC,
DCPUSHBUTTON, etc.
bGETLIST_VAR
This is an "anchor" code block which is usually used as the
:datalink to the Xbase part. The function DC_GetAnchorCB() is
used to create a code block which provides access to a local
memory variable. For example, if this object were a GET, the
code block may look like this:
{|x| IIf( PCount()==0 , uVar, uVar:=x) }
It is also be used to provide a link to a local array which is
used for list-boxes, combo-boxes, etc.
It can be passed as a single code block or as an array of two
elements: the first being the code block and the second being
the string representation of the code block. Passing an array
allows for "data-driven" applications because the reader will
automatically macro-compile the string to a code-block if the
code block does not exist.
nGETLIST_STARTROW
This is the Start Row of the object, relative to 0 (top) of the
parent object, unless bGETLIST_RELATIVE contains a code-block.
If lGETLIST_PIXEL is .TRUE. then this should be in pixels,
otherwise it is in text-based coordinates.
nGETLIST_STARTCOL
This is the Start Column of the object, relative to 0 (left) of
the parent object, unless bGETLIST_RELATIVE contains a
code-block. If lGETLIST_PIXEL is .TRUE. then this should be in
pixels, otherwise it is in text-based coordinates.
nGETLIST_ENDROW
This is the End Row of the object, relative to 0 (top) of the
parent object. If lGETLIST_PIXEL is .TRUE. then this should
be in pixels, otherwise it is in text-based coordinates.
nGETLIST_ENDCOL
This is the End Column of the object, relative to 0 (left) of
the parent object. If lGETLIST_PIXEL is .TRUE. then this should
be in pixels, otherwise it is in text-based coordinates.
nGETLIST_WIDTH
This is the Width of the object. If lGETLIST_PIXEL is .TRUE.
then this should be in pixels, otherwise it is a text-based
number.
nGETLIST_HEIGHT
This is the Height of the object. If lGETLIST_PIXEL is .TRUE.
then this should be in pixels, otherwise it is a text-based
number.
oGETLIST_FONT
The is the Font. If left empty, then the font is inherited
from the parent. This may be a font object created by XbpFont()
or the name of a font.
cGETLIST_PICTURE
This is a picture clause and is used only with GET objects to
define the picture of the GET, ex: "99/99/9999".
bGETLIST_WHEN
This is a code block which is evaluated after other events which
may affect memory variables or database pointers in the
application. If the return value of the code block is .FALSE.
then the object is disabled with the :disable() method. If the
return value of the code block is .TRUE. then the object is
enabled with the :enable() method.
It can be passed as a single code block or as an array of two
elements: the first being the code block and the second being
the string representation of the code block. Passing an array
allows for "data-driven" applications because the reader will
automatically macro-compile the string to a code-block if the
code block does not exist.
bGETLIST_VALID
This is a code block which is evaluated when the object loses
focus. If the return value is .FALSE. then the object remains
in focus.
It can be passed as a single code block or as an array of two
elements: the first being the code block and the second being
the string representation of the code block. Passing an array
allows for "data-driven" applications because the reader will
automatically macro-compile the string to a code-block if the
code block does not exist.
cGETLIST_TOOLTIP
This is a message to display in a "tool-tip" when the mouse is
placed over the object.
xGETLIST_CARGO
This is any kind of data you wish to to add to the :cargo
container for this object. The cargo may be accessed at any
time via the <þoObjectþ>:cargo exported variable, however it will
not be stored in the same manner it is entered. The :cargo
container of DCDIALOG objects is an array of at least three
elements:
[1] - A numeric value that is a pointer to the Getlist array
for this object.
[2] - A pointer to the GetList array.
[3] - The value of <þxCargoþ>.
[4] and up - optional values added by the GUI reader.
aGETLIST_PRESENTATION
This is an array of presentation parameters that conforms to
the standard presentation specification for Xbase parts.
This is a two dimensional array. If specified, this contains
presentation parameters for the Xbase Parts object. The first
column of the array must contain #define constants from the
XBP.CH file starting with the prefix XBP_PP_. These constants
define the presentation parameters that can be set for the
Xbase Parts object and include colors and fonts. The second
column of the array contains the value for each setting.
These are usually set using #define constantse from the
GRA.CH file:
bGETLIST_ACTION
This is a code block that is evaluated by some Xbase Parts
objects which cause an action, such as a Push-Button or a
menu item.
It can be passed as a single code block or as an array of two
elements: the first being the code block and the second being
the string representation of the code block. Passing an array
allows for "data-driven" applications because the reader will
automatically macro-compile the string to a code-block if the
code block does not exist.
oGETLIST_OBJECT
This is a spare.
This is an "anchor" code block which is used to assign a local
variable to the Xbase Part after it is created by DC_ReadGui().
xGETLIST_ORIGVALUE
This is an empty container which is used by DC_ReadGui() to
store the original value of the variable which has been data-
linked to the Xbase Parts object.
xGETLIST_OPTIONS
This is used to pass optional parameters to the Xbase Part.
Some objects have additional features, such as the :spinFast
option of a SPIN BUTTON. Features that are unique to an object
are handled here.
aGETLIST_COLOR
This is a two-element array consisting of a ForeGround and a
BackGround color for the object. By default, the object inherits
the colors of the parent object. The values in the array my be
color-strings that conform to SetColor() type colors or numerical
values that conform to GRA_* type colors defined in GRA.CH.
The colors may also be set via aGETLIST_PRESENTATION.
cGETLIST_MESSAGE
This is the text of a message which is display in a DCMESSAGEBOX
object when this object has focus.
cGETLIST_HELPCODE
This is the help code that is passed to DC_HelpF1() "in text
mode" or to a *.HLP file "in GUI mode" if the F1 (Help) key is
pressed when this object is in focus. In GUI mode, the GET
option HELPFILE <þcHelpFileþ> is required to identify the Windows
.HLP file containing the context help.
cGETLIST_VARNAME
This is the character string name of the variable that has been
data-linked to the object via bGETLIST_VAR
bGETLIST_READVAR
This is provided for compatability with DC_ReadModal(), text-
based gets.
It can be passed as a single code block or as an array of two
elements: the first being the code block and the second being
the string representation of the code block. Passing an array
allows for "data-driven" applications because the reader will
automatically macro-compile the string to a code-block if the
code block does not exist.
bGETLIST_DELIMVAR
This is an "anchor" code block which is used to assign a local
variable to the delimeter variable. A delimeter variable is
only used by text-based Radio-Buttons and Check-boxes and is
needed with DC_ReadModal(), the Text-based reader.
It can be passed as a single code block or as an array of two
elements: the first being the code block and the second being
the string representation of the code block. Passing an array
allows for "data-driven" applications because the reader will
automatically macro-compile the string to a code-block if the
code block does not exist.
bGETLIST_GROUP
This is an "anchor" code block which is used to assign a local
variable to the Xbase Part after it is created by DC_ReadGui().
The local variable is used as a pointer to this object when it
it needed as a "parent" to other objects.
It can be passed as a single code block or as an array of two
elements: the first being the code block and the second being
the string representation of the code block. Passing an array
allows for "data-driven" applications because the reader will
automatically macro-compile the string to a code-block if the
code block does not exist.
nGETLIST_POINTER
This is a numeric pointer to another GetList item which may be
associated with this item. The number is a GetList sub-array.
For example, a GETLIST_GET item is associated with a GETLIST_SAY
item.
bGETLIST_PARENT
This is an "anchor" code block which is used to assign a local
variable to the Xbase Part after it is created by DC_ReadGui().
The local variable is used as a pointer to the "parent" object
which this object attaches itself to.
It can be passed as a single code block or as an array of two
elements: the first being the code block and the second being
the string representation of the code block. Passing an array
allows for "data-driven" applications because the reader will
automatically macro-compile the string to a code-block if the
code block does not exist.
bGETLIST_REFVAR
This is an "anchor" code block which is usually used as the
:datalink to the Xbase part. The function DC_GetAnchorCB() is
used to create a code block which provides access to a local
memory variable. This is used only when bGETLIST_VAR is used
for another purpose such as a pointer to an array for a
LIST BOX.
It can be passed as a single code block or as an array of two
elements: the first being the code block and the second being
the string representation of the code block. Passing an array
allows for "data-driven" applications because the reader will
automatically macro-compile the string to a code-block if the
code block does not exist.
lGETLIST_PROTECT
This is used on objects that get and display information. If
this is .TRUE. then the data is protected from editing.
lGETLIST_PIXEL
This is used to establish whether coordinate and size parameters
are in PIXELS or text-based. If this is .FALSE., then the
coordinate and size parameters are converted to pixel-based by
the GUI reader.
nGETLIST_CURSOR
This is the resource id of an alternate mouse cursor to use for
this object.
bGETLIST_EVAL
This code-block is evaluated as the "last step" after an object
is created by the GUI reader. The object is passed to the code
block. It may be used for anything that may be required during
the intialization process of an object by the GUI reader. For
example, let's say we have a static object that displays a color
using GraBox(). We want to insure that the object is refilled
with the color whenever it is repainted. We accomplish this
with the following codeblock:
{|o|o:paint := {|o|RGB(o,nRed,nGreen,nBlue)} }
It can be passed as a single code block or as an array of two
elements: the first being the code block and the second being
the string representation of the code block. Passing an array
allows for "data-driven" applications because the reader will
automatically macro-compile the string to a code-block if the
code block does not exist.
bGETLIST_RELATIVE
This is an "anchor" code block which is used to assign a local
variable to the Xbase Part after it is created by DC_ReadGui().
The local variable is used as a pointer to a "relative" object
which contains the master coordinates. If this codeblock
evaluates to an object type, then the object's current position
coordinates are used to locate this object and the start
column / start row are relative to the start coordinates of
the object.
RELATIVE addressing is recommended because dialog screen
objects usually have a positional relationship to each other on
the screen and designing screens is much faster when a master
object is moved and all other objects move in relationship to
the master.
It can be passed as a single code block or as an array of two
elements: the first being the code block and the second being
the string representation of the code block. Passing an array
allows for "data-driven" applications because the reader will
automatically macro-compile the string to a code-block if the
code block does not exist.
aGETLIST_OPTIONS2 - aGETLIST_OPTIONS9
These elements are provided for special use.
aGETLIST_LEVEL
This is an optional character string used for "sorting" the
Getlist and to establish a heirarchy tree for GetList items.
It is used by the dCLIP++ DC_DlgEdit() DIALOG editor to
associate parent items with child items.
aGETLIST_TITLE
This is an optional character string used as a "title" for the
Getlist object. It is used by the dCLIP++ DC_DlgEdit() DIALOG
editor when displaying a Tree-style browse of the Get List.
cGETLIST_ACCESS
This is an optional "lock code" to apply to the Getlist item.
It is used by dCLIP++ to provide lock and key access to
individual items in the Getlist dependent on user access rights.
bGETLIST_COMPILE
This is an optional code block which is evaluated at the time
the GetList is loaded by the reader. If the code block returns
a .TRUE., then this item is added to the dialog window, If the
code block returns a .FALSE. then this item is ignored. Use
this option when it is necessary to have "conditional compiling"
capability in applications.
cGETLIST_ID
This is a unique ID for the GetList item. It is reserved for
use by dCLIP++.
dGETLIST_REVDATE
This is the last revised date for this object in the Getlist.
It is used by the dCLIP++ DIALOG editor.
cGETLIST_REVTIME
This is the last revised time for this object in the Getlist.
It is used by the dCLIP++ DIALOG editor.
cGETLIST_REVUSER
This is the USER ID of the user or programmer who last revised
this Getlist item via the dCLIP++ DIALOG editor.
bGETLIST_HIDE
This is a code block which is evaluated after other events which
may affect memory variables or database pointers in the
application. If the return value of the code block is .FALSE.
then the object is hidden with the :hide() method. If the
return value of the code block is .TRUE. then the object is
displayed with the :show() method.
It can be passed as a single code block or as an array of two
elements: the first being the code block and the second being
the string representation of the code block. Passing an array
allows for "data-driven" applications because the reader will
automatically macro-compile the string to a code-block if the
code block does not exist.
nGETLIST_ACCELKEY
This is a numeric value equal to xbeK_* numbers that define
keyboard keys in appevent.ch. Pressing the associated key will
either perform the action associated with the object for objects
like PushButtons, Check-Boxes, Radio-Buttons, Menu Items, etc.
or will set input focus to the associated object if the object
is not an action object.
bGETLIST_GOTFOCUS
This optional code block is evaluated when this object receives
input focus.
bGETLIST_LOSTFOCUS
This optional code block is evaluated when this object loses
input focus.
lGETLIST_TABSTOP,
This logical value when .TRUE. will cause the object (Xbase Part)
to be set when using the Tab key. Note: When logical groups are
defined in a dialog using TABGROUP <þnTabGroupþ>, TABSTOP is
usually set to .T. (true) for the first dialog element in the
group. This allows the first dialog element of a group to be
activated using the Tab key.
nGETLIST_TABGROUP
This option numeric value allows objects (Xbase Parts) that are
created immediately after one another in the GetList to be
combined into logical groups. This allows the user to navigate
within a dialog from group to group by pressing the Tab key.
Within a group of dialog elements navigation is performed using
the cursor keys.
Only constants defined in the XBP.CH file can be used as values
for this instance variable. The following table lists the
available constants:
#define constants for <þnTabGroupþ>:
Constant Description
XBP_NO_GROUP *) Dialog element does not belong to a group
XBP_BEGIN_GROUP Dialog element is the first in a group
(this begins the definition of the group)
XBP_WITHIN_GROUP Dialog element is within a group
XBP_END_GROUP Dialog element is the last in a group
(this ends the definition of the group)
*) Default value
lGETLIST_VISIBLE
This option determines whether the object is visible immediately
after the call to the method :create() . By default the object
follows the VISIBLE clause of the DCGETOPTIONS command. Use the
INVISIBLE clause to override the VISIBLE clause of DCGETOPTIONS
cGETLIST_GETGROUP
This option is a "group" name (case-sensitive) to assign to
this GetList object. Assignment to a group makes it possible to
perform operations only on GetList items which are members of a
specified group, using functions such as DC_GetRefresh() or
DC_ReadGui().
lGETLIST_FLAG
This logical element is reserved for the form designer.
See Also:
dc_readgets()
dc_readgui()
DIALOG OPTIONS
DIALOG OPTIONS
The Dialog Get Options Array
Description:
The Dialog Options List is simply a single-dimensionsal array
of 24 elements. eXPress++ Dialog options are included in
DCDIALOG.CH. Before using the DCGETOPTIONS command you must
first initialize the GetOptions array variable so:
LOCAL GetOptions
The elements of the options array are defined as follows:
cGETOPT_NAME
This is the name of the Dialog screen or application. It must
be all Upper Case characters no longer than characters in
length. It is a unique name assigned to the dialog for saving
to the dCLIP++ DIALOG dictionary database.
cGETOPT_TITLE
This is the title or description of the dialog.
nGETOPT_WNDHEIGHT
This is the dialog window height in pixels.
nGETOPT_WNDWIDTH
This is the dialog window width in pixels.
nGETOPT_ROWSPACE
This is the number of pixels between rows when using text-
based coordinates in the Getlist. The default is 20.
nGETOPT_SAYWIDTH
This is the default width for DCSAY objects if the SAYSIZE
parameter is not used with the DCSAY command.
cGETOPT_SAYFONT
This is the default FONT for DCSAY objects if the FONT
parameter is not used with the DCSAY command. If this parameter
is NIL, then the DCSAY object uses the font of the parent.
cGETOPT_GETFONT
This is the default FONT for DCGET and @..DCSAY..GET objects if
the FONT parameter is not used with the DCGET or @..DCSAY..GET
commands. If this parameter is NIL, then the object uses the
font of the parent.
nGETOPT_GETHEIGHT
This is the default HEIGHT (in pixels) of the GET in DCGET and
@..DCSAY..GET commands. If this parameter is nil, then the
default height is 20.
aGETOPT_BUTTONS // to be implemented in Rev 1.1
This is an optional multi-dimensional array of buttons to add
to the bottom of the dialog box. Each button will be added
in sequence from left to right. Each sub-array is an array of
5 elements defining the buttons.
Element Type Description
------- ---- ------------------------------------
1 C Button Caption
2 N Button Width (in pixels)
3 N Button Height (in pixels)
4 B Action Code Block
5 X Button Cargo
nGETOPT_WNDROW
This is the starting row of the dialog window (in pixels). If
this element is NIL, then the dialog will be centered vertically
in the parent.
nGETOPT_WNDCOL
This is the starting column of the dialog window (in pixels). If
this element is NIL, then the dialog will be centered horizontally
in the parent.
nGETOPT_ROWOFFSET
This is the row offset (in pixels) to add to each dialog object.
The default is 0.
nGETOPT_COLOFFSET
This is the column offset (in pixels) to add to each dialog
object. The default is 0.
lGETOPT_DESIGN
If this element is .TRUE., then the user can move and resize
objects on the screen. Objects that are moved and resized are
saved back in the GetList array.
aGETOPT_MENU
This is a multi-dimensional array containing an optional menu to
attach to the top of the dialog window. The menu must conform
to the specifications of menus returned by the dCLIP menu
dictionary system. See DC_MenuLoad().
lGETOPT_PIXEL
If this element is .TRUE., then all coordinates in the Getlist
are in pixels, otherwise they are text-based coordinates.
xGETOPT_SPARE
Spare.
nGETOPT_ICON
This is the resource ID of the ICON to place in the upper left
corner of the dialog window.
lGETOPT_CHECKGET
If this element is .TRUE., then all DCGET or @..DCSAY..GET
objects which GET a logical value will be displayed as a
CheckBox rather than a normal GET.
cGETOPT_HELPFILE
This is the name of a *.HLP help file to activate when the
user clicks on the HELP button on the bottom of the dialog
window.
lGETOPT_VISIBLE
If this element is .TRUE., then the dialog window will be
displayed before objects are created on the window, otherwise
the entire dialog will not be displayed until all objects
are created.
lGETOPT_TRANSLATE
If this element is .TRUE., then it is assumed that all
coordinates in the GetList are based on 0,0 being the upper
left home position of the display or parent object. It is
also assumed that coordinates are text-based unless individually
specified as pixel-based by the aGETLIST_PIXEL. A .TRUE. will
also insure that RELATIVE coordinates are based on the
coordinates of the relative objects specified in the Getlist.
If this element is .FALSE., then NO TRANLATIONS will occur when
the objects are displayed by the GUI reader and all coordinates
are assumed to be based on 0,0 being the lower left home position
of the display or parent object and are all pixel-based.
After the GUI reader translates the coordinates, it writes the
translated coordinates back to the Getlist and automatically
sets this flag to .FALSE. so that successive calls to the GUI
reader with the translated Getlist will not cause anomolies
when displaying the objects.
lGETOPT_SAYRIGHT
If this element is .TRUE. then all GETLIST_SAY type objects
in the Getlist will display their text right-justified, unless
that object specificies LEFT or CENTER justification via
the aGETLIST_OPTIONS element of the Getlist item.
nGETOPT_BITMAP
This is the resource ID of a Bitmap that is linked into the
.EXE. This bitmap will be sized to fill the main dialog window.
aGETOPT_PRESENT
The PRESENTATION option is a two-dimensional array that contains
presentation parameters for the Dialog window. The first column
of the array must contain #define constants from the XBP.CH file
starting with the prefix XBP_PP_. These constants define the
presentation parameters that can be set for the object and
include colors and fonts. The second column of the array contains
the value for each setting. These are also generally set using
#define constants from the GRA.CH file.
nGETOPT_BGCOLOR
This option is a numeric value defining the background color of
the dialog windows. Colors start with GRA_CLR_* (defined in
GRA.CH.
nGETOPT_SAYOPT
Objects created by the @DCSAY command can be given a set of
options which are used to align the text within the rectangular
area of the say (XbpStatic) object. Constants defined in the
XBP.CH file are used for these options. These constants are
listed in the table below. If combinations of alignment options
are required, the sum of the appropriate constants must are
assigned to the instance variable :options .
#define constants for aligning text
Constant Description
XBPSTATIC_TEXT_LEFT Text is left aligned
XBPSTATIC_TEXT_CENTER Text is horizontally centered
XBPSTATIC_TEXT_RIGHT Text is right aligned
XBPSTATIC_TEXT_TOP Text is displayed at top
XBPSTATIC_TEXT_VCENTER Text is vertically centered
XBPSTATIC_TEXT_BOTTOM Text is displayed at bottom
bGETOPT_EVAL
This option is a code block that is evaluated after the main
dialog window (XbpDialog) is created. This code block is
evaluated before any items from the GetList are created and
added to the Dialog. The Dialog object is passed to the code
block.
nGETOPT_MODALSTATE
This element is used to set the Modal State of the dialog
window. Options are XBP_DISP_APPMODAL or XBP_DISP_MODELESS
(defined in XBP.CH).
nGETOPT_SAYHEIGHT
This option is the default HEIGHT (in pixels) of the SAY in
@..DCSAY and @..DCSAY..GET commands. If this element is empty
then the default height is 20.
lGETOPT_MINBUTTON
A logical .TRUE. in this element will suppress the display of
the Minimize button on the dialog window.
lGETOPT_MAXBUTTON
A Logical .TRUE. in this element will suppress the display of
the Maximize button on the dialog window.
lGETOPT_TABSTOP
A Logical .TRUE. in this element will cause all objects
(Xbase Parts) to be set when using the Tab key. The default for
TabStop is .False. or OFF. The TabStop setting for individual
objects can be force to ON or OFF by using the TABSTOP or
NOTABSTOP commands respectively in each command to override the
default setting.
lGETOPT_ABORTQUERY
A Logical .TRUE. in this element will cause a Message Box to
appear Confirming that the cancelling of operation when the
Cancel button is clicked or the Dialog window is closed.
nGETOPT_ROWPIXELS
A numerical value in this element is the amount of pixels that
equate to a row when using text-based coordinates. The default
is 20.
nGETOPT_COLPIXELS
A numerical value in this element is the amount of pixels that
equate to a column when using text-based coordinates. The
default is 7.0.
lGETOPT_ESCAPEKEY
A Logical .FALSE. in this element will disable the ESCape key.
Normally, the ESCape key will close the dialog window and cancel
operation.
cGETOPT_SOURCECODE // feature available in Rev. 1.1
This element contains the name of the source code (*.PRG) file
that contains the DC* commands which created the dialog GetList.
This is needed when using the pop-up Dialog Editor in DESIGN mode.
Changes made to a dialog are re-written to the source code file
only if the command is identified by an ID, GETID or SAYID clause.
aGETOPT_TOOLCOLOR
This element contains an optional 2-element array defining the
he foreground color and background color of tooltips when using
the TOOLTIP clause on eXPress++ commands. The default colors
are GRA_CLR_BLACK and GRA_CLR_WHITE.
nGETOPT_BORDER
This element defines the border type of the dialog window.
Constants defined in the XBP.CH file can be assigned to <þnBorderþ>.
The following table shows the valid #define constants.
Constant Description
XBPDLG_NO_BORDER No border
XBPDLG_SIZEBORDER Window is sizeable
XBPDLG_THINBORDER *) Thin border, window size
cannot be changed
XBPDLG_DLGBORDER Thick border, window size
cannot be changed
XBPDLG_RAISEDBORDERTHICK **) Thick, raised border
XBPDLG_RAISEDBORDERTHIN *) Thin, raised border
XBPDLG_RECESSEDBORDERTHICK Thick, recessed border
XBPDLG_RECESSEDBORDERTHIN *) Thin, recessed border
XBPDLG_RAISEDBORDERTHICK_FIXED Thick, raised border,
size cannot be changed
XBPDLG_RAISEDBORDERTHIN_FIXED *) Thin, raised border,
size cannot be changed
XBPDLG_RECESSEDBORDERTHICK_FIXED Thick, recessed border,
size cannot be changed
XBPDLG_RECESSEDBORDERTHIN_FIXED *) Thin, recessed border,
size cannot be changed
*) not supported by Windows **) Default border
If a dialog is embedded as MDI client within another dialog,
Windows ignores all border styles except XBPDLG_RAISEDBORDERTHICK
and XBPDLG_RECESSDBORDERTHICK. In all other cases, a border is
displayed for MDI clients that corresponds to
XBPDLG_RAISEDBORDERTHICK.
lGETOPT_EXVALID
This element if .TRUE. will traverse the GetList when the user
clicks on the OK button and test all validations. If any
validation fails, the failed object will receive input focus and
the dialog will remain active.
lGETOPT_NOTASKLIST
This element if .TRUE. will insure that the dialog window is not
placed on the Windows task bar.
nGETOPT_MINSIZE
This element is used to establish the minimum size of the dialog
window, in pixels, if the operator attempts to resize the window.
nGETOPT_MAXSIZE
This element is used to establish the maximum size of the dialog
window, in pixels, if the operator attempts to resize the window.
lGETOPT_NORESIZE
This element if .TRUE. will prevent the operator from resizing
the dialog window.
lGETOPT_NOTITLEBAR
This element if .TRUE. will prevent a titlebar from displaying on
the dialog window. This will also prevent the minimize, maximize,
and close buttons from appearing.
lGETOPT_NOMOVE
This element if .TRUE. will prevent the dialog window from
automatically moving when it's owner is moved.
nGETOPT_ORIGIN
This element defines the reference point for the position of
the dialog window. The value of <þnOriginþ> must be a #define
constant from the file XBP.CH. The available constants are listed
in the following table:
Constants for the origin of a dialog window
Constant Description
XBPDLG_ORIGIN_OWNER *) Origin is point {0,0} of the owner window
XBPDLG_ORIGIN_SCREEN Origin is point {0,0} of the desktop window
XBPDLG_ORIGIN_MOUSE Origin is the current mouse position
*) Default value
nGETOPT_HILITEGETS
This element defines the color of a box that will be drawn around
the currently selected GET. The numeric value must be a GRA_CLR_*
color defined in GRA.CH. This clause highlights only the GET
portion of @.DCSAY..GET commands and DCGET commands. The feature
is disabled if this element is a NIL.
lGETOPT_SUPERVISE
This element if .FALSE. will cause the ENTER key to move from the
last get of a group of gets to the first get of the next group of
gets. Default behavior (.TRUE.) is for the movement from the last
get to the first get of a group of gets that all have the same
parent.
For example, if there are gets on 3 different tab pages, and
the user is in the last get of TabPage 1, and ENTER will cause
the first get on TabPage 2 to acquire focus.
See Also:
DIALOG GETLIST