@database "classes" @master "Work:Programing/sc/OS3.1_Docs/doc/8svx_dtc.doc" @Node Main "classes" @{b}@{u}listview.gadget@{uu}@{ub}: @{b}@{u}Datatypes:@{uu}@{ub} @{"GetListViewClass()" LINK "GetListViewClass"} @{"sound.datatype()" Link "sound.datatype()"} @{"listview.gadget()" LINK "listview.gadget"} ->@{"8svx.datatype()" Link "8svx.datatype()"},@{"aiff.datatype()" Link "aiff.datatype()"} @{"Tree_NewList()" LINK "Tree_NewList"} @{"text.datatype()" Link "text.datatype()"} @{"Tree_AddHead()" LINK "Tree_AddHead"} ->@{"ascii.datatype()" Link "ascii.datatype()"} @{"Tree_RemHead()" LINK "Tree_RemHead"} @{"picture.datatype()" Link "picture.datatype()"} @{"Tree_AddSubHead()" LINK "Tree_AddSubHead"} ->@{"ilbm.datatype()" Link "ilbm.datatype()"} @{"Tree_RemSubHead()" LINK "Tree_RemSubHead"} @{"animation.datatype()" Link "animation.datatype()"} @{"Tree_Insert()" LINK "Tree_Insert"} @{"amigaguide.datatype()" Link "amigaguide.datatype()"} @{"Tree_Remove()" LINK "Tree_Remove"} @{b}@{u}colorwheel.gadget@{uu}@{ub}: @{"Tree_AddSubTail()" LINK "Tree_AddSubTail"} @{"colorwheel.gadget()" Link "colorwheel.gadget()"} @{"Tree_RemSubTail()" LINK "Tree_RemSubTail"} @{"ConvertHSBToRGB()" Link "ConvertHSBToRGB()"} @{"Tree_AddTail()" LINK "Tree_AddTail"} @{"ConvertRGBToHSB()" Link "ConvertRGBToHSB()"} @{"Tree_RemTail()" LINK "Tree_RemTail"} @{b}@{u}gradientslider.gadget@{uu}@{ub}: @{"Tree_NextNode()" LINK "Tree_NextNode"} @{"gradientslider.gadget()" Link "gradientslider.gadget()"} @{"Tree_NextSubNode()" LINK "Tree_NextSubNode"} @{b}@{u}textfield.gadget@{uu}@{ub}:@{"Main" link textfield.gadget_main} @{b}@{u}progress.gadget@{uu}@{ub}: @{b}@{u}gauge.gadget@{uu}@{ub}: @{"progress.gadget()" LINK "progress.gadget"} @{"--background--" LINK "--background--"} @{"GetProgressClass()" LINK "GetProgressClass"} @{"NewGaugeA()" LINK "NewGaugeA"} @{b}@{u}smartbitmap.image@{uu}@{ub}: @{"SetGaugeA()" LINK "SetGaugeA"} @{"smartbitmap.image()" LINK "smartbitmap.image"} @{"GetGaugeA()" LINK "GetGaugeA"} @{"GetSmartBitMapClass()" LINK "GetSmartBitMapClass"}@{"DisposeGauge()" LINK "DisposeGauge"} @ENDNODE @NODE "textfield.gadget_main" "textfield.gadget/Main" @{"Textfield.gadget" LINK "Textfield.gadget"} @{"Size_Issue" LINK "Size_Issue"} @{"Prog_Language" LINK "Prog_Language"} @{"Open_Library" LINK "Open_Library"} @{"Class_Name" LINK "Class_Name"} @{"OS_Version" LINK "OS_Version"} @{"Str_Comparison" LINK "Str_Comparison"} @{"Rendering" LINK "Rendering"} @{"Buffer_Access" LINK "Buffer_Access"} @{"Buffer_Characters" LINK "Buffer_Characters"} @{"Changing_Attributes" LINK "Changing_Attributes"} @{"Move_or_Size" LINK "Move_or_Size"} @{"Undo" LINK "Undo"} @{"User_Docs" LINK "User_Docs"} @{"Applicability" LINK "Applicability"} @{"Tags" LINK "Tags"} @{"Borders" LINK "Borders"} @{"Alignment" LINK "Alignment"} @{"Bugs" LINK "Bugs"} @{"Author" LINK "Author"} @{"GetClass()" LINK "GetClass()"} @{"GetCopyright()" LINK "GetCopyright()"} @ENDNODE @NODE "Textfield.gadget" "textfield.gadget/Textfield.gadget()" @{b}@{u}textfield.gadget@{uu}@{ub} -- multi-line text entry BOOPSI object.(V3) The textfield class allows you create an area on your screen for text entry.The class supports a number of features including unlimited or limited size text entry, specifying the font and style to use, specifying the colors for different parts (text, background, and lines), two types of borders (with option to invert the borders for a total of 4 types of borders) or no border, text left/center/right justification, vertical centering, @{"IntuiText" LINK "include:intuition/intuition.h/MAIN" 656} labels, attached Images, line spacing, limited character acceptance, insertion or block cursor, cursor blinking speed or no blinking, read-only mode, modified buffer flag, lined paper, cut/copy/paste/erase while editing or program- matically, undo buffer, and settable word delimiter characters for word wrapping. LEGAL textfield.gadget is Copyright © 1995 Mark Thomas All rights reserved. @ENDNODE @NODE "Size_Issue" "textfield.gadget/Size_Issue()" SIZE ISSUE The textfield class gadget should be used for relatively small areas where you want to allow text entry.Typically a size below 320 x 200 is a fairly reasonable limit, but larger sizes will work.In other words it is not intended to be a whole editor like Ed.Please note that the vertical size has more affect on speed than the horizontal size.Many people have ignored the size issue in previous versions, and it doesn't seem to have caused problem.I keep this here until the day I can really optimize the gadget. @ENDNODE @NODE "Prog_Language" "textfield.gadget/Prog_Language()" PROGRAMMING LANGUAGE This gadget is written for a C language interface and is that way simply because the Amiga development is geared more towards the C language than any other.This does not mean that the gadget cannot be used with another language.In particular, support for Oberon is given in the form of two mod files.One file, TextField.mod provides the actual interface to the gadget class.It can be compiled and linked into an Oberon project.The other, TestClass.mod is a sample program, similar to the C version, that tests the class and shows how to use the class.Thanks goes to Stefan for taking the effort to convert the files. If you use C, the important thing to know is that you need to include the header file <@{"gadgets/textfield.h" LINK "include:gadgets/textfield.h/MAIN" 0}>.And depending on what you do you may need to include some other files: <@{"intuition/gadgetclass.h" LINK "include:intuition/gadgetclass.h/MAIN" 0}>, <@{"intuition/classes.h" LINK "include:intuition/classes.h/MAIN" 0}>, <@{"intuition/classusr.h" LINK "include:intuition/classusr.h/MAIN" 0}>, <@{"intuition/icclass.h" LINK "include:intuition/icclass.h/MAIN" 0}>, <@{"intuition/imageclass.h" LINK "include:intuition/imageclass.h/MAIN" 0}>, <@{"utility/tagitem.h" LINK "include:utility/tagitem.h/MAIN" 0}>. @ENDNODE @NODE "Open_Library" "textfield.gadget/Open_Library()" OPENING THE LIBRARY @{u}HOW TO OPEN THE TEXTFIELD GADGET LIBRARY (for non-SAS/C 6.50+ users)@{uu}: To use the class you must open the "textfield.gadget" library like so: OpenLibrary("@{b}gadgets/textfield.gadge@{ub}t", 0).If that was successful, then you need to get the class pointer with the TEXTFIELD_GetClass() function.You do not have to check to make sure that the pointer returned by TEXTFIELD_GetClass() is valid (see TEXTFIELD_GetClass description).You do not have to return the pointer with any function, just do not use the pointer after you close the "textfield.gadget" library. @{u}Here's a quick guide@{uu}: @{FG shine}struct@{FG text} @{"Library" LINK "include:exec/libraries.h/MAIN" 33} *@{i}TextFieldBase@{ui}; @{FG shine}Class@{FG text} *@{i}TextFieldClass@{ui}; @{i}TextFieldBase@{ui} = OpenLibrary("@{b}gadgets/textfield.gadget@{ub}", 0) @{FG shine}if@{FG text} (@{i}TextFieldBase@{ui}) { @{i}TextFieldClass@{ui} = @{b}TEXTFIELD_GetClass@{ub}(); /* use the class */ @{i}TextFieldClass@{ui} = NULL; CloseLibrary(@{i}TextFieldBase@{ui}); } @{u}HOW TO OPEN THE TEXTFIELD GADGET LIBRARY (for SAS/C 6.50+ users)@{uu}: If you use SAS/C 6.50 or greater, then you can use the TextFieldAuto.c source file provided in the source draw to have the library open automatically at startup, and close automatically at termination so that you will not have to take care of these yourself.I highly recommend using this feature. @{u}The file makes two variables available to the client@{uu}: extern @{FG shine}struct@{FG text} @{"Library" LINK "include:exec/libraries.h/MAIN" 33} *@{i}TextFieldBase@{ui}; extern @{FG shine}Class@{FG text} *@{i}TextFieldClass@{ui}; Starting in main() these varaibles will automatically be defined to have the library base and the class pointer.If the library fails to open, SAS/C's auto-open feature will close down the program with a standard Amiga requester telling the user what happened. @ENDNODE @NODE "Class_Name" "textfield.gadget/Class_Name()" NO PUBLIC CLASS NAME Future versions of the textfield.gadget intend to offer a public class name that you can use, but that will have to wait until (or if) Commodore or CATS return from the dead since I have to register the class name.At which time that a public class name is offered, both the old TEXTFIELD_GetClass() and the class name can be used with the NewObject() function so that old and new programs will work. @ENDNODE @NODE "OS_Version" "textfield.gadget/OS_Version()" WORKS ON OS 2.04 AND UP The class will work on OS 2.04 and up, but for OS 2.04 through 2.1 there is no standard place to put .gadget libraries, so on these systems the gadget should be installed in a drawer named "Gadgets" in the same directory of the program that uses it.See the example program on how to open the class.For OS 3.0 and up, just install the textfield.gadget file in "SYS:Classes/Gadgets" like normal. @ENDNODE @NODE "Str_Comparison" "textfield.gadget/Str_Comparison()" COMPARISON TO STRING GADGET Unlike the Amiga's string gadget, you get a gadget up message from this gadget when you hit the right mouse button, or either Amiga keys and the right alt keys pressed together. @ENDNODE @NODE "Rendering" "textfield.gadget/Rendering()" GADGET GRAPHIC ELEMENTS SUPPORTED This gadget does support the @{i}GA_Image@{ui} tag for rendering a linked list of images attached to the gadget.Borders structures are not supported. (Complain if you want it.) As of version 2.0 the gadget also supports @{i}GA_IntuiText@{ui} also.This means this gadget will render a linked list of @{"IntuiText" LINK "include:intuition/intuition.h/MAIN" 656} structures.Note that @{i}GA_Text@{ui} and @{i}GA_LabelImage@{ui} are not supported. (Like above, complain if you want it.) @{u}This may or may not help you, but the render order for the elements of@{uu} @{u}this gadget is as follows@{uu}: Border (if enabled) Lines of text Image (from @{i}GA_Image@{ui}) IntuiText (from @{i}GA_IntuiText@{ui}) So, images do overwrite borders and the lines of text.Also note that the gadget will render at least one line of text, and at least one character per line, so restrict the width and height if this is a problem. @ENDNODE @NODE "Buffer_Access" "textfield.gadget/Buffer_Access()" IMPORTANT NOTES ON ACCESSING THE BUFFER You must follow these rules or bad things can happen. The buffer pointer returned by @{i}TEXTFIELD_Text@{ui} with the get method is read only.You must not modify the buffer at any time. @{u}The buffer pointer returned by @{i}TEXTFIELD_Text@{ui} with the get method is@{uu} @{u}valid between any of the following@{uu}: OffGadget() valid OnGadget() @{i}GA_Disabled@{ui}, TRUE valid @{i}Disabled@{ui}, FALSE @{i}TEXTFIELD_ReadOnly@{ui}, TRUE valid @{i}TEXTFIELD_ReadOnly@{ui}, FALSE Anytime you are outside all of the above situations, the pointer is invalid and is guaranteed to change.In fact you will get a NULL pointer if you are outside all of the above situations. The size of the buffer you have can be obtained by issuing a get method of @{i}TEXTFIELD_Size@{ui} on the gadget inside the above situations. And if you get a size of 0, then you must not reference the pointer that is returned because it is NULL.Be very careful to never reference past the size given.The buffer is not NULL terminated. In C, that's buffer[0] through buffer[size - 1]. @ENDNODE @NODE "Buffer_Characters" "textfield.gadget/Buffer_Characters()" CHARACTERS ALLOWED IN THE BUFFER Normally the textfield gadget only allows you to put printable characters into its buffer.The gadget itself will filter out the non-printable characters, so that the buffer will only contain the values 0x0a, 0x20 - 0x7f, and 0xa0 - 0xff. In addition, the 0x0d character is automatically converted to 0x0a for you.The buffer that is passed to the gadget is not changed in any way.The gadget will copy the characters into its own internal buffer, making the changes along the way. If for some reason you need to have the other characters in your buffer, you can set the attribute @{i}TEXTFIELD_NonPrintChars@{ui} to TRUE and then all but 0x0d will be allowed in the buffer.As before, the 0x0d character will be converted to 0x0a. When characters are passed to the gadget, either by the application or by the user, only the characters listed above are allowed in.You can also make further restrictions with @{i}TEXTFIELD_AcceptChars@{ui} and @{i}TEXTFIELD_RejectChars@{ui}.See the tags section for specific details. @ENDNODE @NODE "Changing_Attributes" "textfield.gadget/Changing_Attributes()" CHANGING ATTRIBUTES When setting attributes, the gadget will always render the changes, except if the gadget's geometry is changed, in which case it will return a non-zero value to let you know changes need to be rendered by refreshing the gadget. A geometry change means that the gadget moves in the window. @{u}Specifically the following attributes cause the geometry to change@{uu}: @{i}GA_Top@{ui}, @{i}GA_Left@{ui}, @{i}GA_Width@{ui}, @{i}GA_Height@{ui}, @{i}GA_RelWidth@{ui}, @{i}GA_RelHeight@{ui}, @{i}GA_RelBottom@{ui}, @{i}GA_RelRight@{ui}. @{u}Here's how to handle this inside an application@{uu}: @{FG shine}if@{FG text} (@{b}SetGadgetAttrs@{ub}(@{i}gadget@{ui}, @{i}window@{ui}, @{i}requester@{ui}, ...)) { /* gadget needs rendering */ @{b}RefreshGList@{ub}(@{i}gadget@{ui}, @{i}window@{ui}, @{i}requester@{ui}, 1); } Some of the attributes cause others to not work properly.Do not get discouraged.This only applies when sending them in one OM_SET method.It is unavoidable in the current release, so if you are seeing things not work right, or in particular if a later tag works but a former one does not, then split the attributes among two calls. The gadget is set up so that later tags have precedence over former tags.This particularly applies to attributes that change the cursor position and scrolling (changing top and such). @ENDNODE @NODE "Move_or_Size" "textfield.gadget/Move_or_Size()" MOVING OR SIZING THE GADGET If you want to move the gadget or change its size you should take note of the section above on changing attributes.In addition, the source file TestClass.c in the TestClass example shows how to move the gadget or change its size.You should clear out the old position, then set the new position and size, and finally refresh the gadget. @ENDNODE @NODE "Undo" "textfield.gadget/Undo()" UNDO The undo function is implemented as an alternate paste buffer.In certain situations list below text will be copied into an undo buffer.When the undo command is issued, the text in that buffer is pasted to the current cursor position.It does not really undo anything, it just saves otherwise lost text.When the undo is actually performed, the undo buffer becomes cleared so that you cannot undo the same text multiple times. @{u}List of places where text is saved in the undo buffer@{uu}: - If you hit BACKSPACE or DELETE while some text is marked, the marked text is placed in the undo buffer before the text is deleted. - If you hit SHIFT BACKSPACE or DELETE, the text that is deleted is placed in the undo buffer. - If you hit ALT BACKSPACE or DELETE, the word that is deleted is placed in the undo buffer. - If you hit CTRL X, the line that is deleted is placed in the undo buffer. - If you type a character while some text is marked, the marked text is placed in the undo buffer before the text is delete. - When you perform a normal paste while text is marked, the marked text is placed in the undo buffer before it is deleted and the paste occurs. - If you perform an erase (RAMIGA E or programmatically), the whole buffer is placed in the undo buffer before it is deleted. @ENDNODE @NODE "User_Docs" "textfield.gadget/User_Docs()" DOCS FOR USERS You can mark text for cutting, copying, and erasing by simply clicking and dragging.Hitting alphanumeric keys replaces the text that is highlighted. Hitting cursor keys moves you to the front or end of the highlighted text. If your cursor is already somewhere in the textfield, you can hold the SHIFT key and click to mark the text from the current cursor position to the place where you clicked. And the last way to mark text is to double-click, which will mark the word you clicked on.If you didn't click on a word, but rather you clicked on spaces, the whole block of spaces is marked.And if you clicked on word delimiters, the whole block of delimiters is marked. While you drag to scroll, the farther away from the gadget your mouse pointer is, the faster the gadget will scroll.For key sequences, the Amiga Style Guide was followed.Anywhere the undo buffer is mentioned, the state- ment is only valid if the UndoStream is supplied (see tag section below). @{u}Key Sequence - Function@{uu}: @{b}TAB@{ub} - Activate next gadget (if @{i}GA_TabCycle@{ui}) @{b}SHIFT TAB@{ub} - Activate previous gadget (if @{i}GA_TabCycle@{ui}) @{b}SHIFT CURSOR UP@{ub} - Move to the top line in the current page, or scroll up one page if cursor is on top line @{b}SHIFT CURSOR DOWN@{ub} - Move to the bottom line in the current page, or scroll down one page if cursor is on top line @{b}CTRL or SHIFT CURSOR RIGHT@{ub} - Move to the right end of the current line @{b}CTRL or SHIFT CURSOR LEFT@{ub} - Move to the left end of the current line @{b}SHIFT BACKSPACE@{ub} - Delete all text to the left of cursor on the current line @{b}SHIFT DELETE@{ub} - Delete all text to the right of the cursor on the current line (in block cursor mode this also includes the highlighted character) @{b}CTRL CURSOR UP@{ub} - Move to the top line of the text @{b}CTRL CURSOR DOWN@{ub} - Move to the bottom line of the text @{b}ALT CURSOR RIGHT@{ub} - Move to the next word (using the delimiter characters provided by the programmer) @{b}ALT CURSOR LEFT@{ub} - Move to the previous word (using the delimiter characters provided by the programmer) @{b}ALT CURSOR UP@{ub} - Move to first character in gadget @{b}ALT CURSOR DOWN@{ub} - Move to last character in gadget @{b}ALT BACKSPACE@{ub} - Deletes the word to the left of the cursor starting at the current cursor position @{b}ALT DEL@{ub} - Deletes the word to the right of the cursor starting at the current cursor position @{b}CTRL X@{ub} - Deletes the whole line that the cursor is on @{b}RAMIGA [@{ub} - Switch to left justification (if @{i}TEXTFIELD_UserAlign@{ui} is set) @{b}RAMIGA \ or RAMIGA =@{ub} - Switch to center justification (if @{i}TEXTFIELD_UserAlign@{ui} is set) @{b}RAMIGA ]@{ub} - Switch to right justification (if @{i}TEXTFIELD_UserAlign@{ui} is set) @{b}RAMIGA E@{ub} - Erase all text in gadget (saved in undo buffer) (no read-only) @{b}RAMIGA V@{ub} - Paste text from clipboard to current cursor position (no read-only) @{b}RAMIGA A@{ub} - Mark all text @{b}RAMIGA U@{ub} - Undeletes (pastes) the last block of text marked, or recover from RAMIGA E (no read-only) @{u}When text is highlighted the following keys have functions@{uu}: @{b}BACKSPACE@{ub} - Erase marked text (saved in undo buffer) @{b}DEL@{ub} - Erase marked text (saved in undo buffer) @{b}RAMIGA X@{ub} - Cut marked text to clipboard (no read-only) @{b}RAMIGA C@{ub} - Copy marked text to clipboard @{b}RAMIGA V@{ub} - Replace marked text with text from clipboard (save marked text in undo buffer) (no read-only) @{b}(any text key)@{ub} - Replace marked text with that character @ENDNODE @NODE "Applicability" "textfield.gadget/Applicability()" APPLICABILITY IN THE TAGS SECTION In the TAGS section there is a statement with each attribute called applicability.It consists of a letters inside parentheses, like (ISGNU).These are standard BOOPSI letters that tell you which standard methods the attribute can be used. @{u}Here's what the letters refer to (see the BOOPSI reference in the@{uu} @{u}RKRM: Libraries for further information)@{uu}: @{b}I@{ub} - OM_NEW (initializable) @{b}S@{ub} - OM_SET (settable) @{b}G@{ub} - OM_GET (gettable) @{b}N@{ub} - OM_NOTIFY (is passed in gadget's notify message) @{b}U@{ub} - OM_UPDATE (updatable) @ENDNODE @NODE "Tags" "textfield.gadget/Tags()" @{i}@{b}GA_Left@{ub}@{ui} (WORD) -- Specifies the left edge of the gadget. @{i}@{b}GA_Top@{ub}@{ui} (WORD) -- Specified the top edge of the gadget. @{i}@{b}GA_Width@{ub}@{ui} (WORD) -- Specifies the width of the gadget. If a border is chosen, it will be rednered within this value. @{i}@{b}GA_Height@{ub}@{ui} (WORD) -- Specifies the height of the gadget. If a border is chosen, it will be rendered within this value. @{i}@{b}GA_RelRight@{ub}@{ui} (WORD) -- Specifies the gadget as being relative to the right border of whatever the gadget is attached to.See the BOOPSI Class Reference. @{i}@{b}GA_RelBottom@{ub}@{ui} (WORD) -- Specifies the gadget as being relative to the bottom border of whatever the gadget is attached to.See the BOOPSI Class Reference. @{i}@{b}GA_RelWidth@{ub}@{ui} (WORD) -- Specifies the gadget as being relative to the width of whatever it is attached to.See the BOOPSI Class Reference. @{i}@{b}GA_RelHeight@{ub}@{ui} (WORD) -- Specifies the gadget as being relative to the height of whatever it is attached to.See the BOOPSI Class Reference. @{i}@{b}GA_Image@{ub}@{ui} (@{FG shine}struct@{FG text} @{"Image" LINK "include:intuition/intuition.h/MAIN" 705} *) -- Pass a pointer to a linked list of images and this class will render them relative to the gadget's upper left corner. See rendering order above. @{i}@{b}GA_IntuiText@{ub}@{ui} (@{FG shine}struct@{FG text} @{"IntuiText" LINK "include:intuition/intuition.h/MAIN" 656} *) -- Pass a pointer to a linked list of IntuiText structures and this class will render them relative to the gadget's upper left corner.See rendering order above.(V2) @{i}@{b}GA_Disabled@{ub}@{ui} (BOOL) -- TRUE disables the gadget, not allowing input, and FALSE enables the gadget for input.When the gadget is disabled, it usually is ghosted, see @{i}TEXTFIELD_NoGhost@{ui} for other conditions. @{i}@{b}GA_TabCycle@{ub}@{ui} (BOOL) -- Turns on tab cycling.See the BOOPSI Class Reference. @{i}@{b}TEXTFIELD_Text@{ub}@{ui} (@{FG shine}char@{FG text} *) -- This set/replaces text.NULL means no change. To set the buffer empty pass "" (pointer to empty string, not a NULL pointer). When you use it to get text see special conditions under @{b}IMPORTANT@{ub} in the @{"Buffer_Access" LINK "Buffer_Access" 0} section above.The cursor position is reset to the beginning (0).The pointer passed must be a pointer to a NULL terminated string of characters.If you have read-only mode turned on with @{i}TEXTFIELD_ReadOnly@{ui}, this attribute still works.The text is copied to an internal buffer. @{b}Default@{ub} for this tag is NULL.@{i}Applicability@{ui} is (ISG U). @{i}@{b}TEXTFIELD_InsertText@{ub}@{ui} (@{FG shine}char@{FG text} *) -- This inserts text at current cursor position and move the cursor to the end of the inserted text. You must pass a NULL terminated pointer to characters.If you have read only mode turned on with @{i}TEXTFIELD_ReadOnly@{ui}, this attribute still works. @{i}Applicability@{ui} is ( S U). @{i}@{b}TEXTFIELD_DeleteText@{ub}@{ui} (ULONG) -- This deletes the number of characters you pass in the data field, starting at the current cursor position.This attribute works even if read only mode is turned on with @{i}TEXTFIELD_ReadOnly@{ui}. @{i}Applicability@{ui} is ( S U).(V2) @{i}@{b}TEXTFIELD_TextFont@{ub}@{ui} (@{FG shine}struct@{FG text} @{"TextFont" LINK "include:graphics/text.h/MAIN" 88} *) -- Sets the font for the gadget to use. Pass the object a pointer to a TextFont structure.This supersedes @{i}TEXTFIELD_TextAttr@{ui} below.Please do not close this font while the gadget is using it.:) The default font is your screen's current font. @{b}Default@{ub} for this tag is NULL.@{i}Applicability@{ui} is (IS U). @{i}@{b}TEXTFIELD_TextAttr@{ub}@{ui} (@{FG shine}struct@{FG text} @{"TextAttr" LINK "include:graphics/text.h/MAIN" 64} *) -- Sets the font the gadget is to use. Pass the gadget a pointer to a TextAttr structure.This is superseded by @{i}TEXTFIELD_TextFont@{ui}.The default font is the screen's current font. @{b}Default@{ub} for this tag is NULL.@{i}Applicability@{ui} is (IS U). @{i}@{b}TEXTFIELD_FontStyle@{ub}@{ui} (ULONG) -- The style will get set to what you pass here. The font style automatically gets reset when @{i}TEXTFIELD_TextFont@{ui} or @{i}TEXTFIELD_TextAttr@{ui} is set. @{b}Default@{ub} for this tag is @{i}FSF_PLAIN@{ui}.@{i}Applicability@{ui} is (IS U). @{i}@{b}TEXTFIELD_Delimiters@{ub}@{ui} (@{FG shine}char@{FG text} *) -- You get the default if you pass NULL.Words break after these and "\n".You will probably want at least " ", the space. This string is not copied, so do not get rid of it while the gadget is in use. @{b}Default@{ub} for this tag is "@{b},)!@^&*_=+\\|<>?/ @{ub}".@{i}Applicability@{ui} is (IS U). @{i}@{b}TEXTFIELD_AcceptChars@{ub}@{ui} (@{FG shine}char@{FG text} *) -- Tells the textfield gadget which characters to accept.All others are rejected, and non-printable characters are automa- tically rejected.Some of these characters may not be accepted if they also appear in the reject string.This string is not copied, so do not get rid of it while the gadget is in use.A NULL means to accept all characters. @{b}Default@{ub} for this tag is NULL.@{i}Applicability@{ui} is (IS U).(V2) @{i}@{b}TEXTFIELD_RejectChars@{ub}@{ui} (@{FG shine}char@{FG text} *) -- Tells the textfield gadget which characters to reject.Non-printable characters are automatically rejected.Characters specified with this are always rejected.This string is not copied, so do not get rid of it while the gadget is in use.A NULL means to reject no characters. @{b}Default@{ub} for this tag is NULL.@{i}Applicability@{ui} is (IS U).(V2) @{i}@{b}TEXTFIELD_BlinkRate@{ub}@{ui} (ULONG) -- This sets the number of microseconds between a cursor on-off, or off-on transition.A value of 0 means do not blink. Realistically, this should be set to 100000 or higher since BOOPSI objects don't get idle messages any faster than about once every 10th of a second, but any value between 0 and 100000 will just make the cursor blink as fast as it can.If you give the user an option of blink speed, suggest values: 0 for no blink, 750000 for a slow blink, 500000 for a medium blink, and 250000 for a fast blink.@{b}Default@{ub} for this tag is 0.@{i}Applicability@{ui} is (IS U). @{i}@{b}TEXTFIELD_BlockCursor@{ub}@{ui} (BOOL) -- Turn on/off block cursor mode.You should not use a block cursor if your font is italic because it looks weird. @{b}Default@{ub} for this tag is FALSE.@{i}Applicability@{ui} is (IS U). @{i}@{b}TEXTFIELD_CursorPos@{ub}@{ui} (ULONG/ULONG *) -- Get/Set the cursor position. The cursor position returned is always an exact offset into the buffer you get to read via @{i}TEXTFIELD_Text@{ui}.0 takes you to the first character in the gadget, and 0xFFFFFFFF takes you past the last character in the gadget. In general, any value you pass that is larger than what's returned by @{i}TEXTFIELD_Size@{ui} will end up just past the last character in the gadget. Setting this attribute will scroll the text to the position you set the cursor to.If there is any text highlighted, highlighting is turned off. When you get the current cursor position, you must pass a pointer to a ULONG. The ULONG will then have the cursor position in it.@{i}Applicability@{ui} is (ISG U). @{i}@{b}TEXTFIELD_Size@{ub}@{ui} (ULONG *) -- Returns the number of characters in the gadget's buffer, including \n characters.This gives you the size when you want to use @{i}TEXTFIELD_Text@{ui} to read the text in the gadget.You must pass a pointer to a ULONG and then the ULONG will contain the value.@{i}Applicability@{ui} is ( G ). @{i}@{b}TEXTFIELD_MaxSize@{ub}@{ui} (ULONG) -- Limit the size of text entered into the gadget. 0 means unlimited, otherwise limits the buffer size to what you pass.This includes \n characters.@{b}Default@{ub} for this tag is UNLIMITED.@{i}Applicability@{ui} is (I). @{i}@{b}TEXTFIELD_MaxSizeBeep@{ub}@{ui} (BOOL) -- This attribute lets you set whether the system DisplayBeep() function is called if the user attempts to enter text into the gadget and the gadget is full (i.e. the gadget's buffer size is equal to the limit set by @{i}TEXTFIELD_MaxSize@{ui}).If TRUE the system beep is called.If FALSE, the system beep is not called.@{b}Default@{ub} for this tag is TRUE. @{i}Applicability@{ui} is (IS U).(V2) @{i}@{b}TEXTFIELD_Visible@{ub}@{ui} (ULONG *) -- Get the current number of visible lines. It always returns how many @{b}_could_@{ub} be displayed if there were enough characters to fill the display.Use for notifying a BOOPSI prop gadget. You actually pass a pointer to a ULONG and then the ULONG will contain the value.See example program.@{i}Applicability@{ui} is ( GN ). @{i}@{b}TEXTFIELD_Lines@{ub}@{ui} (ULONG *) -- Get the total number of lines in the buffer of the gadget.Use this to also notify a BOOPSI prop gadget.You pass a pointer to a ULONG and then the ULONG will contain the value. See example program.@{i}Applicability@{ui} is ( GN ). @{i}@{b}TEXTFIELD_Top@{ub}@{ui} (ULONG/ULONG *) -- Get or set ordinal value of the top line. 0 is the top most line.This is useful for @{i}ICA_MAP@{ui} and @{i}ICA_TARGET@{ui} when using the BOOPSI prop gadget and notifications.When you get the value you pass a pointer to a ULONG and then the ULONG will contain the value.See sample program for example.@{b}Default@{ub} for this tag is 0.@{i}Applicability@{ui} is ( SGNU). @{i}@{b}TEXTFIELD_Partial@{ub}@{ui} (BOOL) -- When this flag is set to TRUE, partial lines will be shown at the bottom of the gadget.When this flag is set to false, then only whole lines will be shown in the gadget.Note that having both @{i}TEXTFIELD_VCenter@{ui}, and @{i}TEXTFIELD_Partial@{ui} on is not allowed and doesn't make sense.If both @{i}TEXTFIELD_VCenter@{ui} and @{i}TEXTFIELD_Partial@{ui} are turned on at the same time, only @{i}TEXTFIELD_VCenter@{ui} will get turned on. @{b}Default@{ub} for this tag is FALSE.@{i}Applicability@{ui} is (IS U). @{i}@{b}TEXTFIELD_NoGhost@{ub}@{ui} (BOOL) -- If TRUE, never ghost when gadget is disabled. If FALSE, then ghost when gadget is disabled.You can use this to make a read only multiline string gadget.It has a special purpose, though. Normally you will want a gadget to be enabled when allowing text to be entered.However, when you need to read the text from the gadget, you have to disable it.But disabling a gadget ghosts it.So, with this option, you can pass @{i}GA_Disabled@{ui}, TRUE, @{i}TEXTFIELD_NoGhost@{ui}, TRUE at the same time and it will disable without ever showing the ghosted pattern.And likewise, passing the attributes @{i}GA_Disabled@{ui}, FALSE, @{i}TEXTFIELD_NoGhost@{ui}, FALSE will seamlessly reenable the gadget.While the gadget is disabled, read the text and then be on your way.Also note that most S and U attributes are settable while the gadget is disabled, notably @{i}TEXTFIELD_Top@{ui}.This allows you to make a scrollable read-only multiline non-ghosted text, image capable, and border capable gadget.Sounds useful to me! The read only mode is probably better. See below.@{b}Default@{ub} for this tag is FALSE.@{i}Applicability@{ui} is (IS U). @{i}@{b}TEXTFIELD_ReadOnly@{ub}@{ui} (BOOL) -- If TRUE, then the gadget does not allow text to be entered or deleted by the user.However, the user can still highlight so that text can be copied to the clipboard.If FALSE, then the gadget acts normally.If you want a read only mode without clipboard support, then use the @{i}GA_Disabled@{ui} and @{i}TEXTFIELD_NoGhost@{ui} mode mentioned in the @{i}TEXTFIELD_NoGhost@{ui} description.All but two of the normal keyboard editing commands are ignored while in read-only mode.RAMIGA-a highlights all text, and RAMIGA-c copies highlighted text to the clipboard.Other RAMIGA keys will get passed is @{i}TEXTFIELD_PassCommand@{ui} is turned on.@{u}So that the gadget acts more like it's not@{uu} @{u}active while in this mode, certain keys events get passed on to the window@{uu}: F1-F10, Help, Cursor keys. Note that non-RAWKEY events, like mouse moves, buttons, and timer events are not passed on so that normal highlighting and scrolling can occur.There is no visual change in the gadget when it is read-only other than it does not have a cursor.You should set the border to an inverted bevel or inverted double-bevel.By the style guide, inverted borders represent read-only gadgets.@{b}Default@{ub} for this tag is FALSE.@{i}Applicability@{ui} is (IS U).(V2) @{i}@{b}TEXTFIELD_Modified@{ub}@{ui} (BOOL) -- This attribute is a flag that you can set and read to find out if a gadget's buffer has been modified in some way.For instance, if you wanted to load some text into the gadget, then when the program quits determine if the text was modified then you would load and set the flag like this: @{i}TEXTFIELD_Text@{ui}, text, @{i}TEXTFIELD_Modified@{ui}, FALSE. Note that the order matters, such that if they were reversed the text change would promptly set the modified flag to TRUE.You can read or set this flag at any time.The flag also notifies any listeners. @{b}Default@{ub} for this tag is FALSE.@{i}Applicability@{ui} is (ISGNU).(V2) @{i}@{b}TEXTFIELD_PassCommand@{ub}@{ui} (BOOL) -- This attribute is a flag to allow the gadget to pass unused right Amiga key sequences (command key sequences) on to the client application.If the flag is set to TRUE then the key sequences are passed to the client.There is a side effect that causes the gadget to become inactive (as if the user had clicked outside the gadget).The default behavior (set to FALSE) is to ignore these key sequences so that the gadget remains active.@{b}Default@{ub} for this tag is FALSE.@{i}Applicability@{ui} is (IS U).(V2) @{i}@{b}TEXTFIELD_NonPrintChars@{ub}@{ui} (BOOL) -- This attribute is a flag that when set to TRUE allows all characters except 0x0d into the gadget's buffer.When the flag is set to FALSE, only printable characters are allowed in the buffer (0x20 - 0x7f, 0xa0 - 0xff, and 0x0a). @{b}Default@{ub} for this tag is FALSE.@{i}Applicability@{ui} is (IS U).(V3). @{i}@{b}TEXTFIELD_Border@{ub}@{ui} (ULONG) -- Sets the border type.See defines below. The gadget offers a standard bevel, and standard double bevel. If you need another type, your could always create an image, link it to the gadget with @{i}GA_Image@{ui}, and set its top and left edges above and to the left of this gadget (negative in the image structure), and make the width and height larger than this gadget. @{b}Default@{ub} for this tag is @{i}TEXTFIELD_BORDER_NONE@{ui}.@{i}Applicability@{ui} is (IS U). @{i}@{b}TEXTFIELD_Inverted@{ub}@{ui} (BOOL) -- If this flags is TRUE, the border is drawn inverted, if there is a border.If FALSE, the border is drawn non-inverted. This option is here in case you want to give the textfield gadget a read-only look when used in conjunction with @{i}TEXTFIELD_NoGhost@{ui} and @{i}GA_Disabled@{ui}. @{b}Default@{ub} for this tag is FALSE.@{i}Applicability@{ui} is (IS U). @{i}@{b}TEXTFIELD_Up@{ub}@{ui} (ULONG) -- Moves the text up by one line.You can pass anything, but it will only move the text up by a line, if it's not at the top already. Useful for BOOPSI notifications.@{i}Applicability@{ui} is ( S U). @{i}@{b}TEXTFIELD_Down@{ub}@{ui} (ULONG) -- Moves the text down by one line.You can pass anything, but it will only move the text down by a line, if it's not at the bottom already.Useful for BOOPSI notifications.@{i}Applicability@{ui} is ( S U). @{i}@{b}TEXTFIELD_Alignment@{ub}@{ui} (ULONG/ULONG *) -- Set/Get the line justification. This gadget offers left, center, and right justification. When you are getting the flags, you need to pass a pointer to a ULONG and then the ULONG will contain the flags.See defines below. @{b}Default@{ub} for this tag is @{i}TEXTFIELD_ALIGN_LEFT@{ui}.@{i}Applicability@{ui} is (ISG U). @{i}@{b}TEXTFIELD_VCenter@{ub}@{ui} (BOOL) -- Turn on/off vertical centering.When on, the lines in the display are centered vertically.If the total number of lines is less than the visible number of lines then the smaller number of lines are centered. This allows you to center single lines of text within the gadget very easily. For normal text entry operation, it is best to leave this off.Also, check @{i}TEXTFIELD_Partial@{ui} for possible conflicts when used with @{i}TEXTFIELD_VCenter@{ui}. @{b}Default@{ub} for this tag is FALSE.@{i}Applicability@{ui} is (IS U). @{i}@{b}TEXTFIELD_UserAlign@{ub}@{ui} (BOOL) -- If this is set at creation, then the user will have control over the left/center/right justification of text through RIGHT-AMIGA [, =, ] keyboard shortcuts.If you want to save what the user has set the justification to, then do a GetAttr() on @{i}TEXTFIELD_Alignment@{ui}. @{b}Default@{ub} for this tag is FALSE.@{i}Applicability@{ui} is (I ). @{i}@{b}TEXTFIELD_RuledPaper@{ub}@{ui} (BOOL) -- Lets you set whether the paper (background) has ruled horizontal lines under each line of text or not. @{b}Default@{ub} for this tag is FALSE.@{i}Applicability@{ui} is (IS U). @{i}@{b}TEXTFIELD_PaperPen@{ub}@{ui} (ULONG) -- This lets you specify the pen used for drawing the paper (background) of the gadget.A value of -1 means use default, which is BACKGROUNDPEN.@{b}Default@{ub} for this tag is -1.@{i}Applicability@{ui} is (IS U). @{i}@{b}TEXTFIELD_InkPen@{ub}@{ui} (ULONG) -- This lets you specify the pen used for drawing the text.A value of -1 means use the default, which is TEXTPEN.If this pen, and the @{i}TEXTFIELD_LinePen@{ui} are different, then rendering speed is slowed down a bit.It is recommended that the line pen be left to -1. @{b}Default@{ub} for this tag is -1.@{i}Applicability@{ui} is (IS U). @{i}@{b}TEXTFIELD_LinePen@{ub}@{ui} (ULONG) -- This lets you specify the pen used for drawing the ruled lines, if @{i}TEXTFIELD_RuledPaper@{ui} is TRUE.See @{i}TEXTFIELD_InkPen@{ui} for possible speed problems when specifying this pen.A value of -1 means to use the same pen as @{i}TEXTFIELD_InkPen@{ui}.@{b}Default@{ub} for this tag is -1. @{i}Applicability@{ui} is (IS U). @{i}@{b}TEXTFIELD_Spacing@{ub}@{ui} (UBYTE) -- Lets you set an extra amount of spacing between lines of text, for maybe doing 1-1/2 or double spacing.It's a pixel value between 0 and 255.The space is added to the top of each line.In other words, the baseline is moved down by the amount you specify. @{b}Default@{ub} for this tag is 0.@{i}Applicability@{ui} is (IS U). @{i}@{b}TEXTFIELD_TabSpaces@{ub}@{ui} (UBYTE) -- Lets you set how many spaces get inserted when the TAB key is pressed.This does not work at all unless @{i}GA_TabCycle@{ui} is set to FALSE.In other words, if you have @{i}GA_TabCycle@{ui} on, then you cannot have tabs insert any spaces.@{b}Default@{ub} for this tag is 0.@{i}Applicability@{ui} is (IS U).(V3) @{i}@{b}TEXTFIELD_ClipStream@{ub}@{ui} (@{FG shine}struct@{FG text} @{"ClipboardHandle" LINK "include:libraries/iffparse.h/MAIN" 147} *) -- This tag allows clipboard support in the gadget.Pass the pointer returned from the iffparse.library OpenClipboard() function.If a NULL is passed, the clipboard support is not allowed.Please supply this tag value.Don't leave users without clipboard support.It is recommended that the unit opened by OpenClipboard() be 0 or @{i}PRIMARY_UNIT@{ui}, since that is the standard unit, but you can pick whatever unit you or your user wants.This stream can be safely given to multiple objects.@{b}Default@{ub} for this tag is NULL.@{i}Applicability@{ui} is (I ). @{i}@{b}TEXTFIELD_ClipStream2@{ub}@{ui} (@{FG shine}struct@{FG text} ClipboardHandle *) -- ClipStream2 is used for the undo features of the textfield class.It is obtained from the iffparse.library OpenClipboard() function.You should probably use a clipboard unit other than 0 to avoid conflicts with normal clips.This stream can be safely passed to multiple objects.(See @{i}TEXTFIELD_UndoStream@{ui}) @{b}Default@{ub} for this tag is NULL.@{i}Applicability@{ui} (I ). @{i}@{b}TEXTFIELD_UndoStream@{ub}@{ui} -- This is a synonym for @{i}TEXTFIELD_ClipStream2@{ui}.See it above. @{i}@{b}TEXTFIELD_LineLength@{ub}@{ui} (ULONG *) -- Get the contents of the ULONG to a line num- ber and that ULONG will be replaced with the length of that line in characters. If you are worried about the line lengths changing while you are reading them, then try removing the gadget from the window first.Please realize that if the gadget has a relative width or height then the lengths can change anytime the user resized the window.@{i}Applicability@{ui} is ( G ).(V2) @{i}@{b}TEXTFIELD_SelectSize@{ub}@{ui} (ULONG/ULONG *) -- Set the number of characters to high- light starting from the current cursor position.If the value is 0, highlight- ing will be turned off.If the number is non-zero, that number of characters will be highlighted.You can also get the number of highlighted characters with this attribute by passing a ULONG *.If you get a 0 value, then high- lighting is turned off.This can is useful for the copy, cut, and paste commands.@{i}Applicability@{ui} is ( SG U).(V2) @{i}@{b}TEXTFIELD_Copy@{ub}@{ui} -- When this attribute is specified, the gadget copies any highlighted text to the clipboard.Highlighting is turned off after issuing this.You can put Copy in a menu with this.This does not take a parameter. @{i}Applicability@{ui} is ( S U).(V2) @{i}@{b}TEXTFIELD_CopyAll@{ub}@{ui} -- When this attribute is specified, the gadget copies all of the gadget's text to the clipboard.It does not affect the state of the highlight and the text does not need to be highlighted.You can put Copy All in a menu with this.This does not take a parameter.@{i}Applicability@{ui} is (SU).(V2) @{i}@{b}TEXTFIELD_Cut@{ub}@{ui} -- When this attribute is specified, the gadget will cut any high- lighted text to the clipboard.Cut text goes to the clipboard.You can put Cut in a menu with this.This does not take a parameter.@{i}Applicability@{ui} is (SU).(V2) @{i}@{b}TEXTFIELD_Paste@{ub}@{ui} -- When this attribute is specified, the gadget will delete any highlighted text to the undo buffer, then it will paste the text from the clipboard to the gadget.You can put Paste in a menu with this.This does not take a parameter.@{i}Applicability@{ui} is ( S U).(V2) @{i}@{b}TEXTFIELD_Erase@{ub}@{ui} -- When this attribute is specified, the gadget will delete any highlighted text, otherwise do nothing.If text is deleted, it's placed in the undo buffer.You can put Erase in a menu with this.This does not take a parameter.@{i}Applicability@{ui} is ( S U).(V2) @{i}@{b}TEXTFIELD_Undo@{ub}@{ui} -- When this attribute is specified, the gadget will delete any highlighted text, then insert the text from the undo buffer.You can put Undo in a menu with this.This does not take a parameter.@{i}Applicability@{ui} is (SU).(V2) @ENDNODE @NODE "Borders" "textfield.gadget/Borders()" BORDER REFERENCE You can use the width and heights given when calculating window sizes and limits.To make the window's height minimal with respect to your font, use (window border top) + (window border bottom) + (num_lines * (font height)) + (gadget border height).Also, if you use TEXTFIELD_Spacing, you'll have to add that in too. @{b}TEXTFIELD_BORDER_NONE@{ub} - Border takes up: 0 width, 0 height @{b}TEXTFIELD_BORDER_BEVEL@{ub} - Border takes up: 8 width, 4 height @{b}TEXTFIELD_BORDER_DOUBLEBEVEL@{ub} - Border takes up: 12 width, 6 height @ENDNODE @NODE "Alignment" "textfield.gadget/Alignment()" ALIGMENT REFERENCE @{b}TEXTFIELD_ALIGN_LEFT@{ub} - Cause text to be flush left @{b}TEXTFIELD_ALIGN_CENTER@{ub} - Cause text to be centered @{b}TEXTFIELD_ALIGN_RIGHT@{ub} - Cause text to be flush right @ENDNODE @NODE "Bugs" "textfield.gadget/Bugs()" BUGS What bugs? Please let me know if you find any. See the History file for a list of fixed bugs. DEBUGGING A version of the textfield.gadget library is provided with routines that print debug information to the serial port using the current settings for the serial device.It could be helpful.Just rename the debug gadget (textfield.gadget.db) to textfield.gadget and place it in the normal gadgets place listed above. @ENDNODE @NODE "Author" "textfield.gadget/Author()" @{u}To contact me for reporting bugs or giving suggestions@{uu}: Mark Thomas 9036 N.Lamar, Apt.#125 Austin, TX 78753 or mthomas@zilker.net @ENDNODE @NODE "GetClass()" "textfield.gadget/GetClass()()" @{b}@{u}TEXTFIELD_GetClass@{uu}@{ub} -- Gets the pointer to the textfield class.(V1) Obtains the pointer to the textfield.gadget class for use with NewObject().This function always returns a valid pointer so you do not need to check it.The reason is that if the library opens fine, then the pointer returned is already setup.(Of course this implies that if opening the library fails, you shouldn't be calling this.) SYNOPSIS @{FG shine}Class@{FG text} *TEXTFIELD_GetClass(@{FG shine}void@{FG text}); @{i}@{b}textfield_class@{ub}@{ui} = TEXTFIELD_GetClass(); D0 @{i}@{b}textfield_class@{ub}@{ui} - the pointer to the textfield.gadget class. @ENDNODE @NODE "GetCopyright()" "textfield.gadget/GetCopyright()()" @{b}@{u}TEXTFIELD_GetCopyright@{uu}@{ub} -- Gets a pointer to the copyright and version string for use in About requesters.(V3) Gets a pointer to a string that contains the copyright information for textfield.gadget.@{u}The string has the following format@{uu}: "@{b}textfield.gadget 3.1 is\nCopyright © 1995 Mark Thomas@{ub}" SYNOPSIS @{FG shine}char@{FG text} *TEXTFIELD_GetCopyright(@{FG shine}void@{FG text}); @{i}@{b}copyright_str@{ub}@{ui} = TEXTFIELD_GetCopyright(); D0 @{i}@{b}copyright_str@{ub}@{ui} - the pointer to the copyright string. @ENDNODE @NODE "--background--" "gauge/--background--" PURPOSE The "Amiga User Interface Style Guide" contains an example of how a progress requester should look like (page 29), but this example has no "teeth".It is just a visual cue, you still have to implement the requester yourself.Around Christmas Day, the issue was brought up in comp.sys.amiga.programmer how to program these progress requesters.This is my attempt at solving the problem. GOALS - The progress requester should be entirely self-contained and reentrant. - It should be simple to find out if the user has hit the "Stop" button. - Creation and management of the requester should follow a familiar model. - The display should be font sensitive. IMPLEMENTATION The implementation consists of a set of BOOPSI objects, which are linked together, plus a display element for the gauge.This is similar to how Intuition builds system requesters and has the advantage of delegating the work load of refreshing and maintaining the display to Intuition.The application to create the display just has to listen for the user to hit the "Stop" button, it need not worry about housekeeping work. The gauge creation code is reentrant, it was written with SAS/C in mind.The only compiler dependant part is the custom class dispatcher.You must initialize @{"IntuitionBase" LINK "include:intuition/intuitionbase.h/MAIN" 65}, @{"GfxBase" LINK "include:graphics/gfxbase.h/MAIN" 25}, @{"UtilityBase" LINK "include:utility/utility.h/MAIN" 30} and SysBase for the gauge code to work. COPYRIGHT AND USAGE RESTRICTIONS This implementation is Copyright © 1997 by Olaf `Olsen' Barthel. It is freely distributable.I place no restrictions on its usage. You may use this code in commercial software or shareware programs without having to pay royalties to me.An acknowledgement would still be nice, though :^) If you find bugs in the code or make enhancements, please notify me.I would like to keep this code updated, so everyone will be able to take advantage of it. @{u}My electronic mail address@{uu}: olsen@sourcery.han.de @{u}My postal address@{uu}: Olaf Barthel Brabeckstrasse 35 D-30559 Hannover Federal Republic of Germany @ENDNODE @NODE "DisposeGauge" "gauge/DisposeGauge()" @{b}@{u}DisposeGauge@{uu}@{ub} -- Close a progress requester Window. When you are finished with the work the progress gauge represents, you should close the gauge Window.This routine will close the display opened by @{"NewGaugeA()" LINK "NewGaugeA" 0}. SYNOPSIS @{FG shine}void@{FG text} DisposeGauge(@{FG shine}struct@{FG text} Gauge *); DisposeGauge(@{i}Gauge@{ui}) @{i}Gauge@{ui} - Pointer to a Gauge structure as created by @{"NewGaugeA()" LINK "NewGaugeA" 0}. NULL is a valid parameter. EXAMPLE /* Close the gauge display */ DisposeGauge(@{i}gauge@{ui}); SEE ALSO @{"NewGaugeA" LINK "NewGaugeA" 0} @ENDNODE @NODE "GetGaugeA" "gauge/GetGaugeA()" @{b}@{u}GetGaugeA@{uu}@{ub} -- Obtain information about the gauge display. The Gauge structure is meant to be opaque, you should not peek inside to find the information you need, such as the pointer to the Window the dis- play is built on top of.Rather, use this routine to find out about it.This routine also provides means to find out if a user has hit the "Stop" button. SYNOPSIS @{FG shine}long@{FG text} GetGaugeA(@{FG shine}struct@{FG text} Gauge *,@{FG shine}struct@{FG text} @{"TagItem" LINK "include:utility/tagitem.h/MAIN" 31} *); @{i}@{b}Attributes@{ub}@{ui} = GetGaugeA(@{i}Gauge@{ui},@{i}TagList@{ui}) @{FG shine}long@{FG text} GetGauge (@{FG shine}struct@{FG text} Gauge *,...); @{i}@{b}Attributes@{ub}@{ui} = GetGauge (@{i}Gauge@{ui},@{i}Tags@{ui}); @{i}Gauge@{ui} - Pointer to a Gauge structure as created by @{"NewGaugeA()" LINK "NewGaugeA" 0}. NULL is a valid parameter. @{i}TagList@{ui} - Pointer to a table of TagItem structures. NULL is a valid parameter. @{i}@{b}Attributes@{ub}@{ui} - Number of attributes this function could provide information on. @{"TAGS" link GETGAUGEA_TAGS} @{"EXAMPLE" link GETGAUGEA_EXAMPLE} NOTES If this function returns a number smaller than the actual number of attributes you inquired about, some of the variables you have provided will not be initialized. SEE ALSO @{"NewGaugeA" LINK "NewGaugeA" 0}, gadtools.library/GT_GetGadgetAttrs @ENDNODE @node GETGAUGEA_TAGS "GetGaugeA_tags" @{i}@{b}GAUGE_MsgPort@{ub}@{ui} (@{FG shine}struct@{FG text} @{"MsgPort" LINK "include:exec/ports.h/MAIN" 27} *) - Pointer to the port IntuiMessages arrive at the gauge Window. @{i}@{b}GAUGE_Window@{ub}@{ui} (@{FG shine}struct@{FG text} @{"Window" LINK "include:intuition/intuition.h/MAIN" 909} *) - Pointer to the Window the progress requester is built on top of.If the gauge display is using a shared message arrival port, you can use the Window pointer to find out if an input event was meant for the gauge display rather than a different Window. @{i}@{b}GAUGE_Hit@{ub}@{ui} (@{FG shine}long@{FG text}) - If the user hit the "Stop" button, this routine will return TRUE, FALSE otherwise. @{i}@{b}GAUGE_SigBit@{ub}@{ui} (@{FG shine}long@{FG text}) - Provides the signal bit of the message arrival port the gauge Window uses. @endnode @node GETGAUGEA_EXAMPLE "GetGaugeA_example" /* Find out whether the user has hit the "Stop" button.*/ @{FG shine}long@{FG text} @{i}stop@{ui}; @{FG shine}if@{FG text}(@{b}GetGauge@{ub}(@{i}gauge@{ui}, @{i}GAUGE_Hit@{ui},@{i}&stop@{ui}, TAG_END) == 1) { @{FG shine}if@{FG text}(@{i}stop@{ui}) printf("@{b}User wants to stop the work in progress@{ub}.\n"); @{FG shine}else@{FG text} printf("@{b}The work in progress can continue@{ub}.\n"); } @{FG shine}else@{FG text} { printf("@{b}Something is wrong@{ub}.\n"); } @endnode @NODE "NewGaugeA" "gauge/NewGaugeA()" @{b}@{u}NewGaugeA@{uu}@{ub} -- Create a progress gauge display requester. The "Amiga User Interface Style Guide" gives an example of how a progress requester should look like (page 29).This example lacks "teeth" as it just represents a visual cue, not something you can work with--until you implement it.NewGaugeA() will create such a progress requester. SYNOPSIS @{FG shine}struct@{FG text} Gauge *NewGaugeA(@{FG shine}struct@{FG text} @{"TagItem" LINK "include:utility/tagitem.h/MAIN" 31} *); @{i}@{b}Gauge@{ub}@{ui} = NewGaugeA(@{i}TagList@{ui}) @{FG shine}struct@{FG text} Gauge *NewGauge (Tag @{i}firstTag@{ui},...); @{i}@{b}Gauge@{ub}@{ui} = NewGauge (@{i}Tags@{ui}); @{i}@{b}Gauge@{ub}@{ui} - Pointer to a Gauge structure that represents the progress requester Window and its contents.You should not peek the data this structure holds, but use the @{"GetGaugeA()" LINK "GetGaugeA" 0} function instead. If NewGaugeA() cannot create the progress display, it will return NULL. @{"TAGS" link NEWGAUGEA_TAGS} @{"EXAMPLE" link NEWGAUGEA_EXAMPLE} NOTES Unless you provide a @{"MsgPort" LINK "include:exec/ports.h/MAIN" 27} to be used as the @{"IntuiMessage" LINK "include:intuition/intuition.h/MAIN" 763} arrival port, this function will create one for you.To find out about this port, use @{"GetGaugeA()" LINK "GetGaugeA" 0}. If this function is not told about the Screen it should open the progress requester Window on, it will default to opening the Window on the Default Public Screen.Usually, this will be the Workbench Screen. The gauge Window contains one single button the user can hit if the action the requester represents should be aborted.In this event, an @{i}IDCMP_GADGETUP@{ui} message will be generated.This is the *@{b}only@{ub}* type of event the gauge Window can generate.Thus, when you receive any kind of input from this Window you can be certain that the user wants to stop the work in progress. SEE ALSO intuition.library/OpenWindow, intuition.library/OpenWindowTagList @ENDNODE @node NEWGAUGEA_TAGS "NewGaugeA_tags" @{i}@{b}GAUGE_Window@{ub}@{ui} (@{FG shine}struct@{FG text} @{"Window" LINK "include:intuition/intuition.h/MAIN" 909} *) - The parent Window to "attach" the gauge to. The gauge display will appear on the same Screen as the parent Window, centred within the bounds of the Window. These are the only relations to the "parent" Window. @{i}@{b}GAUGE_Screen@{ub}@{ui} (@{FG shine}struct@{FG text} @{"Screen" LINK "include:intuition/screens.h/MAIN" 132} *) - The Screen to open the gauge on. The gauge will appear centred within the visible part of this Screen. @{i}@{b}GAUGE_PubScreen@{ub}@{ui} (@{FG shine}struct@{FG text} Screen *) - Pointer to a Public Screen the gauge display should be opened on as a Visitor Window.The gauge will appear centred within the visible part of this Screen. @{i}@{b}GAUGE_PubScreenName@{ub}@{ui} (STRPTR) - Name of a Public Screen the gauge display should be opened on as a Visitor Window.If the named Screen cannot be found, the display will default to open on the Default Public Screen.You can control the fall-back behaviour with the @{i}GAUGE_PubScreenFallback@{ui} tag. @{i}@{b}GAUGE_PubScreenFallback@{ub}@{ui} (BOOL) - If the named Public Screen the display is to open on cannot be found, the gauge display will default to open on the Default Public Screen.In most cases, this will be the Workbench Screen. This tag controls whether the fall-back will take place or whether the display will fail to open.@{b}Default@{ub}: TRUE @{i}@{b}GAUGE_UserPort@{ub}@{ui} (@{FG shine}struct@{FG text} @{"MsgPort" LINK "include:exec/ports.h/MAIN" 27} *) - You can have multiple Windows sharing the @{"IntuiMessage" LINK "include:intuition/intuition.h/MAIN" 763} arrival MsgPort.If you want to share some other Window's arrival port with the gauge display, you can specify the port address with this tag. @{i}@{b}GAUGE_ButtonLabel@{ub}@{ui} (STRPTR) - There is one single button in the gauge display, which when hit by the user indicates that whatever action in progress the gauge represents should be brought to a stop.By default, this button bears the label "Stop".You can provide a replacement label, such as for locali- zation, using this tag.@{b}Default@{ub}: "Stop" @{i}@{b}GAUGE_Title@{ub}@{ui} (STRPTR) - The gauge display bears a title which tells about the action in progress the display indicates.This title eventually will become the title of the progress Window.Steps will be taken to make the progress gauge Window large enough to show the complete title.@{b}Default@{ub}: "" @{i}@{b}GAUGE_Fill@{ub}@{ui} (@{FG shine}long@{FG text}) - Progress is shown with a bar that grows from left to right. You specify how far the bar should grow with this tags in percentage, i.e. a value of 0 will show no bar, 50 will show a bar that covers half its maximum size and 100 will produce the complete bar.Any values outside this range will be truncated to the range.@{b}Default@{ub}: 0 @endnode @node NEWGAUGEA_EXAMPLE "NewGaugeA_example" /* Create the progress report Window and wait for the user to * hit the "Stop" button.Make it look like the example in * the "Amiga User Interface Style Guide".*/ @{FG shine}struct@{FG text} Gauge *@{i}gauge@{ui}; @{FG shine}struct@{FG text} @{"MsgPort" LINK "include:exec/ports.h/MAIN" 27} *@{i}port@{ui}; @{i}gauge@{ui} = @{b}NewGauge@{ub}( @{i}GAUGE_Title@{ui}, "@{b}Rendering \"Boing.Ball\"@{ub}", @{i}GAUGE_Fill@{ui}, 40, TAG_END); @{FG shine}if@{FG text}(@{i}gauge@{ui} != NULL) { @{b}GetGauge@{ub}(@{i}&gauge@{ui}, @{i}GAUGE_MsgPort@{ui},@{i}&port@{ui}, TAG_END); WaitPort(@{i}port@{ui}); @{b}DisposeGauge@{ub}(@{i}gauge@{ui}); } @endnode @NODE "SetGaugeA" "gauge/SetGaugeA()" @{b}@{u}SetGaugeA@{uu}@{ub} -- Change the title or the position of the progress indicator of the gauge display. After you have opened the progress requester display, you will want to change the indicator that shows how far the work the requester represents has progressed.Occasionally, the requester title may need changing, too, as work progresses into a different phase. SYNOPSIS @{FG shine}void@{FG text} SetGaugeA(@{FG shine}struct@{FG text} Gauge *Gauge,@{FG shine}struct@{FG text} @{"TagItem" LINK "include:utility/tagitem.h/MAIN" 31} *); SetGaugeA(@{i}Gauge@{ui},@{i}TagList@{ui}) @{FG shine}void@{FG text} SetGauge (@{FG shine}struct@{FG text} Gauge *,...); SetGauge (@{i}Gauge@{ui},@{i}Tags@{ui}); @{i}Gauge@{ui} - Pointer to a Gauge structure as created by @{"NewGaugeA()" LINK "NewGaugeA" 0}. NULL is a valid parameter. @{i}TagList@{ui} - Pointer to a table of TagItem structures. NULL is a valid parameter. @{"TAGS" link SETGAUGEA_TAGS} EXAMPLE /* Set the fill indicator to 70% */ @{b}SetGauge@{ub}(@{i}gauge@{ui}, @{i}GAUGE_Fill@{ui}, 70, TAG_END); SEE ALSO @{"NewGaugeA" LINK "NewGaugeA" 0}, intuition.library/SetAttrsA @ENDNODE @node SETGAUGEA_TAGS "SetGaugeA_tags" @{i}@{b}GAUGE_Title@{ub}@{ui} (STRPTR) - The gauge display bears a title which tell about the action in progress the display indicates.This title eventually will become the title of the progress Window.Steps will be taken to make the progress gauge Window large enough to show the complete title. @{i}@{b}GAUGE_Fill@{ub}@{ui} (@{FG shine}long@{FG text}) - Progress is shown with a bar that grows from left to right. You specify how far the bar should grow with this tags in percentage, i.e. a value of 0 will show no bar, 50 will show a bar that covers half its maximum size and 100 will produce the complete bar.Any values outside this range will be truncated to the range. @endnode @NODE "smartbitmap.image" "smartbitmap.image/smartbitmap.image()" @{b}@{u}smartbitmap.image@{uu}@{ub} -- create image from bitmap (V39). The smartbitmap class provides capability to generate image compatible object with a given @{"BitMap" LINK "graphics/gfx.h/MAIN" 45} structure and palette. Source bitmap can be standard amiga bitmap or CyberGraphX bitmap. When image object is created, source bitmap is converted to destination bitmap which can be planar, chunky or nonpalette (eg.hicolor and truecolor). Palette structure is defined as: @{FG shine}struct@{FG text} SmartBitMapIRGB { ULONG I,R,G,B; }; I - is allocated pen number, if set to -1 image class will allocate it for you. R, G, B - 32 bit color values. @{"TAGS" link SMARTBITMAP_TAGS} SEE ALSO @{"intuition/imageclass.h" LINK "intuition.guide/imageclass.h/MAIN" 0} @ENDNODE @node SMARTBITMAP_TAGS "smartbitmap_tags" @{b}@{u}Applicability is (I):@{uu}@{ub} @{u}IA_Data@{uu} (struct @{"BitMap" LINK "graphics.guide/gfx.h/MAIN" 45} *) @{i}SMBM_BitMap@{ui} (struct @{"BitMap" LINK "graphics.guide/gfx.h/MAIN" 45} *) - Pointer to bitmap. This tag is required.(V39) @{i}SMBM_Border@{ui} (BOOL) - Draw raised border around image. Default for this tag is FALSE.(V39) @{i}SMBM_SelBorder@{ui} (BOOL) - Draw selected border around selected image. Default for this tag is FALSE.(V39) @{i}SMBM_Palette@{ui} (struct SmartBitMapIRGB *) - Palette of bitmap and optionally allocated pens.Only required for pallette based bitmaps.This tag is mutually exclusive with SMBM_Pens. Default for this tag is NULL.(V39). @{u}IA_Pens@{uu} (UWORD *) @{i}SMBM_Screen@{ui} (struct @{"Screen" LINK "intuition.guide/screens.h/MAIN" 132} *) - Screen on which bitmaps will be displayed. This tag is required.(V39) @{i}SMBM_Pens@{ui} (UWORD *) - Table of allocated pens.Only required for palette based bitmaps.This tag is mutually exclusive with SMBM_Palette. Default for this tag is NULL.(V39) @endnode @NODE "GetSmartBitMapClass" "smartbitmap.image/GetSmartBitMapClass()" @{b}@{u}GetSmartBitMapClass@{uu}@{ub} -- get public class of smartbitmap (V39). Obtains pointer to smartbitmap.image class for use with intuition.library/NewObject(). SYNOPSIS @{FG shine}Class@{FG text} *GetSmartBitMapClass( @{FG shine}void@{FG text} ); @{b}@{i}smartbitmap_class@{ui}@{ub} = GetSmartBitMapClass(); D0 @{b}@{i}smartbitmap_class@{ui}@{ub} - pointer to smartbitmap class @ENDNODE @NODE "GetListViewClass" "listview.gadget/GetListViewClass()" @{b}@{u}GetListViewClass@{uu}@{ub} -- creates listview class (V37). Obtains pointer to listview.gadget class for use with intuition.library/NewObject().Call this function only at start of program. SYNOPSIS @{FG shine}Class@{FG text} *GetListViewClass( @{FG shine}void@{FG text} ); @{b}@{i}listview_class@{ui}@{ub} = GetListViewClass(); D0 @{b}@{i}listview_class@{ui}@{ub} - pointer to listview class @ENDNODE @NODE "listview.gadget" "listview.gadget/listview.gadget()" @{b}@{u}listview.gadget@{uu}@{ub} -- create enchanced listview gadget (V37). The listview class provides capability to create tree and multi column lists and show them in BOOPSI listview gadget.Tree lists are similiar to standard exec lists, but some changes has been made.You can use them on standard listview gadget but then you can't use all features of tree nodes.To browse through tree list you should use @{"Tree_NextNode()" LINK "Tree_NextNode" 0}.This function can easly give you next open node in tree (hidden nodes are NOT processed!).If you want browse thru all nodes do it as in standard lists but you must check for parent nodes (leafs are terminated by pointer to parent node).Tree node looks like this: @{FG shine}struct@{FG text} LVNode { @{FG shine}struct@{FG text} LVNode *ln_Succ; // Pointer to next node in the list. // If this is last node in the leaf it points // to the parent node, otherwise it points to // lh_Tail in list structure. @{FG shine}struct@{FG text} LVNode *ln_Pred; // Pointer to previous node in the list. // If this is first node in tree it points to the // parent node, otherwise it points to NULL UWORD ln_Flags; // Flags of the node.LV_SELECT is set if node // is selected.LV_OPEN is set if leaf is open. STRPTR ln_Name; // Pointer to NULL terminated string.In // multicolumn lists collumns are separated // by special character defined in NewObject(). @{FG shine}struct@{FG text} LVNode *ln_Sub; // Pointer to sub node in the list. // NULL if there are no sub nodes. @{FG shine}struct@{FG text} LVNode *ln_Parent; // Pointer to parent node. // NULL if there is no parent nodes UBYTE ln_Indent; // Private! Don't change.This is indent of sub nodes. }; Why tree node linking is so strange? And why I simply don't use list structures for sub nodes? It's easy to understand.Creating for every leaf new list is hard to make, you need a lot of NewList() initializations. Also, when entering to leafs you must remember parent node.With this style of lists you can browse tree list likenormal lists (you can indicate a new leaf by checking ln_Indent field), it's faster and easier to make such lists. Unfortunately you need a new functions for list management.Root list is compatiblewith exec list, but use Tree_#?() functions instead. You can also use a functions designed for sub nodes on root list. ln_Name and LIST_Format strings have basic support of formatting: ESCc - center, ESCl - left, ESCr - right, ESC - pen number (only 0 to 9), ESCp - plain, ESCb - bold, ESCi - italic, ESCu - underline. @{"TAGS" link LISTVIEW_TAGS} SEE ALSO gadgets/listview.h @ENDNODE @node LISTVIEW_TAGS "listview_tags" @{b}@{u}Applicability is (IS):@{uu}@{ub} @{i}LIST_Labels@{ui} (struct LVList *) - Pointer to the list of nodes. Don't try to supply standard lists.Default for this tag is NULL.(V37) @{b}@{u}Applicability is (I):@{uu}@{ub} @{i}LIST_TabChar@{ui} (STRPTR) - Character used to separate columns. Default for this tag is '\t'.(V37) @{i}LIST_Format@{ui} (STRPTR) - Pointer to titles of columns.Titles are separated by '|' character.Set to NULL if you don't want titles.Strings can be formatted. Default for this tag is NULL.(V37) @{i}LIST_Columns@{ui} (ULONG) - Number of columns in listview gadget. Default for this tag is 1.(V37) @{i}LIST_TextFont@{ui} (struct @{"TextFont" LINK "graphics/text.h/MAIN" 88} *) - Font used for rendering all texts. Default for this tag is NULL.(V37) @{i}LIST_ReadOnly@{ui} (BOOL) - Make listview gadget read only. Default for this tag is FALSE.(V37) @{i}LIST_Border@{ui} (BOOL) - Set it to FALSE if you don't want a border around listview gadget.Default for this tag is TRUE.(V37) @{b}@{u}Applicability is (G):@{uu}@{ub} @{i}LIST_Selected@{ui} (struct LVNode *) - Returns pointer to currently selected node in the list.In multiselect lists use LV_SELECT flag in ln_Flags field instead. Default for this tag is NULL.(V37) @{i}LIST_Visible@{ui} (ULONG) - Number of visible lines.(V37) @{i}LIST_Total@{ui} (ULONG) - Number of all open nodes in the list.(V37) @{b}@{u}Applicability is (IG):@{uu}@{ub} @{i}LIST_ShowTreeLines@{ui} (BOOL) - If you want lines in tree gadget set it to TRUE. Default for this tag is FALSE.(V37) @{i}LIST_IsTree@{ui} (BOOL) - You must set this to TRUE if you use tree lists.(V37) @{b}@{u}Applicability is (ISG):@{uu}@{ub} @{i}LIST_Top@{ui} (ULONG) - Number of top shown node. Default for this tag is 0.(V37) @{i}LIST_HookSub@{ui} (struct @{"Hook" LINK "utility/hooks.h/MAIN" 27} *) - Callback routine called when leaf is opened (TLV_OPENSUB, TLVSubMsg) or closed (TLV_CLOSESUB, TLVSubMsg). You can use this callback to use dynamicly generated trees like directory list. Remember: sub nodes must have at least one node (make dummy node for this). Callback must return TLVCB_OK when message was processed.(V37) @{i}LIST_HookDraw@{ui} (struct @{"Hook" LINK "utility/hooks.h/MAIN" 27} *) - Callback routine called when node is rendered (TLV_DRAW, TLVDrawmsg).Callback must return TLVCB_OK when message was processed.(V37) @{i}LIST_HookEdit@{ui} (struct @{"Hook" LINK "utility/hooks.h/MAIN" 27} *) - Callback routine called when node is going to be edited and when was edited.First TLV_DOEDIT (TLVEditMsg) method is called, you must check tlvm_Column field end tell to listview that you want to edit this column or not.Return TLVCB_OK to not edit column or TLVCB_UNKNOWN to edit column.After the node was edited TLV_EDIT method is called.You need to manually replace tlvm_Node->ln_Name with new string in tlvm_String adding strings from other columns.Callback must return TLVCB_OK when message was processed. Setting this hook makes listview editable by user. Edit string gadget is created and added at the end of list of all gadgets. So, use it carefully because you can remove listview from window but string can stay in the list of gadgets (it's only invisible for you).String is removed and disposed when listview is disposed.(V37) @{i}LIST_ColumnsPos@{ui} (UWORD *) - Table of column positions.Column 0 has position always equal to 0 and last column always equal to width of gadget. Two columned listview has three positions.(V37) @endnode @NODE "Tree_AddHead" "listview.gadget/Tree_AddHead()" @{b}@{u}Tree_AddHead@{uu}@{ub} -- insert node at the head of a list (V37). Add a node to the head of a doubly linked list. SYNOPSIS @{FG shine}void@{FG text} Tree_AddHead(@{FG shine}struct@{FG text} LVList *,@{FG shine}struct@{FG text} LVNode *); Tree_AddHead(@{i}list@{ui},@{i}node@{ui}); A0 A1 @{i}list@{ui} - a pointer to list to the target list header @{i}node@{ui} - the node to insert at head SEE ALSO @{"Tree_AddTail" LINK "Tree_AddTail" 0}, @{"Tree_Insert" LINK "Tree_Insert" 0}, @{"Tree_Remove" LINK "Tree_Remove" 0}, @{"Tree_RemHead" LINK "Tree_RemHead" 0}, @{"Tree_RemTail" LINK "Tree_RemTail" 0} @ENDNODE @NODE "Tree_AddSubHead" "listview.gadget/Tree_AddSubHead()" @{b}@{u}Tree_AddSubHead@{uu}@{ub} -- insert node at the head of a sub list (V37). Add a node to the head of a sub list. SYNOPSIS @{FG shine}void@{FG text} Tree_AddSubHead(@{FG shine}struct@{FG text} LVList *,@{FG shine}struct@{FG text} LVNode *,@{FG shine}struct@{FG text} LVNode *); Tree_AddSubHead(@{i}list@{ui},@{i}parent@{ui},@{i}node@{ui}); A0 A1 A2 @{i}list@{ui} - a pointer to list to the target list header @{i}parent@{ui} - a parent node of the sub list to insert the node to.May be NULL. @{i}node@{ui} - the node to insert at head SEE ALSO @{"Tree_AddSubTail" LINK "Tree_AddSubTail" 0}, @{"Tree_Insert" LINK "Tree_Insert" 0}, @{"Tree_Remove" LINK "Tree_Remove" 0}, @{"Tree_RemSubHead" LINK "Tree_RemSubHead" 0}, @{"Tree_RemSubTail" LINK "Tree_RemSubTail" 0} @ENDNODE @NODE "Tree_AddSubTail" "listview.gadget/Tree_AddSubTail()" @{b}@{u}Tree_AddSubTail@{uu}@{ub} -- append node to tail of a sub list (V37). Add a node to the tail of a sub list. SYNOPSIS @{FG shine}void@{FG text} Tree_AddSubTail(@{FG shine}struct@{FG text} LVList *,@{FG shine}struct@{FG text} LVNode *,@{FG shine}struct@{FG text} LVNode *); Tree_AddSubTail(@{i}list@{ui},@{i}parent@{ui},@{i}node@{ui}); A0 A1 A2 @{i}list@{ui} - a pointer to the target list header @{i}parent@{ui} - a parent node of the sub list to append the node to.May be NULL. @{i}node@{ui} - a pointer to the node to insert at tail of the sub list SEE ALSO @{"Tree_AddSubHead" LINK "Tree_AddSubHead" 0}, @{"Tree_Insert" LINK "Tree_Insert" 0}, @{"Tree_Remove" LINK "Tree_Remove" 0}, @{"Tree_RemSubHead" LINK "Tree_RemSubHead" 0}, @{"Tree_RemSubTail" LINK "Tree_RemSubTail" 0} @ENDNODE @NODE "Tree_AddTail" "listview.gadget/Tree_AddTail()" @{b}@{u}Tree_AddTail@{uu}@{ub} -- append node to tail of a list (V37). Add a node to the tail of a doubly linked list. SYNOPSIS @{FG shine}void@{FG text} Tree_AddTail(@{FG shine}struct@{FG text} LVList *,@{FG shine}struct@{FG text} LVNode *); Tree_AddTail(@{i}list@{ui},@{i}node@{ui}); A0 A1 @{i}list@{ui} - a pointer to the target list header @{i}node@{ui} - a pointer to the node to inser at tail of the list SEE ALSO @{"Tree_AddHead" LINK "Tree_AddHead" 0}, @{"Tree_Insert" LINK "Tree_Insert" 0}, @{"Tree_Remove" LINK "Tree_Remove" 0}, @{"Tree_RemHead" LINK "Tree_RemHead" 0}, @{"Tree_RemTail" LINK "Tree_RemTail" 0} @ENDNODE @NODE "Tree_Insert" "listview.gadget/Tree_Insert()" @{b}@{u}Tree_Insert@{uu}@{ub} -- insert a node into a list or sub list (V37). Insert a node into a double linked list AFTER a given node position. Insertion at the head of a list is possible by passing a zero value for listNode, though the AddHead function is slightly faster for that special case. SYNOPSIS @{FG shine}void@{FG text} Tree_Insert(@{FG shine}struct@{FG text} LVList *, @{FG shine}struct@{FG text} LVNode *, @{FG shine}struct@{FG text} LVNode *); Tree_Insert(@{i}list@{ui}, @{i}node@{ui}, @{i}listNode@{ui}) A0 A1 A2 @{i}list@{ui} - a pointer to the target list header @{i}node@{ui} - the node to insert @{i}listNode@{ui} - the node after which to insert SEE ALSO @{"Tree_AddHead" LINK "Tree_AddHead" 0}, @{"Tree_AddSubHead" LINK "Tree_AddSubHead" 0}, @{"Tree_AddSubTail" LINK "Tree_AddSubTail" 0}, @{"Tree_AddTail" LINK "Tree_AddTail" 0}, @{"Tree_RemHead" LINK "Tree_RemHead" 0}, @{"Tree_RemSubHead" LINK "Tree_RemSubHead" 0}, @{"Tree_RemSubTail" LINK "Tree_RemSubTail" 0}, @{"Tree_Remove" LINK "Tree_Remove" 0}, @{"Tree_RemTail" LINK "Tree_RemTail" 0} @ENDNODE @NODE "Tree_NewList" "listview.gadget/Tree_NewList()" @{b}@{u}Tree_NewList@{uu}@{ub} -- initialize list for use (V37). Initializes list structure to use. SYNOPSIS @{FG shine}void@{FG text} Tree_NewList(@{FG shine}struct@{FG text} LVList *); Tree_NewList(@{i}list@{ui}) A0 @{i}list@{ui} - a pointer to the list @ENDNODE @NODE "Tree_NextNode" "listview.gadget/Tree_NextNode()" @{b}@{u}Tree_NextNode@{uu}@{ub} -- get pointer to next node (V37). Returns pointer to next node in the list.If node is open it will enter in it and process sub nodes otherwise sub nodes will be skipped. You can simply process all open nodes using for() instruction: @{FG shine}for@{FG text}(@{i}node@{ui}=list.lh_Head;Tree_NextNode(@{i}node@{ui});@{i}node@{ui}=Tree_NextNode(@{i}node@{ui})) { // do here something with node } SYNOPSIS @{FG shine}struct@{FG text} LVNode *Tree_NextNode(@{FG shine}struct@{FG text} LVNode *); @{b}@{i}nextnode@{ui}@{ub} = Tree_NextNode(@{i}node@{ui}) D0 A0 @{i}node@{ui} - a pointer to the node @{b}@{i}nextnode@{ui}@{ub} - a pointer to the next node or NULL if there is no more nodes. SEE ALSO @{"Tree_NextSubNode" LINK "Tree_NextSubNode" 0} @ENDNODE @NODE "Tree_NextSubNode" "listview.gadget/Tree_NextSubNode()" @{b}@{u}Tree_NextSubNode@{uu}@{ub} -- get pointer to next node or sub node (V37). Returns pointer to next node in the list. You can simply process all nodes using for() instruction: @{FG shine}for@{FG text}(@{i}node@{ui}=list.lh_Head;Tree_NextSubNode(@{i}node@{ui});@{i}node@{ui}=Tree_NextSubNode(@{i}node@{ui})) { // do here something with node } SYNOPSIS @{FG shine}struct@{FG text} LVNode *Tree_NextSubNode(@{FG shine}struct@{FG text} LVNode *); @{b}@{i}nextnode@{ui}@{ub} = Tree_NextSubNode(@{i}node@{ui}); D0 A0 @{i}node@{ui} - a pointer to the node @{b}@{i}nextnode@{ui}@{ub} - a pointer to the next node or NULL if there is no more nodes SEE ALSO @{"Tree_NextNode" LINK "Tree_NextNode" 0} @ENDNODE @NODE "Tree_RemHead" "listview.gadget/Tree_RemHead()" @{b}@{u}Tree_RemHead@{uu}@{ub} -- remove the head node from a list (V37). Get a pointer to the head node and remove it from the list. SYNOPSIS @{FG shine}struct@{FG text} LVNode *Tree_RemHead(@{FG shine}struct@{FG text} LVList *); @{b}@{i}node@{ui}@{ub} = Tree_RemHead(@{i}list@{ui}); D0 A0 @{i}list@{ui} - a pointer to the target list header @{b}@{i}node@{ui}@{ub} - the node removed or zero when empty list SEE ALSO @{"Tree_AddHead" LINK "Tree_AddHead" 0}, @{"Tree_AddTail" LINK "Tree_AddTail" 0}, @{"Tree_Insert" LINK "Tree_Insert" 0}, @{"Tree_Remove" LINK "Tree_Remove" 0}, @{"Tree_RemTail" LINK "Tree_RemTail" 0} @ENDNODE @NODE "Tree_Remove" "listview.gadget/Tree_Remove()" @{b}@{u}Tree_Remove@{uu}@{ub} -- remove a node from a list (V37). Unlink a node with all sub nodes whatever list it is in. Nodes that are not part of a list must not be passed to this function! SYNOPSIS @{FG shine}void@{FG text} Tree_Remove(@{FG shine}struct@{FG text} LVNode *); Tree_Remove(@{i}node@{ui}) A0 @{i}node@{ui} - the node to remove SEE ALSO @{"Tree_AddHead" LINK "Tree_AddHead" 0}, @{"Tree_AddTail" LINK "Tree_AddTail" 0}, @{"Tree_Insert" LINK "Tree_Insert" 0}, @{"Tree_RemHead" LINK "Tree_RemHead" 0}, @{"Tree_RemTail" LINK "Tree_RemTail" 0} @ENDNODE @NODE "Tree_RemSubHead" "listview.gadget/Tree_RemSubHead()" @{b}@{u}Tree_RemSubHead@{uu}@{ub} -- remove the head node from a sub list (V37). Get a pointer to the head sub node and remove it from the list. SYNOPSIS @{FG shine}struct@{FG text} LVNode *Tree_RemSubHead(@{FG shine}struct@{FG text} LVNode *); @{b}@{i}node@{ui}@{ub} = Tree_RemSubHead(@{i}node@{ui}) D0 A0 @{i}node@{ui} - a pointer to the target node header @{b}@{i}node@{ui}@{ub} - the node removed or zero when empty list SEE ALSO @{"Tree_AddSubHead" LINK "Tree_AddSubHead" 0}, @{"Tree_AddSubTail" LINK "Tree_AddSubTail" 0}, @{"Tree_Insert" LINK "Tree_Insert" 0}, @{"Tree_Remove" LINK "Tree_Remove" 0}, @{"Tree_RemSubTail" LINK "Tree_RemSubTail" 0} @ENDNODE @NODE "Tree_RemSubTail" "listview.gadget/Tree_RemSubTail()" @{b}@{u}Tree_RemSubTail@{uu}@{ub} -- remove the tail node from a sub list (V37). Get a pointer to the tail sub node and remove it from the list. SYNOPSIS @{FG shine}struct@{FG text} LVNode *Tree_RemSubTail(@{FG shine}struct@{FG text} LVNode *); @{b}@{i}node@{ui}@{ub} = Tree_RemSubTail(@{i}node@{ui}) D0 A0 @{i}node@{ui} - a pointer to the target node header @{b}@{i}node@{ui}@{ub} - the node removed or zero when empty list SEE ALSO @{"Tree_AddSubHead" LINK "Tree_AddSubHead" 0}, @{"Tree_AddSubTail" LINK "Tree_AddSubTail" 0}, @{"Tree_Insert" LINK "Tree_Insert" 0}, @{"Tree_Remove" LINK "Tree_Remove" 0}, @{"Tree_RemSubHead" LINK "Tree_RemSubHead" 0} @ENDNODE @NODE "Tree_RemTail" "listview.gadget/Tree_RemTail()" @{b}@{u}Tree_RemTail@{uu}@{ub} -- remove the tail node from a list (V37). Get a pointer to the tail node and remove it from the list. SYNOPSIS @{FG shine}struct@{FG text} LVNode *Tree_RemTail(@{FG shine}struct@{FG text} LVList *); @{i}@{b}node@{ub}@{ui} = Tree_RemTail(@{i}list@{ui}) D0 A0 @{i}list@{ui} - a pointer to the target list header @{b}@{i}node@{ui}@{ub} - the node removed or zero when empty list SEE ALSO @{"Tree_AddHead" LINK "Tree_AddHead" 0}, @{"Tree_AddTail" LINK "Tree_AddTail" 0}, @{"Tree_Insert" LINK "Tree_Insert" 0}, @{"Tree_Remove" LINK "Tree_Remove" 0}, @{"Tree_RemHead" LINK "Tree_RemHead" 0} @ENDNODE @node PROGRESS_TAGS "progress_tags" @{b}@{u}Applicability is (ISG):@{uu}@{ub} @{i}PROG_Placement@{ui} (ULONG) - Sets placement of text set by PROG_Format. Available values are: PLACETEXT_#? (IN, ABOVE, BELOW, LEFT,RIGHT). Default for this tag is PLACETEXT_IN. @{i}PROG_Border@{ui} (BOOL) - Set to TRUE if you want bevelled box around gadget. Default for this tag is TRUE. @{i}PROG_MaxVal@{ui} (ULONG) - Sets/Gets maximum available value. Default for this tag is 100. @{i}PROG_ConvertToPercents@{ui} (BOOL) - If set to true all values rendered in gadget will be converted to percents.Default for this tag is TRUE. @{i}PROG_Format@{ui} (STRPTR) - Sets format of text rendering. Default for this tag is "%d". @{b}@{u}Applicability is (IG):@{uu}@{ub} @{i}PROG_TextFont@{ui} (struct @{"TextFont" LINK "graphics.guide/text.h/MAIN" 88} *) - Sets/Gets font used for text rendering.Default for this tag is current font. @{b}@{u}Applicability is (ISGNU):@{uu}@{ub} @{i}PROG_CurVal@{ui} (ULONG) - Sets/Gets current value. Default for this tag is 0. @endnode @NODE "progress.gadget" "progress.gadget/progress.gadget()" @{b}@{u}progress.gadget@{uu}@{ub} -- create standard progress indicator gadget (V36). This class provides ability to create standarized progress gadget. With this class you can easily show how many was done of current work. You can set any number of maximum value for this gadget.Progress.gadget provides for you ability to convert current values to number of percents (eg: copied file is 4500 bytes long, so when copying it you can show user what percent of file was copied, instead of current bytes copied). @{"TAGS" link PROGRESS_TAGS} @ENDNODE @NODE "GetProgressClass" "progress.gadget/GetProgressClass()" @{b}@{u}GetProgressClass@{uu}@{ub} -- get base class of gadget (V36). Retrives base address of class to use later with intuition.library/NewObject(). SYNOPSIS @{FG shine}Class@{FG text} *GetProgressClass( @{FG shine}void@{FG text} ); @{b}@{i}class@{ui}@{ub} = GetProgressClass() D0 A boopsi class which can be used to use with NewObject(). SEE ALSO intuition.library/NewObject(). @ENDNODE @node WHEEL_HSB "wheel_HSB" Set and get the hue, saturation, and brightness components of a color wheel. This is a buik version of the separate WHEEL_Hue, WHEEL_Saturation, and WHEEL_Brightness tags. When setting this tag, initialize a ColorWheelHSB structure, and provide a pointer to it.When getting this tag, pass a pointer to a ColorWheelHSB structure, and the color wheel object will fill it in with the current values. Default for this tag is a hue of 0, a saturation of $FFFFFFFF, and a brightness of $FFFFFFFF.(V39) @endnode @node WHEEL_RGB "wheel_RGB" Set and get the red, green,and brightness components of a color wheel. This is a buik version of the separate WHEEL_Red, WHEEL_Green, and WHEEL_Blue tags. When setting this tag, initialize a ColorWheelRGB structure, and provide a pointer to it.When getting this tag, pass a pointer to a ColorWheelRGB structure, and the color wheel object will fill it in with the current values. Default for this tag is a red of $FFFFFFFF, a green of 0, and a blue of 0.(V39) @endnode @node WHEEL_BRIGHTNESS "wheel_brightness" Set and get the brightness component of a color wheel. The color wheel does not itself have any means of displaying or editing brightness,but it does maintain this value internally. Used with WHEEL_GradientSlider, this tag lets you control the value of a gradient slider object by passing WHEEL_Brightness to a color heel. A brightness value of 0 means all black. Increasing the value progressively brightens the current color, until the value $FFFFFFFF is reached, in which case the color is as bright as it gets. If you are setting or getting more than one color component at a time, it is more efficient to use the WHEEL_HSB tag. Default for this tag is $FFFFFFFF.(V39) @endnode @node WHEEL_HUE "wheel_hue" Set and get the hue component of a color wheel. This is effectively the angle around the wheel where the desired color lies. If the wheel is currently displayed, the position of the selection knob will be moved to reflect the new hue. A hue value of 0 is all red, and nothing but red. Increasing the value moves the color towards all green at $55555555, full blue at $AAAAAAAA, and back to red at $FFFFFFFF. If you are setting or getting more than one color component at a time, it is more efficient to use the WHEEL_HSB tag. Default for this tag is 0.(V39) @endnode @node WHEEL_SATURATION "wheel_saturation" Set and get the saturation component of a color wheel. This is effectively the distance from the center of the wheel where the desired color lies. If the wheel is currently displayed, the position of the selection knob will be moved to reflect the new saturation. A saturation value of 0 puts the knob at the center of the wheel and always yields white. Increasing the value progressively moves the knob farther awayfrom the center,until the value $FFFFFFFF is reached in which case the knob is as far as it can go. If you are setting or getting more than one color component at a time, it is more efficient to use the WHEEL_HSB tag. Default for this tag is $FFFFFFFF.(V39) @endnode @node WHEEL_RED "wheel_red" Set and get the red component of a color wheel. If the wheel is currently displayed, the position of the selection knob will be moved to reflect the new amount of red. If you are setting or getting more than one color component at a time, it is more efficient to use the WHEEL_RGB tag. Default for this tag is $FFFFFFFF.(V39) @endnode @node WHEEL_GREEN "wheel_green" Set and get the green component of a color wheel. If the wheel is currently displayed, the position of the selection knob will be moved to reflect the new amount of green. If you are setting or getting more than one color component at a time, it is more efficient to use the WHEEL_RGB tag. Default for this tag is 0.(V39) @endnode @node WHEEL_BLUE "wheel_blue" Set and get the blue component of a color wheel. If the wheel is currently displayed, the position of the selection knob will be moved to reflect the new amount of blue. If you are setting or getting more than one color component at a time, it is more efficient to use the WHEEL_RGB tag. Default for this tag is 0.(V39) @endnode @node WHEEL_ABBRV "wheel_abbrv" When the color wheel is rendered on a display which doesn't have enough colors to allow it to draw itself in color, it automatically renders itself in monochrome instead. In such a case, the various color segments are identified by six letters G=Green, C=Cyan, B=Blue, M=Magenta, R=Red, and Y=Yellow. You can provide a replacement set of six letters. This is meant for localization of the wheel. Default for this tag is "GCBMRY".(V39) @endnode @node WHEEL_DONATION "wheel_donation" Specifies an array of pens donated by the application for use by the color wheel. The array can contain any number of pens, and is terminated with a pen value of ~0. The wheel will change the RGB values of these pens to suit its needs, so be prepared for this.This means the pens should likely be allocated using the PENF_EXCLUSIVE option of the graphics.library/ObtainPen() function. Default for this tag is NULL.(V39) @endnode @node WHEEL_GRADIENTSLIDER "wheel_gradientslider" This tag lets you do simple linking of a gradient slider object to a color wheel object. You give this tag a pointer to a gradient slider object obtained previously from @{"NewObject()" Link "intuition.guide/NewObject()"}.Once this is done,anytime the various tags that can affect the brightness component of the current color is sent to the color wheel,the color wheel automatically changes the value of the attached gradient slider to match that new brightness value. Reading the brightness value from the color wheel returns the current value indicated by the gradient slider. Using this tag effectively allows you to treat the color wheel and gradient slider as a single gadget.Once things are set up, all communications occur through the wheel object, and the gradient slider can pretty much be ignored by the application. Default for this tag is NULL.(V39) @endnode @node COLORWHEEL_TAGS "colorwheel_tags" @{b}@{u}Applicability is (ISGU):@{uu}@{ub} @{"WHEEL_HSB" link WHEEL_HSB} (struct ColorWheelHSB *) @{"WHEEL_RGB" link WHEEL_RGB} (struct ColorWheelRGB *) @{"WHEEL_Brightness" link WHEEL_BRIGHTNESS} (ULONG) @{b}@{u}Applicability is (ISGNU):@{uu}@{ub} @{i}GA_ID@{ui} (UWORD) - Specify the gadget ID of a color wheel object.(V39) @{"WHEEL_Hue" link WHEEL_HUE} (ULONG) @{"WHEEL_Saturation" link WHEEL_SATURATION} (ULONG) @{"WHEEL_Red" link WHEEL_RED} (ULONG) @{"WHEEL_Green" link WHEEL_GREEN} (ULONG) @{"WHEEL_Blue" link WHEEL_BLUE} (ULONG) @{b}@{u}Applicability is (I):@{uu}@{ub} @{i}WHEEL_Screen@{ui} (struct @{"Screen" Link "include:intuition/screens.h/Main" 97} *) - Indicate the screen the color wheel is to open on.This is a required tag and must be provided when the wheel is created via @{"NewObject()" Link "intuition.guide/NewObject()"}.(V39) @{"WHEEL_Abbrv" link WHEEL_ABBRV} (STRPTR) @{"WHEEL_Donation" link WHEEL_DONATION} (UWORD *) @{i}WHEEL_BevelBox@{ui} (BOOL) - Set to TRUE if you want a raised bevelled box to be drawn around the wheel. Default for this tag is FALSE.(V39) @{i}WHEEL_MaxPens@{ui} (ULONG) - Indicate the maximum number of shared color pens the wheel should attempt to allocate.This tag is useful if you wish to minimize the impact the wheel can have on your screen's pens. Default for this tag is 256.(V39) @{b}@{u}Applicability is (IS):@{uu}@{ub} @{"WHEEL_GradientSlider" link WHEEL_GRADIENTSLIDER} (struct @{"Gadget" Link "include:intuition/intuition.h/Main" 215} *) @endnode @Node "colorwheel.gadget()" "colorwheel.gadget/colorwheel.gadget" @{b}@{u}colorwheel.gadget@{uu}@{ub} -- create standard HSB color wheel BOOPSI objects (V39). The color wheel class provides the ability to create gadgets enabling the user to control the hue and saturation components of an HSB (Hue-Saturation-Brightness) color space.The companion gradient slider class enables control of the brightness component of the color space. The color wheel can operate on screens of any depth, and adapts its rendering to the number of colors available.The system's pen sharing mechanism is used in order to maximize the number of colors used by the wheel.A color wheel gadget is (normally) responsible for choosing it's own color pens to draw in (using graphics.library/ObtainBestPen()).However, the creator of the gadget can "donate" some pens to the gadget, using the WHEEL_Donation tag. The reason that the color wheel picks its own colors is because it has the ability to display several different layouts depending on the number and variety of colors available.For example, when opening on a screen of low depth or when opening on a screen where all the pens have already been allocated exclusively, the gadget will display a "monochrome" version of the color wheel, where instead ofcolored segments, the letters "R" (for red), "G" (for green), "B" (for blue), "Y" (for yellow), "C" (for cyan) and "M" (for magenta) will be used as labels. You can talk to the color wheel using HSB or RGB, even though the color wheel only really deals with HSB in its user-interface.All communications with applications are performed with full 32-bit color component values. @{"TAGS" link COLORWHEEL_TAGS} WARNING Once a color wheel has been created on a given screen, the wheel object must be deleted using @{"DisposeObject()" Link "intuition.guide/DisposeObject()"} prior to closing the screen.This is because the wheel object allocates pens on the screen. BUGS Even though all communication with the color wheel is done using full 32-bit color components, color calculations are currently done using 16-bit math, which can cause certain rounding errors to appear. Prior to V40, the WHEEL_Red, WHEEL_Green, and WHEEL_Blue tags did not return the correct values when a gradient slider is linked with the color wheel using the WHEEL_GradientSlider tag.The workaround is to always use the WHEEL_RGB tag, and just extract the values from there. @EndNode @Node "ConvertHSBToRGB()" "colorwheel.gadget/ConvertHSBToRGB" @{b}@{u}ConvertHSBToRGB@{uu}@{ub} -- convert from an HSB color space to an RGB color space.(V39) Converts a color from an HSB representation to an RGB representation. SYNOPSIS @{FG shine}void@{FG text} ConvertHSBToRGB(@{FG shine}struct@{FG text} ColorWheelHSB *, @{FG shine}struct@{FG text} ColorWheelRGB *); ConvertHSBToRGB(@{i}hsb@{ui}, @{i}rgb@{ui}); A0 A1 @{i}hsb@{ui} - filled-in ColorWheelHSB structure containing the values to convert @{i}rgb@{ui} - structure to receive the converted values BUGS Even though all communication with the color wheel is done using full 32-bit color components, color calculations are currently done using 16-bit math, which can cause certain rounding errors to appear. @EndNode @Node "ConvertRGBToHSB()" "colorwheel.gadget/ConvertRGBToHSB" @{b}@{u}ConvertRGBToHSB@{uu}@{ub} -- convert from an RGB color space to an HSB color space.(V39) Converts a color from an RGB representation to an HSB representation. SYNOPSIS @{FG shine}void@{FG text} ConvertRGBToHSB(@{FG shine}struct@{FG text} ColorWheelRGB *, @{FG shine}struct@{FG text} ColorWheelHSB *); ConvertRGBToHSB(@{i}rgb@{ui}, @{i}hsb@{ui}); A0 A1 @{i}rgb@{ui} - filled-in ColorWheelRGB structure containing the values to convert @{i}hsb@{ui} - structure to receive the converted values BUGS Even though all communication with the color wheel is done using full 32-bit color components, color calculations are currently done using 16-bit math, which can cause certain rounding errors to appear. @EndNode @node GRADIENTSLIDER_TAGS "gradientslider_tags" @{b}@{u}Applicability is (I):@{uu}@{ub} @{i}GRAD_KnobPixels@{ui} (UWORD) - Set the size of the knob in pixels. Default for this tag is 5.(V39) @{i}PGA_FREEDOM@{ui} (ULONG) - Determines the orientation of the slider.This can be LORIENT_HORIZ for a horizontal slider, or LORIENT_VERT for a vertical one.Default for this tag is LORIENT_HORIZ.(V39) @{b}@{u}Applicability is (ISU):@{uu}@{ub} @{i}GRAD_PenArray@{ui} (UWORD *) - Specifies an array of pens that the slider should use to create its gradient background.The array can contain any number of pens, and is terminated with a pen value of ~0.These pens can be allocated as shared, since their RGB value is not altered by the slider.The first pen is used on the top or left of the slider, and the last pen is used on the bottom or right. All other pens are evenly spacedout and used in between.Dithering is used between the pens to enhance the smoothness of the gradient transition. A NULL pen array causes the background of the slider to be rendered in the screen's background color.A pen array containing only a single pen causes the background to be rendered using that pen. Default for this tag is NULL.(V39) @{b}@{u}Applicability is (ISGU):@{uu}@{ub} @{i}GRAD_SkipVal@{ui} (ULONG) - Set the amount by which the slider should advance whenever the user clicks on either side of the knob. Default for this tag is $1111.(V39) @{i}GRAD_MaxVal@{ui} (ULONG) - Set the maximum value that the slider can represent, in the range 0..$FFFF.Default for this tag is $FFFF.(V39) @{b}@{u}Applicability is (ISGNU):@{uu}@{ub} @{i}GRAD_CurVal@{ui} (ULONG) - Set or get the current value of the slider, in the range 0..$FFFF.Default for this tag is 0.(V39) @endnode @Node "gradientslider.gadget()" "gradientslider.gadget/gradientslider.gadgetlider.gadget/gradientslider.gadget" @{b}@{u}gradientslider.gadget@{uu}@{ub} -- create a slider with a range of colors as its background.(V39) The gradientslider gadget class is a type of non-proportional slider. The primary feature of the gradient slider is it's appearance.Unlike normal sliders, a gradient slider can display a "spread of colors" or "color gradient" in the slider container box.The "knob" or "thumb" of the slider appears to slide on top of this color gradient. The color gradient effect is built-up using a combination of multiple pens and half-tone dithering.The application must tell the slider exactly which pens to use in creating the gradient effect, and in what order to use them.Essentially, it does this by passing an array of pens (terminated by ~0, just like a PenSpec) to the slider. The first pen in the array is used as the color at the top of the slider (or left, if it is horizontal), and the last color in the array is used at the bottom (or right).The other pens will be used at evenly spaced intervals in between.Dithering is used to smoothly fade between the pens, allowing the illusion of a continuous change in color. @{"TAGS" link GRADIENTSLIDER_TAGS} @EndNode @node AG_METHODS "ag_ methods" OM_NEW -- Create a new AmigaGuide object. OM_SET -- Set the values of multiple attributes. OM_GET -- Obtain the value of an attribute. OM_UPDATE -- Update the values of multiple attributes. GM_RENDER -- Cause the AmigaGuide database to render. GM_LAYOUT -- Layout the object and notify the application of the title and size. GM_HITTEST -- Determine if the object has been hit with the mouse. GM_GOACTIVE -- Tell the object to go active. GM_HANDLEINPUT -- Handle input. OM_DISPOSE -- Dispose of an AmigaGuide object. DTM_GOTO -- Cause the AmigaGuide database to load and display document. DTM_FRAMEBOX -- Obtain the display environment that the AmigaGuide database requires. DTM_PROCLAYOUT -- Layout (remap) the AmigaGuide database on the application's process. DTM_TRIGGER -- Trigger an event. STM_COMMAND - Invoke an AmigaGuide command. STM_CONTENTS - Display the table of contents. STM_INDEX - Display the index. STM_HELP - Display the help file. STM_RETRACE - Retrace. STM_BROWSE_PREV - Go to the previous sequential document. STM_BROWSE_NEXT - Go to the next sequential document. DTM_SELECT -- Select an area in the AmigaGuide database. DTM_COPY -- Copy the selected area of the text to the clipboard as FTXT. If no area is selected, then the entire text is copied. DTM_WRITE -- Write the selected area of the text to a file. If no area is selected, then the entire text is saved. DTM_PRINT -- Print the selected area of the text. If no area is selected, then the entire text is printed. DTM_CLEARSELECTED -- Deselect the selected area of the AmigaGuide database. @endnode @node AG_TAGS "ag_tags" @{b}@{u}Applicability is (I):@{uu}@{ub} DTA_Name (STRPTR) -- Name of the AmigaGuide database. DTA_Handle (BPTR) -- File handle for the AmigaGuide database. DTA_NodeName (STRPTR) -- Document to display. AGA_HelpGroup (ULONG) -- Help group that the AmigaGuide object belongs in. @{b}@{u}Applicability is (G):@{uu}@{ub} DTA_TriggerMethods -- @{"List" Link "include:exec/lists.h/Main" 21} of the trigger methods supported. DTA_Methods -- @{"List" Link "include:exec/lists.h/Main" 21} of the methods supported. @{b}@{u}Applicability is (ISG):@{uu}@{ub} DTA_TextAttr (struct @{"TextAttr" Link "include:graphics/text.h/Main" 66} *) -- Text attribute to use for the AmigaGuide database. @{b}@{u}Applicability is (IS):@{uu}@{ub} TDTA_WordDelim (STRPTR) -- Characters used to deliminate words. @endnode @node AG_COMMANDS_GLOBAL "ag_commands_global" Commands must start in the very first column of a line, and can be the only thing on the line.If a line begins with an @ sign, then it is interpreted as a command. The following commands can be used in the global section of a database. @DATABASE Must be the very first line of an AmigaGuide document. @MASTER Complete path of the source document used to define this AmigaGuide database. @$VER: Specify the version of the database. This command must always be in upper-case. @AUTHOR Specify the author of the database. @(C) Specify the copyright notice for the database. @INDEX Specify the name of the index node, which will be accessed by the Index button.Can be a node in an external database. @HELP Specify the name of the help node, which will be accessed by the Help button.Can be a node in an external database. @HEIGHT How high, in characters, the largest document is. @WIDTH How wide, in characters, the largest document is. @FONT Specify the font to use for the database. @WORDWRAP Turn on wordwrapping for the whole database. A paragraph must be restrained to one physical line. @NODE Indicate the start of a node (page/article/section). The first node, or main node, must be named MAIN.MAIN must be the master table of contents for the database. @DNODE <name> Indicates the start of a dynamic node.The AmigaGuide system uses the callback hooks to obtain the document from a document provider.This is obsolete, do not use. @REM <remark> @REMARK <remark> This is used to place remarks in the database. These remarks are not displayed to the user. @{b}@{u}New for V40:@{uu}@{ub} @TAB <num> Number of spaces in a tab.Defaults to 8. @SMARTWRAP This is used to indicate that the text of the database is to wordwrapped using a more intelligent algorithm than @wordwrap. A paragraph doesn't need to be restricted to one physical line, but paragraphs must be separated by two line feeds. @ONOPEN <rxcommand> This is used to specify an ARexx macro file to execute when the database is opened.If the script returns an error, then the database will not be opened. @ONCLOSE <rxcommand> This is used to specify an ARexx macro file to execute when the database is closed.The return value of the script has no effect on the database. @MACRO <name> <commands> This is used to construct a macro.A macro can be used the same way as an attribute command, and can only consist of other attribute commands or macros. The macro list is searched before the attribute command list is searched. @macro icom "@{i}$1 @{ui}" ... This is an \@{icom "example"} of macro. @endnode @node AG_COMMANDS_LOCAL "ag_commands_local" The following commands can be used within nodes of a database. \ A backslash is the escape character. A backslash in front of the @ sign is used to escape it. @TITLE <title> Title to display in the title bar of the window during the display of this node.Must start at the beginning of a line. @TOC <node name> Name of the node that contains the table of contents for this node.Defaults to MAIN.This is the node that is displayed when the user presses the "Contents" button. @INDEX <name/node> Specify the name of the index node, which will be accessed by the Index button.Can be a node in an external database. @HELP <name/node> Specify the name of the help node, which will be accessed by the Help button.Can be a node in an external database. @PREV <node name> @{"Node" Link "include:exec/nodes.h/Main" 23} to display when the user selects "< Browse" @NEXT <node name> @{"Node" Link "include:exec/nodes.h/Main" 23} to display when the user selects "Browse >" @KEYWORDS <keywords> Keywords of the node.Someday when searching is reimplemented, there will be a keyword search. @FONT <name> <size> Specify the font to use for the node. @WORDWRAP Turn on wordwrapping for the node. A paragraph must be restrained to one physical line. \@{<label> <command>} Indicate a textual link point.Can be anywhere in a line. Starting with 3.0, AmigaGuide can can link to graphics, sounds, animations and other DataTypes. @ENDNODE <name> Indicate the end of a node.Must start at the beginning of a line. @{b}@{u}New for V40:@{uu}@{ub} @TAB <num> Number of spaces in a tab.Defaults to 8.New for V40: @SMARTWRAP This is used to indicate that the text of the node is to wordwrapped using a more intelligent algorithm than @wordwrap. A paragraph doesn't need to be restricted to one physical line, but paragraphs must be separated by two line feeds.New for V40: @ONOPEN <rxcommand> This is used to specify an ARexx macro file to execute when the node is opened.If the script returns an error, then the node will not be opened. @ONCLOSE <rxcommand> This is used to specify an ARexx macro file to execute when the node is closed.The return value of the script has no effect on the node. @endnode @node AG_ATTRIBUTES "ag_attributes" Following is a list of attributes that can be applied to the text of a node. \@{FG <color>} Used to change the foreground color. The same colors can be used as in the BG command. \@{BG <color>} Used to change the background text color.Color can be: Text Shine Shadow Fill FillText Background Highlight \@{B} Turn bold on. \@{UB} Turn bold off. \@{U} Turn underline on. \@{UU} Turn underline off. \@{I} Turn italic on. \@{UI} Turn italic off. @{b}@{u}New for V40:@{uu}@{ub} \@{PARD} Restore the default settings for a paragraph.Text pen to 1, background to 0, normal font, and no indentation. \@{APEN} Use to change the foreground color to a specific pen number. \@{BPEN} Use to change the background color to a specific pen number. \@{PLAIN} Used to turn off all \@{B}, \@{I}, and \@{U} commands. \@{JLEFT} Turn on left justification. \@{JCENTER} Turn on centering. \@{JRIGHT} Turn on right justification. \@{LINDENT} Set the number of spaces to indent the body of a paragraph. \@{PARI} Set the number of spaces to indent the first line of a paragraph relative to the normal paragraph indentation.The value may be a negative number. \@{BODY} Indicate that the following text is the body of the document. Word wrap will be turned back on if it is the default. \@{CODE} Indicate that the following text is not to be word-wrapped. \@{SETTABS <n> ... <n>} This is used to establish tab stops. \@{CLEARTABS} Restore the default tab stops. \@{TAB} The same as character 9 in the source file. \@{AMIGAGUIDE} Displays the word AmigaGuide in bold followed by the ® symbol. \@{LINE} Force a line feed without starting a new paragraph. \@{PAR} Used to indicate the end of a paragraph.This is the same as two sequential LF's in the source file. @endnode @Node "amigaguide.datatype()" "amigaguide.datatype" @{b}@{u}amigaguide.datatype@{uu}@{ub} -- data type for AmigaGuide databases. The amigaguide.datatype is the DataTypes class for AmigaGuide databases. @{"METHODS" link AG_METHODS} @{"TAGS" link AG_TAGS} @{"GLOBAL COMMANDS" link AG_COMMANDS_GLOBAL} @{"LOCAL COMMANDS" link AG_COMMANDS_LOCAL} @{"ATTRIBUTES" link AG_ATTRIBUTES} @{b}@{u}AREXX COMMANDS:@{uu}@{ub} AmigaGuide supports the following ARexx commands. BEEP @{"DisplayBeep()" Link "intuition.guide/DisplayBeep()"}. LINK Go to the named node. CLOSE Close the current database. QUIT Close the current database. @{b}@{u}New for V40:@{uu}@{ub} RETRACE Go to the previous node in the database. Same as pressing the "Retrace" button. PREVIOUS Go to the previous physical node in the database. Same as pressing the "Browse <" button. NEXT Go to the next physical node in the database. Same as pressing the "Browse >" button. GETNODECOUNT Returns the number of nodes in the database using the RESULT variable. PRINT Print the current node.Doesn't return until complete. @EndNode @node SOUND_METHODS "sound_methods" OM_NEW -- Create a new sound object. OM_GET -- Obtain the value of an attribute. OM_SET -- Set the values of multiple attributes. OM_UPDATE -- Update the values of multiple attributes. OM_DISPOSE -- Dispose of a sound object. GM_RENDER -- Cause the graphic to render. Currently the graphic for the sound is just a static icon. GM_LAYOUT -- Layout the object and notify the application of the title and size. GM_HITTEST -- Determine if the object has been hit with the mouse. GM_GOACTIVE -- Tell the object to go active. On SELECTDOWN, the sound will start playing. GM_HANDLEINPUT -- Handle input. Currently input (other than SELECTDOWN) doesn't affect the sound. DTM_TRIGGER -- Cause an event to occur. Currently the only trigger event is STM_PLAY, which will cause the sound to start playing. DTM_COPY -- Copy the entire sound to the clipboard as 8SVX. DTM_WRITE -- Write the entire sound to a file as 8SVX. @endnode @node SOUND_TAGS "sound_tags" @{b}@{u}Applicability is (ISG):@{uu}@{ub} SDTA_VoiceHeader (struct VoiceHeader *) -- Set and get the base information for the sound.VoiceHeader is defined in <datatypes/soundclass.h>. SDTA_Sample (UWORD *) -- Set and get the sound data. Starting from V40 the sample data does not need to be in CHIP memory. SDTA_SampleLength (ULONG) -- Length of the sound data. SDTA_Cycles (UWORD) -- Set and get the number of cycles the sound will be played. Default for this tag is 1. SDTA_Volume (UWORD) -- Set and get the volume of the sound. This attribute can be used to affect a playing sound. Valid range is from 0 to 64.Default for this tag is 64. SDTA_Period (UWORD) -- Set and get the period of the sound. This attribute can be used to affect a playing sound. Default for this tag is 394. @{b}@{u}New for V40:@{uu}@{ub} SDTA_SignalTask (struct @{"Task" Link "include:exec/tasks.h/Main" 25} *) -- Task to signal when the sound is complete, or if SDTA_Continuous is TRUE, when the next buffer is needed. SDTA_SignalBit (BYTE) -- @{"Signal" Link "exec/Signal()"} bit to use with SDTA_SignalTask or -1 to disable. SDTA_Continuous (BOOL) -- Used to indicate that the sound datatype will be fed a continuous stream of data.Defaults to FALSE. @endnode @Node "sound.datatype()" "sound.datatype" @{b}@{u}sound.datatype@{uu}@{ub} -- root data type for sounds. The sound.datatype is the @{b}@{i}super-class@{ui}@{ub} for any sound related classes. @{"METHODS" link SOUND_METHODS} @{"TAGS" link SOUND_TAGS} BUGS Still doesn't support stereo or channel selection. @EndNode @node TEXT_METHODS "text_methods" OM_NEW -- Create a new text object. OM_GET -- Obtain the value of an attribute. OM_SET -- Set the values of multiple attributes. OM_UPDATE -- Update the values of multiple attributes. OM_DISPOSE -- Dispose of a text object. GM_RENDER -- Cause the text to render. GM_LAYOUT -- Layout the object and notify the application of the title and size. GM_HITTEST -- Determine if the object has been hit with the mouse. GM_GOACTIVE -- Tell the object to go active. GM_HANDLEINPUT -- Handle input. DTM_FRAMEBOX -- Obtain the display environment that the text requires. DTM_PROCLAYOUT -- Layout (remap) the text on the application's process. DTM_SELECT -- Select an area in the text. DTM_COPY -- Copy the selected area of the text to the clipboard as FTXT. If no area is selected, then the entire text is copied. DTM_WRITE -- Write the selected area of the text to a file. If no area is selected, then the entire text is saved. DTM_PRINT -- Print the selected area of the text. If no area is selected, then the entire text is printed. DTM_CLEARSELECTED -- Deselect the selected area of the text. @endnode @node TEXT_TAGS "text_tags" @{b}@{u}Applicability is (ISG):@{uu}@{ub} TDTA_Buffer (STRPTR) -- Pointer to the text data. TDTA_BufferLen (ULONG) -- Length of text data. DTA_TextAttr (struct @{"TextAttr" Link "include:graphics/text.h/Main" 66} *) -- Text attribute to use for the text. TDTA_WordWrap (BOOL) -- Used to turn word wrap on and off.Defaults to off. @{b}@{u}Applicability is (G):@{uu}@{ub} DTA_TextFont (struct @{"TextFont" Link "include:graphics/text.h/Main" 90} *) -- Text font to use for the text. TDTA_LineList (struct @{"List" Link "include:exec/lists.h/Main" 21} *) -- List of lines.The elements of the list are Line structures (see <datatype/textclass.h>). @{b}@{u}Applicability is (IS):@{uu}@{ub} TDTA_WordDelim (STRPTR) -- Characters used to deliminate words. @{b}@{u}Applicability is (NU):@{uu}@{ub} TDTA_WordSelect (STRPTR) -- Word that has been double-clicked on. @endnode @Node "text.datatype()" "text.datatype" @{b}@{u}text.datatype@{uu}@{ub} -- Root data type for text. The text.datatype is the @{b}@{i}super-class@{ui}@{ub} for any text related classes. @{"METHODS" link TEXT_METHODS} @{"TAGS" link TEXT_TAGS} SEE ALSO @{"ascii.datatype" link ascii.datatype()} @EndNode @node PICTURE_METHODS "picture_methods" OM_NEW -- Create a new picture object. OM_SET -- Set the values of multiple attributes. OM_GET -- Obtain the value of an attribute. OM_UPDATE -- Update the values of multiple attributes. OM_DISPOSE -- Dispose of a picture object. GM_RENDER -- Cause the graphic to render. GM_LAYOUT -- Layout the object and notify the application of the title and size. GM_HITTEST -- Determine if the object has been hit with the mouse. GM_GOACTIVE -- Tell the object to go active. GM_HANDLEINPUT -- Handle input. DTM_FRAMEBOX -- Obtain the display environment that the picture requires. DTM_PROCLAYOUT -- Layout (remap) the picture on the application's process. DTM_SELECT -- Select an area in the picture. DTM_COPY -- Copy the selected area of the picture to the clipboard as an ILBM. If no area is selected, then the entire picture is copied. DTM_WRITE -- Write the selected area of the picture to a file as an ILBM. If no area is selected, then the entire picture is saved. DTM_PRINT -- Print the selected area of the picture. If no area is selected, then the entire picture is printed. DTM_CLEARSELECTED -- Deselect the selected area of the picture. @endnode @node PICTURE_TAGS "picture_tags" @{b}@{u}Applicability is (I):@{uu}@{ub} PDTA_Remap (BOOL) -- Indicate whether the picture should be remapped or not. PDTA_SparseTable (UBYTE *) -- Pointer to a table of pen numbers indicating which colors should be used when remapping the picture.This array must contain as many entries as indicated by the PDTA_NumSparse tag. PDTA_NumSparse (UWORD) -- Number of entries in the sparse color table. OBP_Precision (ULONG) -- Precision to use when obtaining colors. See the PRECISION_ defines in @{"<graphics/view.h>" Link "include:graphics/view.h/Main" 0}. @{b}@{u}Applicability is (ISG):@{uu}@{ub} PDTA_Grab (Point *) -- Pointer to a Point structure, that defines the grab point of the picture. PDTA_ClassBitMap (struct @{"BitMap" Link "include:graphics/gfx.h/Main" 47} *) -- PDTA_BitMap (struct @{"BitMap" Link "include:graphics/gfx.h/Main" 47} *) -- Pointer to a class-allocated bitmap, that will end up being freed by the picture class in the OM_DISPOSE method. PDTA_ModeID (ULONG) -- Set and get the graphic mode id of the picture. PDTA_NumColors (WORD) -- Number of colors used by the picture. @{b}@{u}Applicability is (G):@{uu}@{ub} PDTA_DestBitMap (struct @{"BitMap" Link "include:graphics/gfx.h/Main" 47} *) -- Pointer to the remapped bitmap. PDTA_BitMapHeader (struct BitMapHeader *) -- Set and get the base information for the picture.BitMapHeader is defined in <datatypes/pictureclass.h>. PDTA_ColorRegisters (struct ColorRegister *) -- Color table. PDTA_CRegs (ULONG *) -- Color table to use with SetRGB32CM(). PDTA_GRegs (ULONG *) -- Color table. PDTA_ColorTable (ULONG *) -- Shared pen table. PDTA_ColorTable2 (ULONG *) -- Shared pen table. PDTA_Allocated (ULONG) -- Number of shared colors allocated. PDTA_NumAlloc (WORD) -- Number of colors allocated by the picture. @{b}@{u}Applicability is (IS):@{uu}@{ub} PDTA_Screen (struct @{"Screen" Link "include:intuition/screens.h/Main" 97} *) -- Pointer to the screen to remap the picture to.Only used if the object is not going to be added to a window. PDTA_FreeSourceBitMap (BOOL) -- Indicate whether the source bitmap should be freed immediately by the picture.datatype after the GM_LAYOUT method is called. @endnode @Node "picture.datatype()" "picture.datatype" @{b}@{u}picture.datatype@{uu}@{ub} -- root data type for pictures. The picture.datatype is the @{b}@{i}super-class@{ui}@{ub} for any picture related classes. @{"METHODS" link PICTURE_METHODS} @{"TAGS" link PICTURE_TAGS} @EndNode @node ANIM_METHODS "anim_methods" OM_NEW -- Create a new animation object. OM_GET -- Obtain the value of an attribute. OM_SET -- Set the values of multiple attributes. OM_UPDATE -- Update the values of multiple attributes. OM_DISPOSE -- Dispose of a animation object. GM_RENDER -- Cause the current frame to render. GM_LAYOUT -- Layout the object and notify the application of the title and size. GM_HITTEST -- Determine if the object has been hit with the mouse. GM_GOACTIVE -- Tell the object to go active. On SELECTDOWN, the animation will start playing. GM_HANDLEINPUT -- Handle input. Currently input (other than SELECTDOWN) doesn't affect the animation. DTM_FRAMEBOX -- Obtain the display environment that the animation requires. DTM_TRIGGER -- Cause an event to occur. Currently the only trigger event is STM_PLAY, which will cause the animation to start playing. DTM_COPY -- Copy the current frame to the clipboard as an IFF ILBM. DTM_WRITE -- Write the current frame to a file as an IFF ILBM. DTM_PRINT -- Print the current frame. ADTM_LOCATE -- Used to locate a frame of the animation. ADTM_LOADFRAME -- Load a frame of the animation. ADTM_START -- Start the animation. This MUST be passed to the super-class AFTER the sub-class has started. ADTM_PAUSE -- Pause the animation. This MUST be passed to the super-class BEFORE the sub-class pauses. ADTM_STOP -- Stop the animation. This MUST be passed to the super-class BEFORE the sub-class stops. ADTM_UNLOADFRAME -- Deallocate any memory allocated by ADTM_LOADFRAME. @endnode @node ANIM_TAGS "anim_tags" @{b}@{u}Applicability is (I):@{uu}@{ub} @{i}DTA_ControlPanel@{ui} (BOOL) -- Determine whether the control panel is shown. Defaults to TRUE. @{i}DTA_Immediate@{ui} (BOOL) -- Indicate whether the animation should immediately begin playing.Defaults to FALSE. @{i}ADTA_Remap@{ui} (BOOL) -- Indicate whether the animation should be remapped or not. @{b}@{u}Applicability is (ISG):@{uu}@{ub} @{i}ADTA_KeyFrame@{ui} (@{FG shine}struct@{FG text} @{"BitMap" Link "include:graphics/gfx.h/Main" 47} *) -- Pointer to the key frame. @{i}ADTA_ModeID@{ui} (ULONG) -- Set and get the graphic mode id of the picture. @{i}ADTA_NumColors@{ui} (WORD) -- Number of colors used by the picture. @{i}ADTA_Frames@{ui} (ULONG) -- Number of frames in animation. @{i}ADTA_FramesPerSecond@{ui} (ULONG) -- Number of frames per second to play. @{i}SDTA_Sample@{ui} (BYTE *) -- Pointer to sample data. @{i}SDTA_SampleLength@{ui} (ULONG) -- Length of sample data. @{i}SDTA_Volume@{ui} (ULONG) -- Volume to play back sample at. @{i}SDTA_Period@{ui} (ULONG) -- Period to play back sample at. @{b}@{u}Applicability is (IG):@{uu}@{ub} @{i}ADTA_Width@{ui} (ULONG) -- Width of a frame in pixels. @{i}ADTA_Height@{ui} (ULONG) -- Height of a frame in pixels. @{i}ADTA_Depth@{ui} (ULONG) -- Depth of the frame. @{b}@{u}Applicability is (G):@{uu}@{ub} @{i}ADTA_BitMapHeader@{ui} (@{FG shine}struct@{FG text} BitMapHeader *) -- Set and get the base information for the animation.BitMapHeader is defined in <datatypes/pictureclass.h>. @{i}ADTA_ColorRegisters@{ui} (@{FG shine}struct@{FG text} @{i}ColorRegister@{ui} *) -- Color table. @{i}ADTA_CRegs@{ui} (ULONG *) -- Color table to use with SetRGB32CM(). @{i}ADTA_GRegs@{ui} (ULONG *) -- Color table. @{i}ADTA_ColorTable@{ui} (ULONG *) -- Shared pen table. @{i}ADTA_ColorTable2@{ui} (ULONG *) -- Shared pen table. @{i}ADTA_Allocated@{ui} (ULONG) -- Number of shared colors allocated. @{i}ADTA_NumAlloc@{ui} (WORD) -- Number of colors allocated by the picture. @endnode @Node "animation.datatype()" "animation.datatype" @{b}@{u}animation.datatype@{uu}@{ub} -- root data type for animations. The animation.datatype is the @{b}@{i}super-class@{ui}@{ub} for any animation related classes. This class is responsible for creating the controls, scaling, remapping and synchronization. @{"METHODS" link ANIM_METHODS} @{"TAGS" link ANIM_TAGS} @EndNode @Node "ilbm.datatype()" "ilbm.datatype" @{b}@{u}ilbm.datatype@{uu}@{ub} -- data type for ILBM pictures. The ILBM data type, a @{i}sub-class of the picture.datatype@{ui}, and is used to load ILBM IFF picture files. METHODS OM_NEW -- Create a new picture object from an ILBM IFF. The source may be either a file or the clipboard. SEE ALSO @{"picture.datatype" link picture.datatype()}. @EndNode @Node "ascii.datatype()" "ascii.datatype" @{b}@{u}ascii.datatype@{uu}@{ub} -- data type for ANSI text. The ASCII data type, a @{i}sub-class of the text.datatype@{ui}, and is used to load ANSI text files. METHODS OM_NEW -- Create a new text object from ANSI characters. The source may be either a file or the clipboard. SEE ALSO @{"text.datatype" link text.datatype()}. @EndNode @Node "8svx.datatype()" "8svx.datatype" @{b}@{u}8svx.datatype@{uu}@{ub} -- data type for 8svx sounds. The 8svx data type, a @{i}sub-class of the sound.datatype@{ui}, and is used to load 8SVX IFF files. METHODS OM_NEW -- Create a new sound object from an 8SVX IFF. The source may be either a file or the clipboard. SEE ALSO @{"sound.datatype" link sound.datatype()}. @EndNode @Node "aiff.datatype()" "aiff.datatype/aiff.datatype" @{b}@{u}aiff.datatype@{uu}@{ub} -- data type for aiff/aifc sounds. The aiff data type, a @{i}sub-class of the sound.datatype@{ui}, is used to load and save aiff/aifc files. METHODS OM_NEW -- Create a new sound object from a aiff/aifc file. Creating an empty object (DTST_RAM) is also supported and allows you to create an aiff files. DTM_WRITE -- For DTWM_RAW an aiff file will be created. DTWM_IFF is passed to the superclass. BUGS Only supports aiff and @{u}uncompressed@{uu} aifc sounds with either one or two channels and 8 or 16 bits. SEE ALSO @{"sound.datatype" Link "sound.datatype()"}. @EndNode