Power-Programmierung

home *** CD-ROM | disk | FTP | other *** search

/ Power-Programmierung / CD2.mdf / c / library / dos / screen / intui110 / tui0.hlp < prev next >

Wrap

Text File | 1992-02-06 | 24.3 KB | 432 lines

`color(RED,LIGHTGRAY);<<<<<<<<<<<<<<<<<<<<< Welcome to EnQue's InTUItion V1.10 >>>>>>>>>>>>>>>>>>>>>`color(); `tab(2);`color_default(LIGHTGRAY,BLUE);`color_keyword(YELLOW,BLUE);`color_first_char(WHITE,BLUE); ┌──────────────────────────────────────────────────────────────────────────┐ │ `keyword(Introduction,/// Introduction); │ │ `keyword(How the TUICP works,/// How the TUICP works); │ │ `keyword(The TUICP's menus,/// The TUICP's menus); │ │ `keyword(Dialog objects,/// Dialog objects); │ │ `keyword(Creating dialogs,[TUI1.HLP]/// Creating dialogs); │ │ `keyword(Dialog Transfer and Menu construction,[TUI2.HLP]/// Dialog Transfer); │ │ `keyword(Incorporating Dialogs into your programs,[TUI2.HLP]/// Incorporating Dialogs); │ │ `keyword(The InTUItion Library,[TUI3.HLP]/// The InTUItion Library); │ │ `keyword(The Online Tutorials,/// The Online Tutorials); │ └──────────────────────────────────────────────────────────────────────────┘ `co(4,7);─────────────────────────────── /// Introduction ─────────────────────────────`co(); The TUICP (Textual User Interface Construction Program) is a programming tool designed to make the construction of user interfaces not only easy, but fun! The TUICP, taking advantage of the power of EnQue's UltraWin windowing library, allows you to interactively "draw" your menus, dialog boxes, data-entry forms, etc. User customizable screen size, colors, palettes, fonts, and more make the TUICP the most flexible screen designer available. We at EnQue take a slightly different approach to teaching you how to use our tools. Like most people, we hate to read long, complicated technical manuals, and find that little information is retained. If you have been programming for any time at all, you know that the best way to learn something is to dive right in and make it work. We take the latter approach with a few sophisticated aids to help. In this way, we can keep our manuals relatively small, serving mainly as a function usage and reference guide. First of all, we ship the full source code not only for our libraries, but for the tools as well. This is a real rarity in this business. We do this because as programmers we often run across a utility that is "almost" exactly what we need "if only". For those of you who run into this, you can add those last few features that make it perfect for you. In addition, the source provides insight into how the tools work and the more you know about the inner workings the more you understand how to take advantage of its features. Secondly, we include several demo programs that illustrate how to use most of the functions in the library. Some of the demos are quite large but are very modular, with a particular module or function demonstrating just a few features. Last and most important, we have included several fully automated tutorials that take you through actual recorded sessions and teach you how to incorporate each dialog object. A few minutes with the tutorials will save you hours of reading boring manuals. You even end up with a usable dialog at the end! If you get stuck while creating a dialog, context-sensitive help is only a button press or keystroke away. In most cases, you will never have to use the manual. `co(4,7);─────────────────────────── /// How the TUICP works ──────────────────────────`co(); The TUICP allows you to use the keyboard and mouse to construct your dialogs. Many dialogs can exists within a single .TUI file, similar to project files commonly used by compilers. InTUItion saves all the needed information to recreate your dialogs during runtime. IT DOES NOT store wasteful screen images like many other products. InTUItion's dialogs can even be modified "on-the-fly" by modifying variables within the controlling structures. A header file, with a .DEF extension, containing defines that describe each object is saved along with the TUI and is used in your program so that each object can be referenced by name, not by number. Don't modify this file, the TUICP does this for you. Dialog files can either be read in during run time or alternatively, the TUICP can generate "C" source code that can be compiled and linked into your exe file. The advantage of loading the file is easy modification without recompiling (assuming the basic structure of the dialog has not been changed, i.e., buttons added/removed, etc.). This method is recommended during program development. In addition, you may be developing a program where you would like the user to have the ability to change the position, colors, etc. of the program's dialogs. Linking in the dialogs will slightly increase the code size but eliminate the need for file I/O during startup. This also prevents users from editing the dialogs, or worse, deleting the files. This is recommended for final versions of your programs. Once a dialog is loaded into memory, the InTUItion library will "process" all dialog commands, returning to you depending on the flags set for each item. Processing the commands is done with a simple switch statement. InTUItion handles all the keyboard and mouse interaction. Once a dialog is created and tested, the TUICP will generate a "C" source code shell that contains the switch statements necessary to process each possible event. Finishing off your program becomes a simple matter of writing the code for each case. Program development time can be reduced by up to 90%. An excellent example is the font editor included with InTUItion. The font editor took less than 20 hours to write, start to finish. Without InTUItion, even using the power of UltraWin, this program would have taken over 100 hours. But don't take our word on this, we're biased. Try a few programs yourself and see how easy it is. The TUICP will also generate a "C" source shell that allows for the inclusion of context-sensitive help. A switch statement similar to the one above can be created with a search string into a help file, and a click of the right button will access the help, taking the user right to the proper location. All you have to do is create the ASCII help file and modify the search strings if needed; the rest is automatic. Internally, InTUItion stores base structures that contains the global parameters for the TUI and a pointer to additional structures depending on what objects you add to the dialog. Each time you add an object, InTUItion allocates a stucture for that object and stores a pointer to it in the base structure. This "base array", which is equal in size to the total number of objects in the TUI, is indexed by the names you specify for each object. The TUICP converts the names to an integer and stores these as defines in an ASCII .DEF include file. Do not modify the actual values, although it is perfectly fine to modify the define names. If you change the names, the next time you load that TUI into the TUICP, your new names will be used. Most TUI structures contain a pointer to additional parameters an object may need. For example, the button's additional parameter is the text for the button. By allocated this space as needed, InTUItion can keep memory requirements low yet allow for large fields if needed. You may notice that these pointers are "C" unions. This is necessary because pointers are different sizes depending on the memory model. In order for TUI files to be compatible across models, we use a union that allocates four bytes, the size of a pointer in large model. If you peruse through the T.H header file you will see exactly what you modify when using the construction program! `co(4,7);─────────────────────────────── /// Dialog objects ───────────────────────────`co(); InTUItion dialogs consist of a collection of buttons, strings, sliders, and other objects. To create such a dialog we must first understand what each object is and its purpose. ┌──────────────────────────────────────────────────────────────────────────┐ │ `keyword(Text Strings,/// Text Strings); │ │ `keyword(Boxes,/// Boxes); │ │ `keyword(Buttons,/// Buttons); │ │ `keyword(Check Boxes,/// Check Boxes); │ │ `keyword(Icons,/// Icons); │ │ `keyword(Sliders,/// Sliders); │ │ `keyword(Entry Strings,/// Entry Strings); │ │ `keyword(Attributes and Flags,/// Attributes and Flags); │ └──────────────────────────────────────────────────────────────────────────┘ `co(15,?);/// Text Strings`co(); The simplest object is the text string. This is actually a button that is not selectable or tabable and will not return if the user clicks on it or presses a hot key. Strings are primarily used for labeling other objects. Since a dialog is a memory structure, you can format your own data into this string and redraw it if desired. This allows you to output data to a dialog as well as input data. `co(15,?);/// Boxes`co(); A box is a rectangular area within the dialog that may be used by your program for output or to hold and group other objects, such as radio buttons. `co(15,?);/// Buttons`co(); Buttons consist of text within a box. A button can have a different appearance when selected or tabbed, and can be set to behave differently depending on the presence of other buttons in its group. The following are the flags for the different types of buttons available. `co(15,?);Normal`co(); Normal buttons act independently, having no effect on other buttons, even if they reside in the same box. `co(15,?);Radio`co(); Radio buttons are a group of buttons within a box that are mutually exclusive. If one is selected, all others are turned off. This is useful where the user must select one option. To make radio buttons, create a box to contain the group and make sure the radio flag is set for each button. If you don't want the bounding box to show, simply set its color to the same as the color of the dialog, effectively "hiding" it. If you have only one group of radio buttons in your dialog, you may simply put them in the dialog, without a grouping box, as the dialog itself acts as the base level box. `co(15,?);Deselectable Radio`co(); Deselectable Radio buttons are the same as above except that all buttons can be turned off if desired. This is useful in the case where a user can select no option, or one of several. `co(15,?);/// Check Boxes`co(); Check boxes are the same as buttons except for the text describing the check area and the check character itself. All three styles are available. `co(15,?);/// Icons`co(); An icon is similar to a box except that each character in the rectangle can be different, resulting in a rectangular image. In addition, a second image can be displayed when the item is selected. `co(15,?);/// Sliders`co(); Horizontal and Vertical sliders are actually the same object except for their orientation. Sliders are useful when more data is available than will fit on the screen. They give the user an easy way to scroll through information, while providing visual feedback as to the current position within that information. `co(15,?);/// Entry Strings`co(); Entry strings are used to get data from the user. They are the most versatile of all objects, in that you can use them to get a string from the user in virtually any format you wish. This is useful when the user must input a name, number, date, time, phone number, etc. `co(4,7);───────────────────────────── /// Attributes and Flags ───────────────────────`co(); Each object has certain attributes that control its appearance and operation. Here is a list of attributes and their meaning: `co(15,?);Name`co(); - This is a text name that will be used in your program to reference this item. The TUICP uses this name to generate a define, which is then saved in the ASCII .DEF include file. Note that the reference in your code is really a number, which is the index into the TUI base array for the object. The defined names make your code much more readable while not reducing performance due to string references. Objects: All `co(15,?);Border style`co(); - This is the border style and is only used by the dialog itself. Options include, none, single line, double line, or heavy solid line. Objects: Dialog `co(15,?);Border color`co(); - This is the border color and is only used by the dialog itself. Objects: Dialog `co(15,?);Dialog color`co(); - This is the dialog color and is only used by the dialog itself. Objects: Dialog `co(15,?);Style`co(); - This describes whether an object is displayed with a shadow. Objects: All except Dialog `co(15,?);Normal color`co(); - This describes the normal color of an object. Objects: Text, Icon, Button, Check Box, Entry String `co(15,?);Normal 1st color`co(); - This describes the normal color of the character referenced by "first position." Objects: Text, Button, Check Box `co(15,?);Selected color`co(); - This describes the color of an object when selected. Objects: Icon, Button, Check Box `co(15,?);Selected 1st color`co(); - This describes the color of the character referenced by "first position" when the object is selected. Objects: Text, Button, Check Box `co(15,?);Tabbed color`co(); - This describes the color of a tabbed object. Objects: Icon, Button, Check Box, Entry String `co(15,?);First position`co(); - This is the offset of the character in the string that will be displayed with the first color values. Objects: Text, Button, Check Box `co(15,?);Text`co(); - The text (string) for the object. Objects: Text, Button, Check Box `co(15,?);Icon image #1`co(); - The two-dimensional character array that describes an icon image. Objects: Icon `co(15,?);Icon Image #2`co(); - The two-dimensional character array that describes a selected icon image. Objects: Icon `co(15,?);Arrow color`co(); - The color of a slider arrow. Objects: Slider `co(15,?);Track color`co(); - The color of a slider track. Objects: Slider `co(15,?);Grab Box color`co(); - The color of a slider grab box. Objects: Slider `co(15,?);Slider Chars`co(); - The 6 characters used to draw a slider. These are the left, right, up, down, track, and grab box characters. Objects: Slider `co(15,?);Input Strings`co(); - The text, mask, and template strings needed for data entry. See the UltraWin documentation and demos for more details. Objects: Entry String `co(15,?);Input Flags`co(); - The action InTUItion should take on an input string before returning control to you. You may use no action or a combination of the following: `co(15,?);Strip`co(); - strips the entire mask from string. `co(15,?);Strip End`co(); - strips only the end of the string. `co(15,?);Capitalize`co(); - converts the first character of each word to upper-case. `co(15,?);Type R-to-L`co(); - causes input to be entered right- to left. This is useful for prices in data-entry forms. `co(15,?);<CR> on Full`co(); - causes the equivalent of an <Enter> key press when the last character of the field is entered. `co(15,?);Clr on Key`co(); - causes the field to be cleared when the first valid character is typed. See the UltraWin documentation and demos for more details. Objects: Entry String Each object has a set of flags that describe its operation. Not all flags apply to all objects. Here is a list of the flags and their meaning: `co(15,?);Selectable`co(); - The object can be selected. `co(15,?);Tabable`co(); - The object can be tabbed. `co(15,?);Radio`co(); - The object is a radio button/check box. `co(15,?);Exit Press`co(); - Returns when the mouse is over the object and a button is pressed. `co(15,?);Exit Release`co(); - Returns when the mouse is over the object and a button is depressed and then released. `co(15,?);Exit Over`co(); - Returns when the mouse cursor is over the object. `co(15,?);One Level`co(); - If control is transferred from another dialog, and the object should exit, return just one level to the calling dialog. `co(15,?);All Levels`co(); - If control is transferred from another dialog, and the object should exit, return all levels through all calling dialogs. (See `keyword(Dialog Transfer,[TUI2.HLP]/// Dialog Transfer);) `co(15,?);Selected`co(); - The object is currently selected. Check for this flag in your program with the is_selected macro to determine if the button is on or off. `co(15,?);Tabbed`co(); - The object is currently tabbed. `co(4,7);──────────────────────────── /// The TUICP's menus ───────────────────────────`co(); `co(15,?);The TUICP's Main Menu`co(); `keyword(Info,/// Info [Main Menu]); `keyword(Files,/// Files [Main Menu]); `keyword(Dialogs,/// Dialogs [Main Menu]); `keyword(Source,/// Source [Main Menu]); `co(15,?);The TUICP's Edit Menu`co(); `keyword(Info,/// Info [Edit Menu]); `keyword(Edit,/// Edit [Edit Menu]); `keyword(Source,/// Source [Edit Menu]); `co(15,?);/// Info [Main Menu]`co(); Help - Displays the TUICP help index. This is a context- sensitive group of hypertexted files under our own hypertext help engine, and contains all the information you will need to utilize InTUItion. About InTUItion - Displays information about EnQue Software, along with system free memory. `co(15,?);/// Files [Main Menu]`co(); TUI Params - Allows global control over colors, fonts, screen size, etc. This sets how the TUI will look when initialized in your program with init_tui. This menu selection is active only when the TUI work window is on the main screen. New TUI - Clears any TUI in memory and creates a new TUI. Load TUI - Allows you to load an existing TUI file into memory. Save TUI - Allows you to save the current TUI in memory to a file. Close TUI - Closes the current TUI without saving. Dos Shell - Shells out to DOS. Type <exit> from DOS to return. Quit - Quits the program. `co(15,?);/// Dialogs [Main Menu]`co(); Add Dialog - Adds a new dialog to the current TUI. Add Menu Dialogs - Adds a number of menu dialogs to the current TUI. Delete Dialog - Deletes a dialog from the current TUI. After selecting delete, move your mouse to the desired dialog and press the left button. `co(15,?);/// Source [Main Menu]`co(); Gen Linkable TUI - InTUItion TUI files can be either loaded at run time or linked in. In order to link in a TUI, the source code needed to create the dialog must be generated and compiled. This generates the source code shell, which can then be added to your project or make file, eliminating the need to distribute seperate TUI files. Be sure to select a filename that will not clash with other "C" files. `co(15,?);/// Info [Edit Menu]`co(); Help - displays the TUICP help index. `co(15,?);/// Edit [Edit Menu]`co(); Clear - Clears all object from the dialog. Copy - Copies an object to the clipboard. After selecting this item, move to and click on the item to copy. Cut - Same as copy but removes the item from the dialog. Paste - Pastes the current item in the clipboard to the dialog. Select this item and hold down the left button, dragging the item onto the dialog. Bring to Top - Changes the order of the dialog's drawing. For instance, if a box is added over several buttons and you want the button to be on top of the box, select this and click on the buttons. They will now draw after the box. Set Tab Order - All objects within a dialog that have the "Tabable" parameter set can be tabbed to by the user. This sets the tab order. After selecting this item, click on each object in the order that you wish the tabbing to proceed. Note that this has the same effect on the drawing order as Bring to Top. Show Clipboard - Allows you to view the last object Copied or Cut. Test - Allows you to interactively test the dialog. This is one of the TUICP's most important features. It allows you to actually use the dialog as the user would and see the actions/colors of the dialog taking place. It also allows you to test the hotkeys, tab order, slider action, transfer, and display the return values of each object that has been set to "exit." Test with Advance is the same as Test, but uses the DO_INPUT_ADV mode, useful for data-entry forms. Main Menu - Returns to the main menu. `co(15,?);/// Source [Edit Menu]`co(); Gen Dialog Shell - This will generate a "C" source code shell with all dialog processing hooks created. All you have to do is add the code needed for each dialog action. Dialog & Help - This will generate a "C" source code shell with all dialog processing hooks created, including context-sensitive calls to the hypertext help engine. All you have to do is add the code needed for each dialog action, and set the desired help search strings. `co(4,7);───────────────────────── /// The Online Tutorials ───────────────────────────`co(); One of the quickest ways to learn about a tool is to have someone who knows how to use it show you. Now while we at EnQue can't sit down with each and every one of you, we have given you the next best thing. Included on the disk are a number of .TUT files. These are recorded sesssions of one of us putting the TUICP through its paces. We use a popup comment box throughout the sessions to "chat" with you during each phase of TUI construction. To play back a .TUT file, just type TUICP -pFILENAME.TUT from the command line, then sit back, relax, and let us show you how to become proficient in no time at all!