home *** CD-ROM | disk | FTP | other *** search
/ Garbo / Garbo.cdr / mac / source / dialgmgr.sit / Dialog.Doc < prev    next >
Encoding:
Text File  |  1990-01-04  |  20.0 KB  |  613 lines  |  [TEXT/MSWD]
  1. Dialog - A Very-High Level Dialog Manager
  2. Version 1.0        1/5/90
  3.  
  4. Copyright 1986-1990 Stackhouse Software
  5.  
  6.  
  7. Introduction
  8.  
  9. Dialog is a series of objects and methods to manage a dialog. In addition to
  10. simple dialog items such as buttons, radio items, and check boxes, support is 
  11. provided for the following:
  12.     - Drawing the bold oval around the default button.
  13.     - Groups of radio items, boxed with titles at top or on side of group.
  14.     - PopUp Menus.
  15.     - Adjusting PopUp Menus to align with a StaticText items.
  16.     - Adjusting List Items to exactly display a given number of items.
  17.     - Items in a scrolling list.
  18.     - User Items.
  19.     - Keyboard equivalents for any radio item, check box, or button.
  20.     - Change the cursor over to an I-Beam when over EditText items.
  21.     - Managing update events when dialogs or windows overlap the dialog.
  22.  
  23. Complex dialogs can be displayed and information retrieved from them with
  24. a few simple lines of source code. While Dialog uses Object-Oriented techniques
  25. in its' implementation, the interface is a simple and can be used in any
  26. existing program without even modifiying the event loop.
  27.  
  28. Dialog is written using Think's Pascal 2.0 and contains about 2200 lines of
  29. code which compiles into between 3K and 10K bytes of code. The size of the code
  30. depends on which Dialog features are selected using compile time options. The 
  31. complete source files are included. Also included is a sample program (source, 
  32. project, and resource).
  33.  
  34. Dialogs is shareware and may be used in other shareware without royalty as 
  35. long as credit is given. I will attempt to answer questions and accept bug
  36. reports by either E-Mail or US Mail. The shareware fee is $35. Please send 
  37. checks to:
  38.      Bill Stackhouse
  39.      13 Sawin Street
  40.      Natick, MA 01760
  41.     
  42. ------------------------------------------------------------------------------
  43. This manual is divided into 3 parts:
  44.     Installation and Compilation
  45.     Description of Types
  46.     Description of Procedures
  47.     Complete Interface Definition
  48.  
  49. [note this document is formatted using Monaco 9pt with tabs set for 4 spaces.]
  50.  
  51.  
  52. ------------------------------------------------------------------------------
  53. Installation and Compilation
  54.  
  55. Dialog is a collection of source programs. They should be placed in a folder
  56. separate from the source for a program being developed to allow sharing
  57. among several projects. Under the Project menu in Think's Pascal 2.0, specify
  58. the options that are required. The values should be TRUE or FALSE; For Example:
  59.     UserListItem=TRUE;
  60. If a value is not defined, it defaults to FALSE. If a feature is not used, the
  61. source for it may be omitted from the project. All Dialog source may be
  62. compiled with the debug/name/range/overflow options set without ill effect. 
  63. Those locations in the source that would otherwise cause a problem, have the 
  64. options explicitly turned off.
  65.  
  66. The source file(s) which use Dialog must have TObject, and TDialogs in the
  67. uses statement. (TObject should be the name of the unit that defines TObject).
  68.  
  69. The compiler options are:
  70.     UseUserItem
  71.     UseListItem
  72.     UsePopUpMenu
  73.     UseTextGroup
  74.     UseKeyGroup
  75.     UseRadioGroup
  76.  
  77. The order of the source programs in the project are:
  78.     -- File --            -- Notes --
  79.     Object.p            required, but may use any object named TObject with
  80.                         a procedure named Free with no parameters.
  81.     KeyGroup.p            optional
  82.     PopUpMenu.p            optional
  83.     RadioGroup.p        optional
  84.     StringDB.p            optional, required if UseListItem = TRUE
  85.     ListItem.p            optional
  86.     TextGroup.p            optional
  87.     UserItem.p            optional
  88.     Centered.p            required
  89.     Dialogs.p            required
  90.  
  91.  
  92. ------------------------------------------------------------------------------
  93. Sample Program Fragment
  94.  
  95.     var
  96.         theDialog: TDialog;
  97.  
  98.  
  99.     new(ListDialog);
  100.     theDialog.Init;
  101.     theDialog.Define(2001, [10], 12);
  102.     theDialog.RadioGroup(6, [5, 6, 7], 'Color', FALSE);
  103.     theDialog.RadioGroup(8, [8, 9], 'Age', TRUE);
  104.     theDialog.TextGroup(11, 3);
  105.     theDialog.PopMenu(Nil, 2000, 16, 2);
  106.     theDialog.KeyButton(CHR(ReturnCode), OK);
  107.     theDialog.KeyButton(CHR(EnterCode), OK);
  108.     theDialog.KeyButton('o', OK);
  109.     theDialog.KeyButton('.', Cancel);
  110.     theDialog.ItemListText('Natick');
  111.     theDialog.ItemListText('Boston');
  112.     theDialog.ItemListText('Cambridge');
  113.     theDialog.ItemListText('Salem');
  114.     theDialog.ItemListText('Seattle');
  115.     theDialog.ItemListText('Portland');
  116.     theDialog.ItemListText('San Diego');
  117.     theDialog.ItemListText('San Francisco');
  118.     theDialog.ItemListText('Marin');
  119.     theDialog.ItemListText('Orlando');
  120.  
  121.     theDialog.Display(TRUE);
  122.     theItem := theDialog.Accept;
  123.  
  124.     theDialog.ItemListGet(1, number, text);
  125.     theDialog.RadioGroupGet(1, number);
  126.     theDialog.RadioGroupGet(2, number);
  127.     theDialog.PopMenuGet(1, number, text);
  128.  
  129.     theDialog.Free;
  130.  
  131.  
  132.  
  133. ------------------------------------------------------------------------------
  134. Description of Types
  135.  
  136. type DialogNumber
  137.  
  138. The numbers 1 to 255. 255 is the maximum number of items that a dialog may
  139. have and be supported by Dialog.
  140.  
  141.  
  142. type DialogSet
  143.  
  144. A set of DialogNumbers.
  145.  
  146.  
  147. ------------------------------------------------------------------------------
  148. Description of Procedures
  149.  
  150.  
  151. Procedure TDialog.Init;
  152.  
  153. Initializes all internal data structures; Should be called once after creating
  154. dialog variable.
  155.  
  156.     var theDialog : TDialog;
  157.     begin
  158.         new(theDialog);
  159.         theDialog.Init;
  160.     end;
  161.  
  162.  
  163. Procedure TDialog.Define (
  164.         pNumber: Integer;    
  165.         pChkDefault: DialogSet;    
  166.         pTextDefault: DialogNumber);
  167.  
  168. Defines basic information for the dialog;
  169. pNumber - the resource number of the dialog;
  170. pChkDefault - a set of the check boxes that are initially checked.
  171. pTextDefault - the number of the EditText box that is initially selected.
  172.  
  173.     theDialog.Define (1000, [3,5,7], 12);
  174.  
  175.  
  176. Procedure TDialog.Display (center: Boolean);
  177.  
  178. This procedure will display the dialog. It should be called after all items
  179. and groups have been defined.
  180. center - TRUE if the dialog is to be positioned in the center of the screen
  181. horizontally and one-third down from the menu bar.
  182.  
  183.     theDialog.Display (TRUE);
  184.  
  185.  
  186. Function TDialog.Accept: Integer;
  187.  
  188. This procedure will wait for any button item to be pressed. The number of the 
  189. button pressed will be returned.
  190.  
  191.     theItem := theDialog.Accept;
  192.  
  193.  
  194. Function TDialog.Error: Integer;
  195.  
  196. This procedure will return the status of the last operation. The possible
  197. errors are:
  198.                             { Return Codes }
  199.   DialogNoErr = 0;            {all's well with the world}
  200.   DialogNotNumber = -1;        {Edit/Static text item did not have a number in it}
  201.   DialogInvalidOp = -2;        {Operation requested with support compiled out}
  202.   DialogInvalidItem = -3;    {item type invalid for op. eg. GetString on a 
  203.                             {radio control}
  204.   DialogGroupIgnored = -10;    {too many groups, key, menus, or user items were 
  205.                             {added}
  206.  
  207.     IF theDialog.Error <> DialogNoErr THEN
  208.         foo;
  209.  
  210.  
  211. Procedure TDialog.Free;
  212.  
  213. This procedure will remove the dialog from the screen and free all internal
  214. data structures including the dialog. It should be called after retrieving
  215. all values from the dialog.
  216.  
  217.     theDialog.Free;
  218.  
  219.  
  220. Procedure TDialog.RadioGroup (
  221.         pOn: DialogNumber;    
  222.         pBtns: DialogSet;    
  223.         pTitle: String;    
  224.         pTitleTop: Boolean);
  225.  
  226. This procedure defines a group of radio items that will have only a single
  227. item on at any time. Optionally the group may have a box drawn around them
  228. and a title placed either at the top or the side of the group. There may not
  229. be more than 15 radio groups in a dialog, additional groups will be ignored.
  230. pOn - the radio item that is currently on.
  231. pBtns - the set of radio items in the group.
  232. pTitle - the title to be drawn with the box. If the title is a null string,
  233.     no box or title is drawn.
  234. pTitleTop - if TRUE, the title is drawn at the top of the group. If FALSE,
  235.     the title is drawn at the side of the group.
  236.  
  237.     theDialog.RadioGroup (white, [red, white, blue], 'Flag Colors', TRUE);
  238.     theDialog.RadioGroup (front, [front, side, back], '', TRUE);
  239.     IF theDialog.Error = DialogGroupIgnored THEN
  240.         foo;
  241.  
  242.  
  243. Procedure TDialog.RadioGroupGet (
  244.         pGroup: Integer;
  245.         Var pItem: Integer);
  246.  
  247. After TDialog.Accept returns, this procedure will return the item number of
  248. the radio item that was last on.
  249. pGroup - the radio group number. The first group defined is number 1.
  250. pItem - the actual item number.
  251.  
  252. Procedure TDialog.RadioGroupSetOn (
  253.         pGroup: Integer;
  254.         pItem: Integer);
  255.  
  256. This procedure will set an item on in a group. All other items in the group
  257. will be off just as if one item in the group had been clicked on.
  258. pGroup - the radio group number. The first group defined is number 1.
  259. pItem - the actual item number.
  260.  
  261.     theDialog.RadioGroupGet(1, theItem);
  262.  
  263.  
  264. Procedure TDialog.TextGroup (
  265.         pBtn: DialogNumber;    
  266.         pText: DialogNumber);
  267.  
  268. This procedure defines a relationship between a radio item or check box and
  269. an EditText item. When the button is clicked on, the related EditText item is
  270. selected. There may not be more than 15 text groups in a dialog, additional groups 
  271. will be ignored.
  272. pBtn - the button item number.
  273. pText - the EditText item number.
  274.  
  275.     theDialog.TextGroup (5,8);
  276.  
  277.  
  278. Procedure TDialog.PopMenu (
  279.         pMenu: MenuHandle;    
  280.         pMenuRes: Integer;    
  281.         pStatic: DialogNumber;    
  282.         pNowOn: Integer);
  283.  
  284. This procedure defines a PopUp Menu that is associated with a StaticText item.
  285. The PopUp Menu itself must not have a UserItem defined for it. The Menu Items
  286. are defined as a standard resource. The StaticText item will be adjusted in
  287. size to correctly align with a select menu item. The width of the rectangle
  288. for the PopUp Menu will be determined by the width of the menu resource. There 
  289. may not be more than 15 PopUp Menus in a dialog, additional menus will be 
  290. ignored.
  291. pMenu - the Handle to the menu. If it is nil, it will be read out of the
  292.     resource file.
  293. pMenuRes - the resource number of the menu.
  294. pStatic - the item number of the StaticText item associated with the menu.
  295. pNowOn - the menu item number initially selected.
  296.  
  297.     theDialog.PopMenu (menuHandle, 1000, 3, 1);
  298.  
  299.  
  300. Procedure TDialog.PopMenuGet (
  301.         pGroup: Integer;
  302.         Var pItem: Integer;
  303.         Var pText: Str255);
  304.  
  305. After TDialog.Accept returns, this procedure will return the menu item number
  306. of the menu item last selected and its text.
  307. pGroup - the radio group number. The first group defined is number 1.
  308. pItem - the menu item number. The first item is number 1.
  309. pText - the menu item text.
  310.  
  311.     theDialog.PopMenuGet (1, theItem, theText);
  312.  
  313.  
  314. Procedure TDialog.PopMenuCallBack (pCallBack: ProcPtr);
  315.  
  316. This procedure defines a procedure which will be called each time any popup
  317. menu for this dialog is accessed. No parameters are passed to the procedure.
  318. It is assumed that the call back has access to the object for the dialog 
  319. and can call any of the procedures defined for TDialog.
  320.  
  321.     theDialog.PopMenuCallBack(@callBack);
  322.  
  323.  
  324. Procedure TDialog.UserItems (
  325.         pBtn: DialogNumber;    
  326.         pDraw, pEvent, pSelect: ProcPtr;    
  327.         pBox: Rect);
  328.  
  329. This procedure defines a UserItem. Call backs for drawing the item, processing
  330. events for it, and selections are provided. There may not be more than 10 user 
  331. items in a dialog, additional items will be ignored.
  332. pBtn - the item number.
  333. pDraw -
  334. pEvent -
  335. pSelect -
  336. pBox -
  337.  
  338.     theDialog.UserItems (4, @draw, @event, @select, theBox);
  339.     
  340.  
  341. Procedure TDialog.ItemList (
  342.         pBtn: DialogNumber;
  343.         pInitiallyOn: Integer;
  344.         pShown: Integer);
  345.  
  346. This procedure defines a scrollable list of items. The List should be defined
  347. as a UserItem in the resource file but any rectangle will do. The rectangle
  348. will be reduced by 16 pixels if it is necessary to show a scroll bar. The
  349. rectangle will be adjusted vertically to insure that the requested number
  350. of items will show. Because of the adjustments, the rectangle does not have
  351. to be exactly right, only that enough space is provided. There may not be more 
  352. than 10 list items in a dialog, additional lists will be ignored.
  353. pBtn - the item number.
  354. pInitiallyOn - the item number of the initial item to be selected
  355.     (highlighted). The first item number is 1.
  356. pShown - the maximum number of words to be shown at once.
  357.  
  358.     theDialog.ItemList (5, 40, 6);
  359.  
  360.  
  361. Procedure TDialog.ItemListText (pText: Str255);
  362.  
  363. This procedure will add a single item to the scrollable list. This must be
  364. called after TDialog.ItemList and before TDialog.Display. If there is
  365. insufficient memory to store the new item, it will be ignored and Error will
  366. return the value DialogGroupIgnored. The group will be displayed with the
  367. items that were successfully added.
  368. pText - The text of the item to be added.
  369.  
  370.     theDialog.ItemListText('Boston');
  371.     IF theDialog.Error = DialogGroupIgnored THEN    {did it get added?}
  372.         foo;
  373.  
  374.  
  375. Procedure TDialog.ItemListGet (
  376.         pGroup: Integer;
  377.         Var pItem: Integer;
  378.         Var pText: Str255);
  379.  
  380. After TDialog.Accept returns, this procedure will return the list item number
  381. of the list item last selected and its text. The item only need to be clicked
  382. on rather than double clicked. Multiple items may not be selected.
  383. pGroup - the radio group number. The first group defined is number 1.
  384. pItem - the list item number. The first item is number 1.
  385. pText - the list item text.
  386.  
  387.     theDialog.ItemListGet (1, theItem, theText );
  388.  
  389.  
  390. Procedure TDialog.KeyButton (
  391.         pKey: char;    
  392.         pItem: DialogNumber);
  393.  
  394. This procedure will define the relationship between a command/letter and any
  395. check box, radio item, or button). Pressing CMD - letter while the dialog is
  396. displayed will be the same as clicking on the item with the mouse. An item
  397. may have several keyboard equivalents. There may not be more than 25 keyboard
  398. equivalents in a dialog, additional pairs will be ignored.
  399. pKey - the actual key. Case is not distinguished. 'A' is different than 'a'.
  400. pItem - the item number to click on.
  401.  
  402.     theDialog.KeyButton ('.', Cancel);
  403.     
  404.  
  405. Function TDialog.GetBooleanValue (pItem: Integer): Boolean;
  406.  
  407. This function will return the value of a check box or radio after Accept
  408. returns.
  409. pItem - the Item number.
  410. result - TRUE if the item is ON. If the item is not a check box or radio item  
  411. the result will be FALSE.
  412.  
  413.     IF theDialog.GetBooleanValue (4) THEN
  414.         foo;
  415.  
  416.  
  417. Function TDialog.GetLongintValue (pItem: Integer): Longint;
  418.  
  419. This function will return the numeric value of any EditText Item after Accept
  420. returns.
  421. pItem - the Item number.
  422. result - the numeric value. If the item is not a Edit or Static item or does 
  423.     not contain a number, the result will be 0 and Error will return 
  424.     DialogInvalidItem or DialogNotNumber.
  425.  
  426.     IF theDialog.GetLongintValue (6) = 25 THEN
  427.         foo;
  428.  
  429.  
  430. Function TDialog.GetStringValue (pItem: Integer): Str255;
  431.  
  432. This function will return a string value of any EditText or StaticText Item 
  433. after Accept returns.
  434. pItem - the Item number.
  435. result - the string value. If the item is not a Edit or Static item the result 
  436.     will be a null string and Error will return DialogInvalidItem
  437.  
  438.     IF theDialog.GetStringValue (6) = 'Joe' THEN
  439.         foo;
  440.  
  441.  
  442. Procedure TDialog.SetBooleanValue (
  443.         pItem: Integer;
  444.         pValue: Boolean);
  445.  
  446. This function will set the value of a check box or radio item prior to Display.
  447. pItem - the Item number.
  448. pValue - TRUE if the item is to be ON.
  449.  
  450.     theDialog.SetBooleanValue (4, TRUE);
  451.  
  452.  
  453. Procedure TDialog.SetLongintValue (
  454.         pItem: Integer;
  455.         pValue: Longint);
  456.  
  457. This function will set the numeric value of any EditText Item prior to Display.
  458. pItem - the Item number.
  459. pValue - the numeric value.
  460.  
  461.     theDialog.SetLongintValue (6, 25);
  462.  
  463.  
  464. Procedure TDialog.SetStringValue (
  465.         pItem: Integer;
  466.         pValue: Str255);
  467.  
  468. This function will set a string value of any EditText or StaticText Item prior 
  469. to Display.
  470. pItem - the Item number.
  471. pValue - the string value.
  472.  
  473.     theDialog.SetStringValue (6, 'Joe');
  474.  
  475.  
  476. Procedure TDialog.CenterText (pItem: Integer);
  477.  
  478. This function will display the text in an EditText centered.
  479. pItem - the Item number.
  480.  
  481.     theDialog.CenterText (6);
  482.  
  483.  
  484. Procedure TDialog.SelectText (pItem: Integer);
  485.  
  486. This function will select the text in an EditText.
  487. pItem - the Item number.
  488.  
  489.     theDialog.CenterText (6);
  490.  
  491.  
  492.  
  493.  
  494. ------------------------------------------------------------------------------
  495. Complete Interface Definition
  496.  
  497. const
  498.   DialogMaxItems = 255;
  499.   ReturnCode = 13;    {ASCII code generated by Return and Enter keys.  Note that}
  500.   EnterCode = 3;    {this is good for any keyboard, no matter how it's mapped}
  501.  
  502.                             { Return Codes }
  503.   DialogNoErr = 0;            {all's well with the world}
  504.   DialogNotNumber = -1;        {Edit/Static text item did not have a number in it}
  505.   DialogInvalidOp = -2;        {Operation requested with support compiled out}
  506.   DialogInvalidItem = -3;    {item type invalid for op. eg. GetString on a 
  507.                             {radio control}
  508.   DialogGroupIgnored = -10;    {too many groups, key, menus, or user items were 
  509.                             {added}
  510.  
  511. type
  512.   DialogNumber = 0..DialogMaxItems;
  513.   DialogSet = packed set of DialogNumber;
  514.  
  515.   TDialog = object(TObject)
  516.     fPrivate: Handle;
  517.  
  518. {    Init        - initialize internal data structures    }
  519. {    Define        - define basic information about dialog }
  520. {    Display        - show dialog }
  521. {    Accept        - process all event until any button item is pressed }
  522. {    Error        - returns error from last operation }
  523. {    Free        - take dialog window down, clean up internal data structures }
  524. procedure TDialog.Init;
  525. procedure TDialog.Define (pNumber: Integer;        {dialog number}
  526.         pChkDefault: DialogSet;                    {which check boxes 
  527. default on}
  528.         pTextDefault: DialogNumber);            {which editText to put I-
  529. Beam}
  530. procedure TDialog.Display (center: Boolean);
  531. function TDialog.Accept: Integer;
  532. function TDialog.Error: Integer;
  533. procedure TDialog.Free;
  534.         override;
  535.  
  536. {    RadioGroup        - define a group of related radio buttons which are 
  537.                         exclusive of each other }
  538. {    RadioGroupGet    - find which button in the group is on }
  539. {   RadioGroupSetOn - set a button in the group }
  540. procedure TDialog.RadioGroup (pOn: DialogNumber;    {which is initially on}
  541.         pBtns: DialogSet;        {which btns in a single group}
  542.         pTitle: string;            {if length > 0, then title with box}
  543.         pTitleTop: Boolean);    {TRUE - title on top, FALSE - title at left}
  544. procedure TDialog.RadioGroupGet (pGroup: Integer;
  545.         var pItem: Integer);
  546. procedure TDialog.RadioGroupSet (pGroup: Integer;
  547.         pItem: Integer);
  548.  
  549. {    TextGroup        - a check box / TextEdit pair. When the check is on, the 
  550.                         edit is selected}
  551. procedure TDialog.TextGroup (pItem: DialogNumber;    {pairs of btn/edit text 
  552.                                                 
  553.     {items}
  554.         pText: DialogNumber);                    {button item number}
  555.  
  556. {    PopMenu            - define a popup menu relative to a StaticText item }
  557. {    PopMenuGet        - find which menu item is currently on along with text }
  558. {    PopMenuCallBack    - user call back when popup used. No parms passed back }
  559. {                                 since obj known }
  560.  
  561. procedure TDialog.PopMenu (pMenu: MenuHandle;    {nil or menu handle}
  562.         pMenuRes: Integer;                {resource number}
  563.         pStatic: DialogNumber;            {related StaticText item number}
  564.         pInitiallyOn: Integer);            {menu item number initially on}
  565. procedure TDialog.PopMenuGet (pGroup: Integer;        {group number}
  566.         var pItem: Integer;                {menu item number currently on}
  567.         var pText: Str255);                {menu item text currently on}
  568. procedure TDialog.PopMenuCallBack (pCallBack: ProcPtr);    {proc addr}
  569.  
  570. {    UserItems        - define a user item }
  571. procedure TDialog.UserItems (pItem: DialogNumber;    {user item number}
  572.         pDraw, pEvent, pSelect: ProcPtr;    {draw/event/select call backs}
  573.         pBox: Rect);                        {Rect that contains the 
  574. item}
  575.  
  576. {    ItemList        - define a single column scrollable list }
  577. {    ItemListText    - add a single row to the list }
  578. {    ItemListGet        - find which item and its' text was last clicked }
  579. procedure TDialog.ItemList (pItem: DialogNumber;        {item number}
  580.         pInitiallyOn: Integer;                        {item 
  581. initially selected}
  582.         pShown: Integer);                {max items to show}
  583. procedure TDialog.ItemListText (pText: Str255);    {text single list item}
  584. procedure TDialog.ItemListGet (pGroup: Integer;    {group number}
  585.         var pItem: Integer;                {list item number currently 
  586. selected}
  587.         var pText: Str255);                {list item text currently 
  588. selected}
  589.  
  590. {    KeyButton    - define keyboard equivalents }
  591. procedure TDialog.KeyButton (pKey: char;        {command key}
  592.         pItem: DialogNumber);            {button}
  593.  
  594. {    General utilities to set and retrieve dialog item values }
  595. function TDialog.GetBooleanValue (pItem: Integer): Boolean;
  596. function TDialog.GetLongintValue (pItem: Integer): Longint;
  597. function TDialog.GetStringValue (pItem: Integer): Str255;
  598.  
  599. procedure TDialog.SetBooleanValue (pItem: Integer;
  600.         theValue: Boolean);
  601. procedure TDialog.SetLongintValue (pItem: Integer;
  602.         theValue: Longint);
  603. procedure TDialog.SetStringValue (pItem: Integer;
  604.         theValue: Str255);
  605.  
  606. {    CenterText    - center the displayed text in the EditText }
  607. {    SelectText    - select the entire text in the EditText box }
  608. procedure TDialog.CenterText (pItem: Integer);
  609. procedure TDialog.SelectText (pItem: Integer);
  610.  
  611. end;
  612.  
  613.