home *** CD-ROM | disk | FTP | other *** search
/ Amiga ACS 1998 #4 / amigaacscoverdisc1998-041998.iso / utilities / shareware / workbench / hypertext_dtc / developer / autodocs / hypertext_dtc.doc < prev    next >
Encoding:
Text File  |  1998-02-11  |  81.7 KB  |  2,439 lines
  1.  
  2.  
  3. TABLE OF CONTENTS
  4.  
  5. hypertext.datatype/--arexx--
  6. hypertext.datatype/--datasheet--
  7. hypertext.datatype/AllocConvInfoA
  8. hypertext.datatype/AllocSegInfoA
  9. hypertext.datatype/AllocSegmentA
  10. hypertext.datatype/ConvertAttributes
  11. hypertext.datatype/FreeConvInfo
  12. hypertext.datatype/FreeSegInfo
  13. hypertext.datatype/FreeSegment
  14. hypertext.datatype/DTM_CLEARSELECTED
  15. hypertext.datatype/DTM_COPY
  16. hypertext.datatype/DTM_FRAMEBOX
  17. hypertext.datatype/DTM_GOTO
  18. hypertext.datatype/DTM_PRINT
  19. hypertext.datatype/DTM_REMOVEDTOBJECT
  20. hypertext.datatype/DTM_SELECT
  21. hypertext.datatype/DTM_TRIGGER
  22. hypertext.datatype/DTM_WRITE
  23. hypertext.datatype/GM_GOACTIVE
  24. hypertext.datatype/GM_HANDLEINPUT
  25. hypertext.datatype/GM_LAYOUT
  26. hypertext.datatype/GM_RENDER
  27. hypertext.datatype/HTDTM_ALLOCVEC
  28. hypertext.datatype/HTDTM_ATTEMPT
  29. hypertext.datatype/HTDTM_CONVATTRIB
  30. hypertext.datatype/HTDTM_EXPORT
  31. hypertext.datatype/HTDTM_FREEVEC
  32. hypertext.datatype/HTDTM_GETFONT
  33. hypertext.datatype/HTDTM_GUISEARCH
  34. hypertext.datatype/HTDTM_HTPROC
  35. hypertext.datatype/HTDTM_LAYOUT
  36. hypertext.datatype/HTDTM_LOADNODES
  37. hypertext.datatype/HTDTM_OBTAIN
  38. hypertext.datatype/HTDTM_OBTAINPEN
  39. hypertext.datatype/HTDTM_RELEASE
  40. hypertext.datatype/HTDTM_RENDER
  41. hypertext.datatype/HTDTM_SAVENODES
  42. hypertext.datatype/HTDTM_SEARCH
  43. hypertext.datatype/OM_DISPOSE
  44. hypertext.datatype/OM_GET
  45. hypertext.datatype/OM_NEW
  46. hypertext.datatype/OM_NOTIFY
  47. hypertext.datatype/OM_SET
  48. hypertext.datatype/OM_UPDATE
  49.  
  50.  
  51. hypertext.datatype/--arexx--                      hypertext.datatype/--arexx--
  52.  
  53.     NAME
  54.         arexx interface -- hypertext.datatype ARexx commands
  55.  
  56.     FUNCTION
  57.         The hypertext.datatype provides a own ARexx port for each object.
  58.         It's name is the port name passed via DTA_ARexxPortName plus a
  59.         suffix of '.1' or if this port exists '.2' and so on.
  60.         For example if you start MultiView with a hypertext object, MultiView
  61.         passes "MULTIVIEW.1" for DTA_ARexxPortName to the hypertext object.
  62.         The hypertext object tries to open a port named "MULTIVIEW.1.1".
  63.  
  64.     AREXX COMMANDS
  65.         See a detailed list and description in the hypertext.hguide document.
  66.  
  67.     SEE ALSO
  68.         hypertext.hguide
  69.  
  70. hypertext.datatype/--datasheet--              hypertext.datatype/--datasheet--
  71.  
  72.     NAME
  73.         hypertext.datatype -- hypertext base class datatype
  74.  
  75.     SUPERCLASS
  76.         datatypesclass
  77.  
  78.     DESCRIPTION
  79.         The hypertext datatype class implements all methods for layout,
  80.         rendering and printing of hypertext and text objects. It supports
  81.         searching within documents and embedding of other datatype objects.
  82.  
  83.         The following list gives an overview about the features of the
  84.         hypertext datatype class :
  85.  
  86.         o embedding of other DataTypes objects (DTM_DRAW).
  87.  
  88.           the hypertext.datatype supports embedding of other datatypes using
  89.           the DTM_DRAW method to render such objects. It's also possible to
  90.           use a object multiple times in one document.
  91.  
  92.         o multiple fonts
  93.  
  94.           it supports more than one font in one document. Limit is only set
  95.           by the available fonts and memory.
  96.  
  97.         o links to other DataTypes objects.
  98.  
  99.         o links to programs and ARexx-scripts
  100.  
  101.         o line separator like HTML <hr>
  102.  
  103.         o justification left,center,right
  104.  
  105.         o asyncron rendering (not in input task)
  106.  
  107.         o own ARexx port (See --arexx--)
  108.  
  109.         o a defined API
  110.  
  111.           see datatypes/hypertextclass.h and the following function
  112.           description.
  113.  
  114.         o example HyperText subclass htdemo
  115.  
  116.           a full subclass implementation with source code is available to
  117.           demonstrate the usage of the hypertext.datatype API.
  118.  
  119.     METHODS
  120.         OM_NEW -- Create a new hypertext object.
  121.  
  122.         OM_GET -- Obtain the value of an attribute.
  123.  
  124.         OM_SET -- Set the values of multiple attributes.
  125.  
  126.         OM_UPDATE -- Updates the values of multiple attributes.
  127.  
  128.         OM_DISPOSE -- Dispose of a hypertext object and all of it's
  129.             resources.
  130.  
  131.         OM_NOTIFY -- Snoops the notification of some attributes.
  132.  
  133.         GM_LAYOUT -- Layout the object and notify the application of the
  134.             title and size.
  135.  
  136.         GM_GOACTIVE -- Tell the object to go active.
  137.  
  138.         GM_HANDLEINPUT -- Handle input.
  139.  
  140.         GM_RENDER -- Cause the object to render. This is done asyncron, so
  141.             input task sends only messages to the hypertext support process.
  142.             This method overwrites the superclass GM_RENDER method.
  143.  
  144.         DTM_GOTO -- Cause the object to load a other object or document.
  145.  
  146.         DTM_TRIGGER -- Trigger an event. Following are currently supported :
  147.  
  148.             STM_PREV_FIELD -- Select previous field/link.
  149.  
  150.             STM_NEXT_FIELD -- Select next field/link.
  151.  
  152.             STM_ACTIVATE_FIELD -- Activate actual selected field/link. And
  153.                 execute the appropriate command. Like running a program,
  154.                 start a ARexx-script or load a new object.
  155.  
  156.             STM_RETRACE -- Retrace to last visited node.
  157.  
  158.             STM_CONTENTS -- Show contents node.
  159.  
  160.             STM_INDEX -- Show index node.
  161.  
  162.             STM_BROWSE_PREV -- Go to the logical previous node.
  163.  
  164.             STM_BROWSE_NEXT -- Go to the logical next node.
  165.  
  166.         DTM_REMOVEDTOBJECT -- Used to clear internal cached variables. Then
  167.             directly passed to superclass.
  168.  
  169.         DTM_COPY -- Copies the current object or selected area to clipboard.
  170.  
  171.         DTM_FRAMEBOX -- Informs the application, which environment the object
  172.             needs.
  173.  
  174.         DTM_WRITE -- Writes the contents of the current object to a file.
  175.  
  176.         DTM_PRINT -- Prints the current object.
  177.  
  178.         DTM_SELECT -- Selects a area of the current object.
  179.  
  180.         DTM_CLEARSELECTED -- Clears the selected area.
  181.  
  182.         HTDTM_LAYOUT -- Layout the hypertext segments. Caclulate
  183.             justifications and other dynamical layout parameters.
  184.  
  185.         HTDTM_GETFONT -- Tries to open a specified font. The hypertext
  186.             datatype handles all resource tracking, so that you can call this
  187.             method much often without remembering the opened font.
  188.  
  189.         HTDTM_OBTAINPEN -- Tries to allocate a shared pen. The hypertext
  190.             datatype handles all resource tracking.
  191.  
  192.         HTDTM_OBTAIN -- Obtain the hypertext object semaphore.
  193.  
  194.         HTDTM_RELEASE -- Release the hypertext object semaphore.
  195.  
  196.         HTDTM_ATTEMPT -- Attempt to obtain the hypertext object semaphore.
  197.  
  198.         HTDTM_ALLOCVEC -- Allocate a memory from the hypertext objects memory
  199.             pool. Similar to AllocVec().
  200.  
  201.         HTDTM_FREEVEC -- Free memory allocatec by HTDTM_ALLOCVEC.
  202.  
  203.         HTDTM_HTPROC -- Check if the current method is invoked on the separate
  204.             hypertext object process. Note: If you overwrite some methods like
  205.             DTM_GOTO, you have to check first if you are in that special
  206.             process context, and if not you have to pass this method directly
  207.             to superclass, so that this can signal the hypertext object
  208.             process to do this method on its context. This strategy is needed
  209.             to avoid problems with input task based method invocations.
  210.  
  211.         HTDTM_RENDER -- Render the hypertext object on its separate process.
  212.  
  213.         HTDTM_LOADNODES -- Tries to load all node informations from a
  214.             database to avoid scanning the whole file.
  215.  
  216.         HTDTM_SAVENODES -- Save all node information to a database. Currently
  217.             the node information is only saved in the documents icon.
  218.  
  219.         HTDTM_SEARCH -- Searchs for occurence of the given pattern or string.
  220.             NOTE: Only available in the registered version.
  221.  
  222.         HTDTM_GUISEARCH -- Opens the search requester on a separate process
  223.             and waits for input from the user.
  224.             NOTE: Only available in the registered version.
  225.  
  226.         HTDTM_EXPORT -- exports the current document to a specific format.
  227.             NOTE: Only available in the registered version.
  228.  
  229.         HTDTM_CONVATTRIB -- used to convert additional HyperGuide style
  230.             attributes during ConvertAttributes() call.
  231.  
  232.     ATTRIBUTES
  233.         DTA_Domain (struct IBox *) -- objects domain box. This is overwritten,
  234.             if a control panel is used.
  235.  
  236.             Applicability is (G).
  237.  
  238.         DTA_TextFont (struct TextFont *) -- Text font to use for normal texts,
  239.             not explicitly specified using the HTDTSA_TextFont text segment
  240.             Tag.
  241.  
  242.             Defaults to the system standard font.
  243.  
  244.             Applicability is (G).
  245.  
  246.         DTA_TextAttr (struct TextAttr *) -- Text attribute structure to use
  247.             for normal texts. This corresponds to the DTA_TextFont attribute.
  248.  
  249.             Defaults to a system standard font TextAttr.
  250.  
  251.             Applicability is (ISG).
  252.  
  253.         DTA_Title (STRPTR) -- Title of the hypertext object, which is normally
  254.             displayed in the windows title bar. The string is copied, so that
  255.             after the set method returns you can free its resources.
  256.  
  257.             Defaults to NULL.
  258.  
  259.             Applicability is (ISG).
  260.  
  261.         DTA_NodeName (STRPTR) -- Name of node of this hypertext object.
  262.             The set method copies the string.
  263.  
  264.             Defaults to "main".
  265.  
  266.             Applicability is (ISG).
  267.  
  268.         DTA_Methods (ULONG *) -- ~0 terminated MethodID list of supported
  269.             methods.
  270.  
  271.             Applicability is (G).
  272.  
  273.         DTA_ControlPanel (BOOL) -- Indicates, if the hypertext datatype should
  274.             (TRUE) create a control panel for the created object or not
  275.             (FALSE).
  276.  
  277.             Defaults to TRUE.
  278.  
  279.             Applicability is (IG).
  280.  
  281.         AGA_Secure (BOOL) -- Indicates, if its permitted (FALSE) to start
  282.             external programms or not (TRUE).
  283.             NOTE: Only supported for compatibility with amigaguide.datatype.
  284.                   Please use HTDTA_Secure instead.
  285.  
  286.             Defaults to FALSE.
  287.  
  288.             Applicability is (ISG)
  289.  
  290.         HTDTA_Secure (BOOL) -- Indicates, if its permitted (FALSE) to start
  291.             external programms or not (TRUE).
  292.  
  293.             Defaults to FALSE.
  294.  
  295.             Applicability is (ISG)
  296.  
  297.         HTDTA_HyperText (BOOL) -- Indicates, if the object is a hypertext
  298.             object.
  299.  
  300.             Defaults to TRUE.
  301.  
  302.             Applicability is (G).
  303.  
  304.         HTDTA_SegmentList (struct List *) -- List of linked segments of the
  305.             current object.
  306.  
  307.             Applicability is (G).
  308.  
  309.         HTDTA_WordDelim (STRPTR) -- String, which describes the delimiter
  310.             characters to use for separating words. The string is not
  311.             copied.
  312.  
  313.             Defaults to " \t\n".
  314.  
  315.             Applicability is (ISG).
  316.  
  317.         HTDTA_Buffer (UBYTE *) -- Pointer to the raw hypertext data buffer, if
  318.             any is available. Subclasses which uses IFF files don't provide
  319.             this buffer. See catalog.datatype for example.
  320.  
  321.             For ascii and binary files the entire file is loaded into this
  322.             buffer.
  323.  
  324.             Applicability is (IG).
  325.  
  326.         HTDTA_BufferLen (ULONG) -- Length of raw hypertext data buffer.
  327.  
  328.             Defaults to length of the HTDS_Buffer.
  329.  
  330.             Applicability is (IG).
  331.  
  332.         HTDTA_LoadBuffer (BOOL) -- Indicates, if the hypertext base class
  333.             should load (TRUE) the entire ascii or binary file into a
  334.             buffer and provide it for the subclass via HTDA_Buffer and
  335.             HTDA_BufferLen.
  336.  
  337.             Defaults to TRUE.
  338.  
  339.             Applicability is (G).
  340.  
  341.         HTDTA_Pool (APTR) -- Memory pool of the current hypertext object.
  342.  
  343.             Applicability is (G).
  344.  
  345.         HTDTA_EmbeddedList (struct List *) -- List of all embedded objects.
  346.             This list can only be walked trough with intuition's NextObject()
  347.             function.
  348.  
  349.             Applicability is (G).
  350.  
  351.         HTDTA_UnderlineLink (BOOL) -- Indicates, if links should be shown as
  352.             buttons (FALSE) like AmigaGuide links or should be underlined
  353.             (TRUE) like most Web browsers do.
  354.  
  355.             Defaults to FALSE.
  356.  
  357.             Applicability is (IG).
  358.  
  359.         HTDTA_Spacing (UWORD) -- Number of pixel between two lines. This value
  360.             is used in HTDTM_LAYOUT method. Thus if you change the value you
  361.             have to invoke DTM_PROCLAYOUT to reflect the change in the output.
  362.  
  363.             Defaults to 1.
  364.  
  365.             Applicability is (ISG).
  366.  
  367.         HTDTA_Contents (STRPTR) -- Defines the name of the contents object of
  368.             the current hypertext object. The string is copied.
  369.  
  370.             Defaults to global contents as specified in the prefs file or NULL
  371.             is no global contents is specified.
  372.  
  373.             Applicability is (ISG).
  374.  
  375.         HTDTA_Index (STRPTR) -- Defines the name of the index object of the
  376.             current hypertext object. The string is copied.
  377.  
  378.             Defaults to NULL.
  379.  
  380.             Applicability is (ISG).
  381.  
  382.         HTDTA_Help (STRPTR) -- Defines the name of the help object of the
  383.             current hypertext object. The string is copied.
  384.  
  385.             Defaults to "HELP:<language>/HTDS_Help.hguide"
  386.  
  387.             Applicability is (ISG).
  388.  
  389.         HTDTA_Previous (STRPTR) -- Defines the name of the previous object of
  390.             the current hypertext object. The string is copied.
  391.  
  392.             Defaults to NULL.
  393.  
  394.             Applicability is (ISG).
  395.  
  396.         HTDTA_Next (STRPTR) -- Defines the name of the next object of the
  397.             current hypertext object. The string is copied.
  398.  
  399.             Defaults to NULL.
  400.  
  401.             Applicability is (ISG).
  402.  
  403.         HTDTA_TabWidth (LONG) -- number of space characters to use for a
  404.             tabulator character.
  405.  
  406.             Defaults to 8.
  407.  
  408.             Applicability is (ISG).
  409.  
  410.         HTDTA_Background (STRPTR) -- file name of a picture to use for
  411.             the background.
  412.  
  413.             Defaults to value specified in the prefs (DEFBGPIC) file or
  414.             NULL if nothing was specified.
  415.  
  416.             Applicability is (ISG).
  417.  
  418.         HTDTA_BackgroundPen (LONG) -- pen number to use for background
  419.             color.
  420.  
  421.             Defaults to value specified in the prefs (DEFBGPEN) file or
  422.             0 if nothing was specified.
  423.  
  424.             Applicability is (ISG).
  425.  
  426.         HTDTA_ForegroundPen (LONG) -- pen number to use for foreground
  427.             color. This is normaly all standard texts.
  428.  
  429.             Defaults to value specified in the prefs (DEFFGPEN) file or
  430.             1 if nothing was specified.
  431.  
  432.             Applicability is (ISG).
  433.  
  434.         HTDTA_AltForegroundPen (LONG) -- pen number to use for foreground
  435.             color, if background and foreground color are the same.
  436.  
  437.             Defaults to value specified in the prefs (DEFALTFGPEN) file or
  438.             3 if nothing was specified.
  439.  
  440.             Applicability is (ISG).
  441.  
  442.         HTDTA_ObjectDir (BPTR) -- used to get a shared lock on the directory
  443.             of the object. It handles all different datatypes source types
  444.             like IFF, misc or files. The returned lock must be free'd after
  445.             you have finished your job with UnLock().
  446.  
  447.             Applicability is (G).
  448.  
  449.         HTDTA_Depth (LONG) -- recommended color depth for the hypertext
  450.             object. This is used by applications to open a appropriate
  451.             custom screen with at least this depth.
  452.  
  453.             Applicability is (ISG).
  454.  
  455.         HTDTA_FileHandle (BPTR) -- file handle from Open() of the hypertext
  456.             object. This is used for obtaining file informations from
  457.             DTST_RAM objects, which are part of an normal file. For example
  458.             the hypertext.datatype creates for each internal node a DTST_RAM
  459.             object with HTDTA_Buffer and HTDTA_BufferLen set.
  460.             NOTE: This attribute should be overwritten from SubClass
  461.                   implementors.
  462.  
  463.             Default is NULL.
  464.  
  465.             Applicability is (G).
  466.  
  467.         HTDTA_ARexxCommand (STRPTR) -- used to send an arexx command to the
  468.             hypertext object.
  469.  
  470.             Applicability is (NU).
  471.  
  472.         HTDTA_NodeList (struct List *) -- used by the hypertext.datatype to
  473.             obtain the list of internal nodes from the subclass.
  474.             NOTE: This attribute should be overwritten from SubClass
  475.                   implementors.
  476.  
  477.             Defaults to NULL.
  478.  
  479.             Applicability is (G).
  480.  
  481.         HTDTA_ShowLink (BOOL) -- indicates, if a link should be shown in as
  482.             DTA_Title when its activated via key or mouse actions.
  483.  
  484.             Defaults to value specified in the prefs (SHOWLINK) file or
  485.             FALSE if nothing was specified.
  486.  
  487.             Applicability is (ISGN).
  488.  
  489.         HTDTA_SeparatorIsFF (BOOL) -- indicates, if a separator should be
  490.             treated as a form feed within printing and AscII export.
  491.  
  492.             Defaults to FALSE.
  493.  
  494.             Applicability is (ISG).
  495.  
  496.         HTDTA_NodeIndexing (BOOL) -- indicates, if internal nodes should be
  497.             saved in a database.
  498.             NOTE: This attribute should be overwritten from SubClass
  499.                   implementors.
  500.  
  501.             Defaults to FALSE.
  502.  
  503.             Applicability is (G).
  504.  
  505.         HTDTA_PathList (struct List *) -- list of pathes to search of objects
  506.             to go to. This list is object dependend and therefore relative
  507.             pathes are relative to the objects directory.
  508.             NOTE: This attribute should be overwritten from SubClass
  509.                   implementors.
  510.  
  511.             Defaults to NULL.
  512.  
  513.             Applicability is (G).
  514.  
  515.     SEE ALSO
  516.         HTDS.hguide
  517.  
  518. hypertext.datatype/AllocConvInfoA            hypertext.datatype/AllocConvInfoA
  519.  
  520.     NAME
  521.         AllocConvInfoA -- allocate ConvertAttributes() info structure
  522.         AllocConvInfo -- varargs stub for AllocConvInfoA()
  523.  
  524.     SYNOPSIS
  525.         convinfo = AllocConvInfoA(segInfo,segTagList,tagList);
  526.            D0                       A0        A1       A2
  527.  
  528.         struct HTConvInfo *AllocConvInfoA(struct HTSegInfo *,
  529.                                           struct TagItem *,struct TagItem *);
  530.  
  531.         convinfo = AllocConvInfo(segInfo,segTagList,tag1,...);
  532.  
  533.         struct HTConvInfo *AllocConvInfo(struct HTSegInfo *,
  534.                                          struct TagItem *,Tag ,...);
  535.  
  536.     FUNCTION
  537.         This function allocates a structure for use with ConvertAttributes().
  538.         It scans the given TagItem array segTagList and setup the appropriate
  539.         pointers to convert the specified hypertext format to the given
  540.         segment TagItem array.
  541.  
  542.     TAGS
  543.         HTDTCIA_Format -- (STRPTR) format to use for conversion. This may be
  544.             any hypertext format such as "hyperguide", "html" or "texinfo".
  545.             Currently only "hyperguide" is supported.
  546.             Defaults to "hyperguide".
  547.  
  548.         HTDTCIA_UserData -- (APTR) this data field is passed to the
  549.             HTDTM_CONVATTRIB method in the UserData field of this message.
  550.  
  551.     INPUTS
  552.         segInfo -- (struct HTSegInfo *) info structure from AllocSegInfoA()
  553.         segTagList -- (struct TagItem *) tag list to use for AllocSegment()
  554.         tagList -- (struct TagItem *) tag list for this function.
  555.  
  556.     RESULTS
  557.         convinfo -- (struct HTConvInfo *) pointer to a ConvertInfo structure
  558.             or NULL for failure.
  559.  
  560.     SEE ALSO
  561.         FreeConvInfo(), AllocSegInfoA(), ConvertAttributes()
  562.  
  563. hypertext.datatype/AllocSegInfoA              hypertext.datatype/AllocSegInfoA
  564.  
  565.     NAME
  566.         AllocSegInfoA -- allocates a segment info structure
  567.         AllocSegInfo -- varargs stub for AllocSegInfoA()
  568.  
  569.     SYNOPSIS
  570.         seginfo = AllocSegInfoA(tagList);
  571.           D0                      A0
  572.  
  573.         APTR AllocSegInfoA(struct TagItem *);
  574.  
  575.         seginfo = AllocSegInfo(tag1,...);
  576.  
  577.         APTR AllocSegInfo(Tag , ...);
  578.  
  579.     FUNCTION
  580.         This function allocates a info structure to use for the
  581.         AllocSegmentA() function. It stores informaions that this function
  582.         need to know. And also it uses private fields for tempory storage
  583.         between to calls to AllocSegmentA().
  584.  
  585.     TAGS
  586.         HTDTSIA_Pool -- (APTR) pool header for use with AllocPooled().
  587.             This Tag is Required !
  588.  
  589.         HTDTSIA_Object -- (Object *) pointer to the hypertext object to
  590.             allocate segments for.
  591.             This Tag is Required !
  592.  
  593.         HTDTSIA_GadgetInfo -- (struct GadgetInfo *) BOOPSI information
  594.             structure.
  595.             This Tag is Required !
  596.  
  597.         HTDTSIA_List -- (struct List *) list to append segments to.
  598.             Defaults to the hypertext object HTDTA_SegmentList.
  599.  
  600.     INPUTS
  601.         tagList -- (struct TagItem *) list of attributes
  602.  
  603.     RESULTS
  604.         a pointer to a private segment info structure or NULL for failure.
  605.         If something fails, a error code is returned in IoErr(). The
  606.         following error codes are defined :
  607.             ERROR_REQUIRED_ARG_MISSING -- required tag is missing.
  608.             ERROR_OBJECT_WRONG_TYPE -- the passed Object isn't a hypertext
  609.                 object.
  610.  
  611.     NOTES
  612.         The function uses the given pool header to allocate it's memory. So
  613.         if you pass a pool, which is used in more than one task, you have to
  614.         arbitriate by yourself.
  615.  
  616.     SEE ALSO
  617.         FreeSegInfo(), AllocSegmentA(), FreeSegment()
  618.  
  619. hypertext.datatype/AllocSegmentA              hypertext.datatype/AllocSegmentA
  620.  
  621.     NAME
  622.         AllocSegementA -- Allocate a hypertext segment
  623.         AllocSegement -- varargs stub for AllocSegmentA()
  624.  
  625.     SYNOPSIS
  626.         segment = AllocSegmentA(segInfo,type,tagList);
  627.           D0                       A0    D0    A1
  628.  
  629.         struct HTSegment *AllocSegmentA(APTR, ULONG, struct TagItem *);
  630.  
  631.         segment = AllocSegment(segInfo,type,tag1,...);
  632.  
  633.         struct HTSegment *AllocSegment(APTR, ULONG,
  634.                                        Tag, ...);
  635.  
  636.     FUNCTION
  637.         This function allocates a new hypertext segment and adds it to the
  638.         list of the hypertext object given in the SegmentInfo structure.
  639.         Currently there are the following types of segments, which the
  640.         hypertext.datatype supports :
  641.             HTST_NORMAL -- normal text
  642.             HTST_DTOBJECT -- datatypes object, which supports DTM_DRAW method
  643.             HTST_SEPARATOR -- horizontal separator line
  644.             HTST_STARTPARAGRAPH -- start paragraph definition
  645.             HTST_ENDPARAGRAPH -- end paragraph definition
  646.             HTST_TAB -- a tabstop
  647.             HTST_SETTABS -- tabulator array definition
  648.             HTST_SETPARAGRAPH -- use current pixel width for paragraph
  649.                 indention
  650.  
  651.     TAGS
  652.         Tags for HTST_NORMAL :
  653.  
  654.             HTDTSA_Text -- (STRPTR) text to render
  655.  
  656.             HTDTSA_TextLen -- (UWORD) length of text from HTDTSA_Text
  657.  
  658.             HTDTSA_XOffset -- (UWORD) x offset for this segment.
  659.                 Defaults to the end of the last segment.
  660.                 NOTE: Obsolete
  661.  
  662.             HTDTSA_YOffset -- (UWORD) y offset for this segment. This is only
  663.                 usefull, if you don't call the HTDTM_LAYOUT method. But this
  664.                 isn't recommended.
  665.                 NOTE: Obsolete
  666.  
  667.             HTDTSA_Width -- (UWORD) width of this segment. For all currently
  668.                 supported segment types (HTST_#?) this attribute is calculated.
  669.  
  670.             HTDTSA_Height -- (UWORD) height of this segment. For all currently
  671.                 supported segment types (HTST_#?) this attribute is calculated.
  672.  
  673.             HTDTSA_Flags -- (ULONG) flags used for this segment. The following
  674.                 Flags are currently supported :
  675.                     HTSF_LF -- line feed, end of line marker
  676.                     HTSF_BR -- line break even in smartwrap mode
  677.                     HTSF_LINK -- it's a link, a bevelborder would be drawn
  678.                     HTSF_ITEM -- segment is a first level item (like HTML <DT>
  679.                         tag)
  680.                     HTSF_ITEM2 -- segment is a second level item (like HTML
  681.                         <DD> tag)
  682.  
  683.             HTDTSA_LayoutFlags -- (ULONG) layout flags to use :
  684.                     HTSLF_JCENTER -- center this segment
  685.                     HTSLF_JRIGHT -- layout this segment most right
  686.                     HTSLF_WRAP -- this segment can be wrapped
  687.  
  688.             HTDTSA_FgPen -- (UBYTE) foreground pen for the text in this
  689.                 segment.
  690.  
  691.             HTDTSA_BgPen -- (UBYTE) background pen for the text in this
  692.                 segment.
  693.  
  694.             HTDTSA_Style -- (UBYTE) FSF_#? flags for the text style.
  695.  
  696.             HTDTSA_TextFont -- (struct TextFont *) font to use for the text.
  697.  
  698.             HTDTSA_LinkType -- (UWORD) type of the link, which describes the
  699.                 HTDTSA_LinkData attribute. Following types exists:
  700.                     HTLKT_NODE -- amigaguide style nodename
  701.                     HTLKT_OBJECT -- complete filename to a file, opened with
  702.                         NewDTObjectA().
  703.                     HTLKT_RX -- complete filename to a arexx macro
  704.                     HTLKT_RXS -- arexx commmand string
  705.                     HTLKT_SYSTEM -- a complete filename to a program
  706.                     HTLKT_QUIT -- just quit current application of this object
  707.                         by sending a SIGBREAKF_CTRL_C signal.
  708.                     HTLKT_USER -- user defined linktype (subclasses).
  709.  
  710.             HTDTSA_LinkData -- (APTR) link data. See HTDTSA_LinkType above.
  711.  
  712.             HTDTSA_AllocText -- (BOOL) if set to TRUE, the text given by the
  713.                 HTDTSA_Text tag should be copied in a own memory region. This
  714.                 is done by allocating new memory from the SegInfo pool.
  715.  
  716.             HTDTSA_AllocLink -- (BOOL) if set to TRUE, the text given by the
  717.                 HTDTSA_LinkData tag should be copied in a own memory region.
  718.                 This is done by allocating new memory from the SegInfo pool.
  719.                 Note the LinkData must be e zero terminated string to use
  720.                 this Tag!
  721.  
  722.         Tags for HTST_DTOBJECT :
  723.  
  724.             HTDTSA_Name -- (STRPTR) name of the object to open via
  725.                 NewDTObjectA()
  726.  
  727.         Tags for HTST_SEPARATOR :
  728.  
  729.             HTDTSA_Height -- (ULONG) height of the separator.
  730.                 Not implemented yet.
  731.  
  732.             HTDTSA_Style -- (ULONG) style of the separator bar. SEPS_#?
  733.                 values.
  734.  
  735.         Tags for HTST_STARTPARAGRAPH :
  736.  
  737.             HTDTSA_ParaIndent -- (LONG) number of chars to indent the first
  738.                 line of the paragraph. This can be negative.
  739.  
  740.             HTDTSA_BodyIndent -- (ULONG) number of chars to indent the body of
  741.                 the paragraph.
  742.  
  743.         Tags for HTST_ENDPARAGRAPH :
  744.  
  745.             none
  746.  
  747.         Tags for HTST_TAB :
  748.  
  749.             HTDTSA_NumTabs -- (ULONG) number of tabstops
  750.  
  751.         Tags for HTST_SETTABS :
  752.  
  753.             HTDTSA_TabStops -- (UWORD *) ~0 terminated array of character
  754.                 positions to use for tabs. This array is copied.
  755.  
  756.         Tags for HTST_SETPARAGRAPH :
  757.  
  758.             none.
  759.  
  760.         Tags for HTST_STARTLIST :
  761.  
  762.             HTDTSA_ListType -- (ULONG) type of the list HTSLIT_#? values.
  763.                 HTSLIT_ITEMIZE -- HTML <UL> style list
  764.                 HTSLIT_ENUMERATION -- HTML <OL> style list
  765.                 HTSLIT_DEFINITION -- HTML <DL> style list
  766.                 Defaults to HTSLIT_ITEMIZE.
  767.  
  768.             HTDTSA_ListItemFormat -- (STRPTR) format string for each item
  769.                 introducer. Not implemented yet.
  770.  
  771.         Tags for HTST_ENDLIST :
  772.  
  773.             HTDTSA_ListType -- type of the list HTSLIT_#? values.
  774.  
  775.         Tags for HTST_LABEL :
  776.  
  777.             HTDTSA_Label -- (STRPTR) label name
  778.  
  779.             HTDTSA_LabelLen -- (ULONG) length of label name
  780.  
  781.         Tags for HTST_GADGET :
  782.  
  783.             Not implemented yet.
  784.  
  785.     INPUTS
  786.         segInfo -- (APTR) info structure from AllocSegInfoA()
  787.         type -- (ULONG) type of the segment see HTST_#? values
  788.         tagList -- (struct TagItem *) list of attributes for the segment
  789.  
  790.     RESULTS
  791.         pointer to a HTSegment or NULL for failure.
  792.  
  793.     NOTES
  794.         The function uses the pool header specified in AllocSegInfoA()
  795.         function to allocate it's memory. So if you pass a pool, which is
  796.         used in more than one task, you have to arbitriate by yourself.
  797.  
  798.     SEE ALSO
  799.         FreeSegment(), exec.library/AllocPooled(),
  800.         datatypes.library/NewDTObjectA(), datatypes/hypertextclass.h
  801.  
  802. hypertext.datatype/ConvertAttributes      hypertext.datatype/ConvertAttributes
  803.  
  804.     NAME
  805.         ConvertAttributes -- convert AmigaGuide style attributes to internal
  806.                              representation
  807.  
  808.     SYNOPSIS
  809.         string = ConvertAttributes(convInfo,string,len)
  810.           D0                         A0       A1    D0
  811.  
  812.         STRPTR ConvertAttributes(struct HTConvInfo * ,STRPTR ,ULONG);
  813.  
  814.     FUNCTION
  815.         This function converts all attributes in the passed string
  816.         to internal representation. The format of the attribute must match
  817.         the one you specified in the AllocConvInfoA() function.
  818.         After you performed this function all converted attributes are set
  819.         in the TagItem list, which you passed to AllocConvInfoA().
  820.         Currently supported Tags are :
  821.  
  822.             HTDTSA_LayoutFlags -- for justifation attributes
  823.             HTDTSA_FgPen -- text color
  824.             HTDTSA_BgPen -- background color
  825.             HTDTSA_Style -- font style
  826.             HTDTSA_TextFont -- textfont
  827.  
  828.         The converting is stopped, if len characters are converted or if
  829.         the next to convert character is not a attribute introducer of the
  830.         specified format.
  831.         If a attribute isn't known by this function, the HTDTM_CONVATTRIB
  832.         method is invoked on the object.
  833.  
  834.     INPUTS
  835.         convInfo -- (struct HTConvInfo *) info struct from AllocConvInfoA()
  836.         string -- (STRPTR) string to convert
  837.         len -- (ULONG) maximal length of the string
  838.  
  839.     RESULTS
  840.         string -- pointer to the next to last converted character.
  841.  
  842.     ATTRIBUTES
  843.         @{apen <pennum>} -- Used to change the foreground color to a specific
  844.             pen number.
  845.  
  846.         @{b} -- Turn bold on.
  847.  
  848.         @{bg <colortext>} -- Used to change the background text color. Color
  849.             can be :
  850.  
  851.                 Text
  852.                 Shine
  853.                 Shadow
  854.                 Fill
  855.                 FillText
  856.                 Background
  857.                 Highlight
  858.  
  859.         @{bpen <pennum>} -- Used to change the background color to a specific
  860.             pen number.
  861.  
  862.         @{stdfont} -- Reset to standard font.
  863.  
  864.         @{fg <colortext>} -- Used to change the foreground text color. The same
  865.             colors can be used as in the bg command.
  866.  
  867.         @{font <fontname>[,<size>]} -- Used to set a TextFont, with name
  868.             <fontname> and size <size>. If size isn't specified 8 is used.
  869.  
  870.         @{i} -- Turn italic on.
  871.  
  872.         @{jcenter} -- Turn centering on.
  873.  
  874.         @{jleft} -- Turn on left justification.
  875.  
  876.         @{jright} -- Turn on right justification.
  877.  
  878.         @{plain} -- reset font style to normal.
  879.  
  880.         @{u} -- Turn underline on.
  881.  
  882.         @{ub} -- Turn bold off.
  883.  
  884.         @{ui} -- Turn italic off.
  885.  
  886.         @{uu} -- Turn underline off.
  887.  
  888.     EXAMPLE
  889.         struct HTSegInfo *seginfo;
  890.  
  891.         if((seginfo = AllocSegInfo(HTDTSIA_Pool,pool,
  892.                                    HTDTSIA_Object,obj,
  893.                                    HTDTSIA_GadgetInfo,msg->gpl_GInfo,
  894.                                    TAG_DONE)) != NULL)
  895.         {
  896.            struct HTConvInfo *convinfo;
  897.            struct TagItem tags[5];
  898.  
  899.            /* AllocConvInfoA() setup defaults, so we only need to provide
  900.             * the Tag id's
  901.             */
  902.            tags[0].ti_Tag  = HTDTSA_Flags;
  903.            tags[1].ti_Tag  = HTDTSA_FgPen;
  904.            tags[2].ti_Tag  = HTDTSA_BgPen;
  905.            tags[3].ti_Tag  = HTDTSA_Style;
  906.            tags[4].ti_Tag  = TAG_DONE;
  907.  
  908.            /* allocate the convert info structure for the TagItem array
  909.             * tags[]
  910.             */
  911.            if((convinfo = AllocConvInfoA(seginfo,tags,NULL)) != NULL)
  912.            {
  913.               STRPTR buffer = "@{fg highlight}highlighted Text@{fg text}";
  914.               STRPTR ptr = buffer;
  915.               STRPTR seg,endseg;
  916.  
  917.               seg = ptr;
  918.               while(*ptr != '\0')
  919.               {
  920.                  endseg = ptr;
  921.                  if(*ptr == '@')
  922.                  {
  923.                     /* is there a outstanding segment with old attributes ?
  924.                      * if there is, allocate a segment.
  925.                      */
  926.                     if(seg < endseg)
  927.                        AllocSegment(seginfo,HTST_NORMAL,
  928.                                     HTDTSA_Text,seg,
  929.                                     HTDTSA_TextLen,endseg-seg,
  930.                                     TAG_MORE,tags);
  931.  
  932.                     /* now convert the new attributes to the internal
  933.                      *  data representation in the TagArray tags[]
  934.                      */
  935.                     ptr = ConvertAttributes(convinfo,ptr,strlen(ptr));
  936.  
  937.                     /* set now the beginning of the next segment */
  938.                     seg = ptr + 1;
  939.                  }
  940.  
  941.                  ptr++;
  942.               }
  943.               /* is there a outstanding segment ? */
  944.               if(seg < endseg)
  945.                  AllocSegment(seginfo,HTST_NORMAL,
  946.                               HTDTSA_Text,seg,
  947.                               HTDTSA_TextLen,endseg-seg,
  948.                               TAG_MORE,tags);
  949.  
  950.               FreeConvInfo(convinfo);
  951.            }
  952.            FreeSegInfo(seginfo);
  953.         }
  954.  
  955.     SEE ALSO
  956.         AllocConvInfoA(), HTDTM_CONVATTRIB, hyperguide.datatype,
  957.         hypertext.datatype
  958.  
  959. hypertext.datatype/FreeConvInfo                hypertext.datatype/FreeConvInfo
  960.  
  961.     NAME
  962.         FreeConvInfo -- free's the structure allocated by AllocConvInfoA()
  963.  
  964.     SYNOPSIS
  965.         FreeConvInfo(convinfo);
  966.                         A0
  967.  
  968.         void FreeConvInfo(struct HTConvInfo *);
  969.  
  970.     FUNCTION
  971.         Free's all resources allocated by AllocConvInfoA() function.
  972.  
  973.     INPUTS
  974.         convinfo -- (struct HTConvInfo *) pointer from AllocConvInfoA().
  975.  
  976.     RESULTS
  977.         none
  978.  
  979.     SEE ALSO
  980.         AllocConvInfoA()
  981.  
  982. hypertext.datatype/FreeSegInfo                  hypertext.datatype/FreeSegInfo
  983.  
  984.     NAME
  985.         FreeSegInfo -- free's resources allocated from AllocSegInfoA()
  986.  
  987.     SYNOPSIS
  988.         FreeSegInfo(seginfo);
  989.                       A0
  990.  
  991.         void FreeSegInfo(APTR);
  992.  
  993.     FUNCTION
  994.         This function free's all resources allocted by AllocSegInfoA().
  995.  
  996.     INPUTS
  997.         seginfo -- (APTR) pointer from AllocSegInfoA(). May be NULL.
  998.  
  999.     NOTES
  1000.         The function uses the pool header given by AllocSegInfoA(). So if
  1001.         this pool is used in more than one task, you have to arbitriate by
  1002.         yourself.
  1003.  
  1004.     SEE ALSO
  1005.         AllocSegInfoA(), AllocSegmentA(), FreeSegment()
  1006.  
  1007. hypertext.datatype/FreeSegment                  hypertext.datatype/FreeSegment
  1008.  
  1009.     NAME
  1010.         FreeSegment -- Free's all resources allocated by AllocSegment()
  1011.  
  1012.     SYNOPSIS
  1013.         FreeSegment(segInfo,segment);
  1014.                       A0      A1
  1015.  
  1016.         void FreeSegment(APTR ,struct HTSegment *);
  1017.  
  1018.     FUNCTION
  1019.         This function free's a segment allocated by AllocSegmentA().
  1020.  
  1021.     INPUTS
  1022.         segInfo -- (APTR) info structure from AllocSegInfoA()
  1023.         segment -- (struct HTSegment *) structure from AllocSegmentA()
  1024.  
  1025.     NOTES
  1026.         The function uses the pool header specified in AllocSegInfoA()
  1027.         function to allocate it's memory. So if you pass a pool, which is
  1028.         used in more than one task, you have to arbitriate by yourself.
  1029.  
  1030.     SEE ALSO
  1031.         AllocSegmentA()
  1032.  
  1033. hypertext.datatype/DTM_CLEARSELECTED      hypertext.datatype/DTM_CLEARSELECTED
  1034.  
  1035.     NAME
  1036.         DTM_CLEARSELECTED -- clear the selected area
  1037.  
  1038.     FUNCTION
  1039.         This method clears a selected area and redraws the object if needed.
  1040.  
  1041.     INPUTS
  1042.         none
  1043.  
  1044.     RESULTS
  1045.         none
  1046.  
  1047.     NOTES
  1048.         Only available in the registered version!
  1049.  
  1050.     SEE ALSO
  1051.         DTM_SELECT
  1052.  
  1053. hypertext.datatype/DTM_COPY                        hypertext.datatype/DTM_COPY
  1054.  
  1055.     NAME
  1056.         DTM_COPY -- copies selected or whole document to cliaboard
  1057.  
  1058.     FUNCTION
  1059.         This method copies a selected area or the whole document to clipboard.
  1060.         ANSI character control sequences are also included.
  1061.  
  1062.     INPUTS
  1063.         struct dtGeneral
  1064.         {
  1065.             ULONG MethodID;
  1066.             struct GadgetInfo *dtg_GInfo;
  1067.         };
  1068.  
  1069.     RESULTS
  1070.         TRUE for success, FALSE for failure.
  1071.  
  1072.     SEE ALSO
  1073.         DTM_WRITE, DTM_PRINT, HTDTM_EXPORT
  1074.  
  1075. hypertext.datatype/DTM_FRAMEBOX                hypertext.datatype/DTM_FRAMEBOX
  1076.  
  1077.     NAME
  1078.         DTM_FRAMEBOX -- provide rendering informations about the object
  1079.  
  1080.     FUNCTION
  1081.         This method provides rendering informations about the hypertext
  1082.         object, mainly the number of needed colors.
  1083.  
  1084.     INPUTS
  1085.         struct dtFrameBox
  1086.         {
  1087.             ULONG MethodID;
  1088.             struct GadgetInfo *dtf_GInfo;
  1089.             struct FrameInfo *dtf_ContentsInfo;
  1090.             struct FrameInfo *dtf_FrameInfo;
  1091.             ULONG dtf_SizeFrameInfo;
  1092.             ULONG dtf_FrameFlags;
  1093.         };
  1094.  
  1095.         dtf_ContentsInfo -- information on the environment the application
  1096.             provides the object
  1097.         dtf_FrameInfo -- structure to put the information in
  1098.         dtf_SizeFrameInfo -- size of FrameInfo structure
  1099.         dtf_FrameFlags -- FRAMEF_SPECIFY
  1100.  
  1101.     RESULTS
  1102.         non-zero for success, zero for failure
  1103.  
  1104.     SEE ALSO
  1105.         datatypesclass/DTM_FRAMEBOX
  1106.  
  1107. hypertext.datatype/DTM_GOTO                        hypertext.datatype/DTM_GOTO
  1108.  
  1109.     NAME
  1110.         DTM_GOTO -- load and display an other object.
  1111.  
  1112.     FUNCTION
  1113.         This method is used to load and display an other object.
  1114.         There are some limitations for subclass implementors, which
  1115.         have to be observed. First a subclass implementation have to
  1116.         check if it runs on a process context using the HTDTM_HTPROC
  1117.         method (see EXAMPLES section) and if not it must call
  1118.         immediately the SuperClass and leave the method. Then
  1119.         SuperClass take care of calling the method on its process
  1120.         context. If HTDTM_HTPROC returns TRUE the subclass
  1121.         implementation can locate its object and pass the found
  1122.         object to the SuperClass. If the path to the object isn't
  1123.         a absolute path the following search algorithm is used by
  1124.         the SuperClass to locate the object :
  1125.  
  1126.         1. It tries to locate the object relative to the base objects
  1127.            directory.
  1128.         2. It tries to locate the object relative to the base objects path
  1129.            list directories.
  1130.         3. It tries to locate the object relative to the current directory of
  1131.            the current process.
  1132.         4. It tries to locate the object relative to a directory with the
  1133.            default language name of current directory of the current process.
  1134.         5. It tries to locate the object relative to the list of pathes, which
  1135.            are configured through the hypertext.prefs file.
  1136.            For each entry in this list the directory itself and the directory
  1137.            with the default language name appended are searched.
  1138.  
  1139.     INPUTS
  1140.         struct dtGoto
  1141.         {
  1142.             ULONG MethodID;
  1143.             struct GadgetInfo *dtg_GInfo;
  1144.             STRPTR dtg_NodeName;
  1145.             struct TagItem *dtg_AttrList;
  1146.         };
  1147.  
  1148.         dtg_NodeName -- name of the node to go to. This also can be a complete
  1149.             filename.
  1150.         dtg_AttrList -- list of attributes, which specifies the object to go to.
  1151.  
  1152.     ATTRIBUTES
  1153.         Attributes, which can be used for dtg_AttrList :
  1154.  
  1155.         HTDTSA_LinkType (ULONG) -- specifies the type of the link to go to.
  1156.             This controls the object locating routine. There are two possible
  1157.             values. HTLKT_NODE indicates, that the given destination name is
  1158.             a AmigaGuide/HyperGuide style name. HTLKT_OBJECT indicates that
  1159.             the destination name is simple file name.
  1160.  
  1161.             Defaults to HTLKT_OBJECT.
  1162.  
  1163.         HTDTSA_LinkName (STRPTR) -- specifies the name of the object to go to.
  1164.  
  1165.             Defaults to dtg_NodeName.
  1166.  
  1167.     EXAMPLES
  1168.         /* subclass DTM_GOTO implementation */
  1169.  
  1170.         /* make sure we are in the objects process context */
  1171.         if(!DoSuperMethod(cl,obj,HTDTM_HTPROC))
  1172.            rc = DoSuperMethodA(cl,obj,(Msg) msg);
  1173.         else
  1174.         {
  1175.            struct TagItem tags[3] =
  1176.            {
  1177.               {HTDTSA_LinkType,HTLKT_OBJECT},
  1178.               {HTDTSA_LinkData,NULL},
  1179.               {TAG_DONE,0}
  1180.            };
  1181.  
  1182.            /* now do your locating stuff */
  1183.            tags[1].ti_Data = (ULONG) "Work:MyObject/To/Go/To";
  1184.  
  1185.            /* then pass your path/node to the super class */
  1186.            rc = DoSuperMethod(cl,obj,DTM_GOTO,msg->dtg_GInfo,NULL,&tags[0]);
  1187.         }
  1188.  
  1189.     SEE ALSO
  1190.  
  1191. hypertext.datatype/DTM_PRINT                      hypertext.datatype/DTM_PRINT
  1192.  
  1193.     NAME
  1194.         DTM_PRINT -- print the current document
  1195.  
  1196.     FUNCTION
  1197.         This method prints the current document or the currently selected
  1198.         area. It supports only printing of texts and tries to layout the
  1199.         printing result as close as shown on the screen.
  1200.  
  1201.     INPUTS
  1202.         struct dtPrint
  1203.         {
  1204.             ULONG MethodID;
  1205.             struct GadgetInfo *dtp_GInfo;
  1206.             union printerIO *dtp_PIO;
  1207.             struct TagItem *dtp_AttrList;
  1208.         };
  1209.  
  1210.         dtp_PIO -- functional IORequest structures.
  1211.         dtp_AttrList -- additional attributes (currently none)
  1212.  
  1213.     RESULTS
  1214.        zero for success, non-zero for a failure.
  1215.  
  1216.     SEE ALSO
  1217.        DTM_WRITE, DTM_COPY
  1218.  
  1219. hypertext.datatype/DTM_REMOVEDTOBJECT    hypertext.datatype/DTM_REMOVEDTOBJECT
  1220.  
  1221.     NAME
  1222.         DTM_REMOVEDTOBJECT -- remove datatype object from a window
  1223.  
  1224.     FUNCTION
  1225.         This method is used to clear any cached variables like window pointer
  1226.         the object is attached to. After clearing all such variables the
  1227.         method is directly passed to its superclass.
  1228.  
  1229.     INPUTS
  1230.         none
  1231.  
  1232.     RESULTS
  1233.         superclass results
  1234.  
  1235.     SEE ALSO
  1236.         datatypesclass/DTM_REMOVEDTOBJECT, datatypes.library/AddDTObject(),
  1237.         datatypes.library/RemoveDTObject()
  1238.  
  1239. hypertext.datatype/DTM_SELECT                    hypertext.datatype/DTM_SELECT
  1240.  
  1241.     NAME
  1242.         DTM_SELECT -- selects the given rectangle
  1243.  
  1244.     FUNCTION
  1245.         This method selects the given rectangle and redraws the object.
  1246.  
  1247.     INPUTS
  1248.         struct dtSelect
  1249.         {
  1250.             ULONG MethodID;
  1251.             struct GadgetInfo *dts_GInfo;
  1252.             struct Rectangle dts_Select;
  1253.         };
  1254.  
  1255.         dts_Select -- selected rectangle
  1256.  
  1257.     RESULTS
  1258.         none
  1259.  
  1260.     NOTES
  1261.         Only available in the registered version!
  1262.  
  1263.     SEE ALSO
  1264.         DTM_CLEARSELECTED, HTDTM_RENDER
  1265.  
  1266. hypertext.datatype/DTM_TRIGGER                  hypertext.datatype/DTM_TRIGGER
  1267.  
  1268.     NAME
  1269.         DTM_TRIGGER -- trigger a function of the hypertext object
  1270.  
  1271.     FUNCTION
  1272.         This method is used to trigger a special hypertext object function.
  1273.         The following trigger functions are supported by the
  1274.         hypertext.datatype :
  1275.  
  1276.             STM_NEXT_FIELD -- highlight next link
  1277.  
  1278.             STM_PREV_FIELD -- highlight previous link
  1279.  
  1280.             STM_ACTIVATE_FIELD -- activate actual highlighted link
  1281.  
  1282.             STM_RETRACE -- retrace to previously viewed node
  1283.  
  1284.             STM_COMMAND -- dtt_Data contains a ARexx command string, which
  1285.                 will be executed
  1286.  
  1287.             STM_CONTENTS -- activate contents node of the actual viewed node
  1288.  
  1289.             STM_INDEX -- activate index node of actual viewed node
  1290.  
  1291.             STM_BROWSE_PREV -- activate logical previous node of actual viewed
  1292.                 node
  1293.  
  1294.             STM_BROWSE_NEXT -- activate logical next node of actual viewed
  1295.                 node
  1296.  
  1297.     INPUTS
  1298.         struct dtTrigger
  1299.         {
  1300.             ULONG MethodID;
  1301.             struct GadgetInfo *dtt_GInfo;
  1302.             ULONG dtt_Function;
  1303.             APTR dtt_Data;
  1304.         };
  1305.  
  1306.         dtt_Function -- STM_#? functions
  1307.         dtt_Data -- user data for STM_#? values
  1308.  
  1309.     RESULTS
  1310.         none
  1311.  
  1312.     SEE ALSO
  1313.         datatypesclass/DTM_TRIGGER, DTM_GOTO
  1314.  
  1315. hypertext.datatype/DTM_WRITE                      hypertext.datatype/DTM_WRITE
  1316.  
  1317.     NAME
  1318.         DTM_WRITE -- write the current document to a file
  1319.  
  1320.     FUNCTION
  1321.         This method writes the current document or the selected area to a
  1322.         file. Only the DTWM_RAW mode is supported, which outputs the document
  1323.         in ASCII with ANSI escape control sequences. In future there might be
  1324.         an output of a new defined HyperText IFF standard.
  1325.  
  1326.     INPUTS
  1327.         struct dtWrite
  1328.         {
  1329.             ULONG MethodID;
  1330.             struct GadgetInfo *dtw_GInfo;
  1331.             BPTR dtw_FileHandle;
  1332.             ULONG dtw_Mode;
  1333.             struct TagItem *dtw_AttrList;
  1334.         };
  1335.  
  1336.         dtw_FileHandle -- file to write to
  1337.         dtw_Mode -- DTWM_IFF or DTWM_RAW
  1338.         dtw_AttrList -- additional attributes (currently none)
  1339.  
  1340.     RESULTS
  1341.         zero for success, non-zero for a failure
  1342.  
  1343.     SEE ALSO
  1344.         HTDTM_EXPORT, DTM_COPY, DTM_PRINT
  1345.  
  1346. hypertext.datatype/GM_GOACTIVE                  hypertext.datatype/GM_GOACTIVE
  1347.  
  1348.     NAME
  1349.         GM_GOACTIVE -- handles the first input event for a hypertext object
  1350.  
  1351.     FUNCTION
  1352.         This method is exactly GM_HANDLEINPUT.
  1353.  
  1354.     SEE ALSO
  1355.         datatypesclass/GM_HANDLEINPUT, GM_HANDLEINPUT, GM_GOINACTIVE
  1356.  
  1357. hypertext.datatype/GM_HANDLEINPUT            hypertext.datatype/GM_HANDLEINPUT
  1358.  
  1359.     NAME
  1360.         GM_HANDLEINPUT -- handles all input events for a hypertext object
  1361.  
  1362.     FUNCTION
  1363.         This method handles all input events for a hypertext object. Currently
  1364.         only mouse events are processed. It handles all mouse event and render
  1365.         links according to their state. All mouse events, which doesn't
  1366.         corresond to link are passed to the superclass.
  1367.  
  1368.     SEE ALSO
  1369.         datatypesclass/GM_HANDLEINPUT, GM_GOACTIVE, GM_GOINACTIVE
  1370.  
  1371. hypertext.datatype/GM_LAYOUT                      hypertext.datatype/GM_LAYOUT
  1372.  
  1373.     NAME
  1374.         GM_LAYOUT -- layout the hypertext object
  1375.  
  1376.     FUNCTION
  1377.         This method layouts the navigator gadget and calculates the new inner
  1378.         dimension of the hypertext object. Thus any subclass implementor have
  1379.         to call the superclass first and only invoke its own layout method, if
  1380.         the result of the call is zero! Typically a subclass allocates all
  1381.         hypertext segments within the first call of this method
  1382.         (gpl_Initial == TRUE). After this and for all !gpl_Initial invocations
  1383.         it have to invoke the HTDTM_LAYOUT method.
  1384.  
  1385.     INPUTS
  1386.         struct gpLayout
  1387.         {
  1388.            ULONG MethodID;
  1389.            struct GadgetInfo *gpl_GInfo;
  1390.            ULONG gpl_Initial;
  1391.         };
  1392.  
  1393.         gpl_Initial - First call of GM_LAYOUT for this object
  1394.  
  1395.     RESULT
  1396.         0 - perform layout of the subclass
  1397.         1 - don't perform layout of the subclass
  1398.  
  1399.     EXAMPLE
  1400.         /* example GM_LAYOUT method for a subclass */
  1401.         ...
  1402.         case GM_LAYOUT:
  1403.             NotifyAttrs(obj, ((struct gpLayout *) msg)->gpl_GInfo, NULL,
  1404.                         GA_ID,       ((struct Gadget *) obj)->GadgetID,
  1405.                         DTA_Busy,    TRUE,
  1406.                         TAG_DONE);
  1407.  
  1408.             if((rc = DoSuperMethodA(cl,obj,msg)) == 0)
  1409.             {
  1410.                 /* we need to do this one asynchronously /*
  1411.                 rc = DoAsyncLayout (obj, (struct gpLayout *) msg);
  1412.             }
  1413.             break;
  1414.         ...
  1415.  
  1416.     SEE ALSO
  1417.         HTDTM_LAYOUT, gadgetclass/GM_LAYOUT
  1418.  
  1419. hypertext.datatype/GM_RENDER                      hypertext.datatype/GM_RENDER
  1420.  
  1421.     NAME
  1422.         GM_RENDER -- render the object
  1423.  
  1424.     FUNCTION
  1425.         This method is used to render the object itself. This method is maybe
  1426.         invoked from input.device task, thus there are all limitations for
  1427.         exec tasks (e.g. no dos calls). Therefore this method is designed
  1428.         asyncronly. When this method is invoked it sends a message to the
  1429.         object privates process, which then renders the object on its context.
  1430.         This also provides a faster response to the user (e.g. if the user
  1431.         scrolls fast in an object).
  1432.  
  1433.     INPUTS
  1434.         struct gpRender
  1435.         {
  1436.             ULONG MethodID;
  1437.             struct GadgetInfo *gpr_GInfo;
  1438.             struct RastPort *gpr_RPort;
  1439.             LONG gpr_Redraw;
  1440.         };
  1441.  
  1442.         gpr_RPort -- rastport to draw into.
  1443.         gpr_Redraw -- redraw mode. Currently only GREDRAW_REDRAW available.
  1444.  
  1445.     NOTE
  1446.         This method uses internal structures, which are created during the
  1447.         initial layout. Thus this method have NOT to be overwritten!
  1448.  
  1449.     SEE ALSO
  1450.         gadgetclass/GM_RENDER, HTDTM_RENDER
  1451.  
  1452. hypertext.datatype/HTDTM_ALLOCVEC            hypertext.datatype/HTDTM_ALLOCVEC
  1453.  
  1454.     NAME
  1455.         HTDTM_ALLOCVEC -- allocate memory from the hypertext objects pool.
  1456.  
  1457.     FUNCTION
  1458.         This method is used to allocate memory from the hypertext objects
  1459.         memory pool. This memory have to be freed using the HTDTM_FREEVEC
  1460.         method or its freed if the object is disposed through the OM_DISPOSE
  1461.         method. The sematics are equal to the AllocVec() of the exec.library,
  1462.         so you don't need to recognize the size of the allocated memory block.
  1463.         Also this method does the needed arbitration for the used memory pool.
  1464.         So if you don't know, if you are the only task which allocates memory
  1465.         from the objects memory pool just use this method.
  1466.  
  1467.     INPUTS
  1468.         struct htAllocVec
  1469.         {
  1470.            ULONG MethodID;
  1471.            struct GadgetInfo *dt_GInfo;
  1472.            ULONG htav_Size;
  1473.         };
  1474.  
  1475.         htav_Size -- size of the memory block to allocate
  1476.  
  1477.     RESULTS
  1478.         NULL for failure, otherwise a pointer to the new allocated memory.
  1479.  
  1480.     SEE ALSO
  1481.         exec.library/AllocVec(), exec.library/AllocPooled(), HTDTM_FREEVEC
  1482.  
  1483. hypertext.datatype/HTDTM_ATTEMPT              hypertext.datatype/HTDTM_ATTEMPT
  1484.  
  1485.     NAME
  1486.         HTDTM_ATTEMPT -- attempt exclusive access to the hypertext object.
  1487.  
  1488.     FUNCTION
  1489.         This method is used to attempt exclusive access to the hypertext
  1490.         object. Currently its the same as attempting access to the
  1491.         DTSpecialInfo semapore. But in future this might change so you have to
  1492.         use this method!
  1493.  
  1494.     INPUTS
  1495.         none
  1496.  
  1497.     RESULTS
  1498.         TRUE for success, FALSE for failure.
  1499.  
  1500.     SEE ALSO
  1501.         exec.library/AttemptSemaphore(), HTDTM_OBTAIN, HTDTM_RELEASE
  1502.  
  1503. hypertext.datatype/HTDTM_CONVATTRIB        hypertext.datatype/HTDTM_CONVATTRIB
  1504.  
  1505.     NAME
  1506.         HTDTM_CONVATTRIB -- converts additional HyperGuide style attributes.
  1507.  
  1508.     FUNCTION
  1509.         This method is used for SubClass implementations, which want to
  1510.         provide own HyperGuide style attributes. Each time the function
  1511.         ConvertAttributes() don't recognizes a attribute, it invokes this
  1512.         method.
  1513.  
  1514.     INPUTS
  1515.         struct htConvAttrib
  1516.         {
  1517.             ULONG MethodID;
  1518.             struct GadgetInfo *dt_GInfo;
  1519.             STRPTR htca_Keyword;
  1520.             ULONG htca_KeywordLen;
  1521.             STRPTR htca_Arguments;
  1522.             ULONG htca_ArgumentsLen;
  1523.             struct TagItem *htca_TagList;
  1524.             struct HTSegInfo *htca_SegInfo;
  1525.             struct HTConvInfo *htca_ConvInfo;
  1526.             APTR htca_UserData;
  1527.         };
  1528.  
  1529.         htca_Keyword -- attribute name
  1530.         htca_KeywordLen -- length of the attribute name
  1531.         htca_Arguments -- additional arguments for the attribute
  1532.         htca_ArgumentsLen -- length of arguments
  1533.         htca_TagList -- TagList passed to AllocConvInfoA()
  1534.         htca_SegInfo -- segment info returned by AllocSgeInfoA()
  1535.         htca_ConvInfo -- convert info returned by AllocConvInfoA()
  1536.         htca_UserData -- userdata passed to AllocConvInfoA() via
  1537.             HTDTCIA_UserData.
  1538.  
  1539.     RESULTS
  1540.         none
  1541.  
  1542.     SEE ALSO
  1543.         ConvertAttributes()
  1544.  
  1545. hypertext.datatype/HTDTM_EXPORT                hypertext.datatype/HTDTM_EXPORT
  1546.  
  1547.     NAME
  1548.         HTDTM_EXPORT -- export the current document
  1549.  
  1550.     FUNCTION
  1551.         This method exports the current document to clipboard or a file with
  1552.         the specified format type.
  1553.  
  1554.     INPUTS
  1555.         struct htExport
  1556.         {
  1557.             ULONG MethodID;
  1558.             struct GadgetInfo *dt_GInfo;
  1559.             STRPTR hte_Type;
  1560.             STRPTR hte_File;
  1561.             ULONG hte_Unit;
  1562.             STRPTR hte_Args;
  1563.         };
  1564.  
  1565.         hte_Type -- export format type (e.g. HTML)
  1566.         hte_File -- file to save the exported document
  1567.         hte_Unit -- unit number for clipboard (hte_File == NULL)
  1568.         hte_Args -- additional arguments for the export class
  1569.  
  1570.     RESULTS
  1571.         zero for success, non zero for a failure.
  1572.  
  1573.     NOTES
  1574.         Only available in the registered version!
  1575.  
  1576.     SEE ALSO
  1577.         HTDS.hguide
  1578.  
  1579. hypertext.datatype/HTDTM_FREEVEC              hypertext.datatype/HTDTM_FREEVEC
  1580.  
  1581.     NAME
  1582.         HTDTM_FREEVEC -- free memory from the hypertext objects pool.
  1583.  
  1584.     FUNCTION
  1585.         This method is used to free memory from the hypertext objects
  1586.         memory pool, which was allocated by the HTDTM_ALLOCVEC method.
  1587.         Also this method does the needed arbitration for the used memory pool.
  1588.         So if you don't know, if you are the only task which allocates memory
  1589.         from the objects memory pool just use this method.
  1590.  
  1591.     INPUTS
  1592.         struct htFreeVec
  1593.         {
  1594.            ULONG MethodID;
  1595.            struct GadgetInfo *dt_GInfo;
  1596.            ULONG htfv_Memory;
  1597.         };
  1598.  
  1599.         htfv_Memory -- pointer to the memory to free
  1600.  
  1601.     SEE ALSO
  1602.         exec.library/FreeVec(), exec.library/FreePooled(), HTDTM_ALLOCVEC
  1603.  
  1604. hypertext.datatype/HTDTM_GETFONT              hypertext.datatype/HTDTM_GETFONT
  1605.  
  1606.     NAME
  1607.         HTDTM_GETFONT -- opens and returns pointer of a TextFont
  1608.  
  1609.     FUNCTION
  1610.         This method opens and returns a pointer of a TextFont. It handles all
  1611.         needed calls to diskfont.library or graphics.library.
  1612.  
  1613.     INPUTS
  1614.         struct htGetFont
  1615.         {
  1616.            ULONG MethodID;
  1617.            struct GadgetInfo *htgf_GInfo;
  1618.            LONG htgf_FontNum;
  1619.            STRPTR htgf_FontName;
  1620.            ULONG htgf_FontSize;
  1621.         };
  1622.  
  1623.         htgf_FontNum  - obsolete
  1624.         htgf_FontName - name of the font. With or without the ".font" suffix.
  1625.         htgf_FontSize - y size of the font.
  1626.  
  1627.     RESULTS
  1628.         returns a pointer to the specified TextFont or NULL for failure.
  1629.  
  1630.     SEE ALSO
  1631.         graphics.library/OpenFont(), diskfont.library/OpenDiskFont()
  1632.  
  1633. hypertext.datatype/HTDTM_GUISEARCH          hypertext.datatype/HTDTM_GUISEARCH
  1634.  
  1635.     NAME
  1636.         HTDM_GUISEARCH -- opens the search requester
  1637.  
  1638.     FUNCTION
  1639.         This method is used to open the search requester to let the user input
  1640.         or change the search string or pattern.
  1641.  
  1642.     INPUTS
  1643.         struct htSearch
  1644.         {
  1645.             ULONG MethodID;
  1646.             struct GadgetInfo *dt_GInfo;
  1647.             STRPTR hts_String;
  1648.             LONG hts_StringLen;
  1649.             ULONG hts_Flags;
  1650.         };
  1651.  
  1652.         hts_String -- string or pattern to search for
  1653.         hts_StringLen -- length of the given string or pattern
  1654.         hts_Flags -- flags, which controls the search. Following flags are
  1655.             currently supported :
  1656.  
  1657.             HTDTSF_NOCASE -- ignore case
  1658.             HTDTSF_PATTERN -- string is a pattern
  1659.  
  1660.     RESULTS
  1661.        none
  1662.  
  1663.     SEE ALSO
  1664.        HTDTM_SEARCH
  1665.  
  1666. hypertext.datatype/HTDTM_HTPROC                hypertext.datatype/HTDTM_HTPROC
  1667.  
  1668.     NAME
  1669.         HTDTM_HTPROC -- tests if its on a process context
  1670.  
  1671.     FUNCTION
  1672.         Check if the current method is invoked on the separate hypertext
  1673.         object process. Note: If you overwrite some methods like DTM_GOTO, you
  1674.         have to check first if you are in that special process context, and if
  1675.         not you have to pass this method directly to superclass, so that this
  1676.         can signal the hypertext object process to do this method on its
  1677.         context. This strategy is needed to avoid problems with input task
  1678.         based method invocations.
  1679.  
  1680.     INPUTS
  1681.         none
  1682.  
  1683.     SEE ALSO
  1684.         DTM_GOTO
  1685.  
  1686. hypertext.datatype/HTDTM_LAYOUT                hypertext.datatype/HTDTM_LAYOUT
  1687.  
  1688.     NAME
  1689.         HTDTM_LAYOUT -- layout all hypertext object segments
  1690.  
  1691.     FUNCTION
  1692.         This method have to be invoked from the GM_LAYOUT method of subclasses
  1693.         of the hypertext.datatype. It layouts all allocated hypertext segments
  1694.         and calculate the correct positions of pictures and texts within a
  1695.         document. Thus it must be invoked after all segments are allocated
  1696.         during the GM_LAYOUT method. Then you invoke this method to layout the
  1697.         complete hypertext object. This method must also be invoked on any
  1698.         subsequent call of GM_LAYOUT, so it can calculate correct positions
  1699.         of centered or justified segments.
  1700.  
  1701.     INPUTS
  1702.         struct htLayout
  1703.         {
  1704.            ULONG MethodID;
  1705.            struct GadgetInfo *dt_GInfo;
  1706.            struct TagItem *htl_AttrList;
  1707.            ULONG htl_Initial;
  1708.         };
  1709.  
  1710.         htl_AttrList - Additional attributes. Currently non defined.
  1711.         htl_Initial  - First call of HTDTM_LAYOUT for this object
  1712.  
  1713.     RESULT
  1714.         returns total number of lines.
  1715.  
  1716.     SEE ALSO
  1717.         GM_LAYOUT
  1718.  
  1719. hypertext.datatype/HTDTM_LOADNODES          hypertext.datatype/HTDTM_LOADNODES
  1720.  
  1721.     NAME
  1722.         HTDTM_LOADNODES -- loads nodes for the current document
  1723.  
  1724.     FUNCTION
  1725.         This method tries to load all needed node information of the current
  1726.         document. Currently node informations are only stored in the documents
  1727.         icon. But in the future there may be a real database to hold the node
  1728.         informations.
  1729.  
  1730.     INPUTS
  1731.         struct htLoadNodes
  1732.         {
  1733.             ULONG MethodID;
  1734.             struct GadgetInfo *dt_GInfo;
  1735.             struct List *htln_List;
  1736.             ULONG htln_NodeSize;
  1737.         };
  1738.  
  1739.         htln_List -- list to append the loaded nodes
  1740.         htln_NodeSize -- size of your private node including the size of the
  1741.             struct HTNode.
  1742.  
  1743.     RESULTS
  1744.         FALSE, if nothing could be loaded or TRUE if the node information are
  1745.         still actual and loaded.
  1746.  
  1747.     SEE ALSO
  1748.         HTDTM_SAVENODES
  1749.  
  1750. hypertext.datatype/HTDTM_OBTAIN                hypertext.datatype/HTDTM_OBTAIN
  1751.  
  1752.     NAME
  1753.         HTDTM_OBTAIN -- obtain exclusive access to the hypertext object.
  1754.  
  1755.     FUNCTION
  1756.         This method is used to get exclusive access to the hypertext object.
  1757.         Currently its the same as obtaining the DTSpecialInfo semapore. But in
  1758.         future this might change so you have to use this method!
  1759.  
  1760.     INPUTS
  1761.         none
  1762.  
  1763.     SEE ALSO
  1764.         exec.library/ObtainSemaphore(), HTDTM_RELEASE, HTDTM_ATTEMPT
  1765.  
  1766. hypertext.datatype/HTDTM_OBTAINPEN          hypertext.datatype/HTDTM_OBTAINPEN
  1767.  
  1768.     NAME
  1769.         HTDTM_OBTAINPEN -- obtain a specific color pen
  1770.  
  1771.     FUNCTION
  1772.         This method is used to obtain a specific color pen. It is possible to
  1773.         pass a string, which will be converted by this method into the
  1774.         appropriate color. This string can be one of the following color
  1775.         names :
  1776.  
  1777.         Black, Green, Silver, Lime, Gray, Olive, White, Yellow, Maroon, Navy
  1778.         Red, Blue, Purple, Teal, Fuchsia, Aqua.
  1779.  
  1780.         Or a string which represents the RGB values with "#RRGGBB" format.
  1781.         Each letter represents a hexadecimal digit.
  1782.  
  1783.         If there is no string given (NULL), the method tries to obtain the
  1784.         color specified by the RGB values.
  1785.  
  1786.     INPUTS
  1787.         struct htObtainPen
  1788.         {
  1789.            ULONG MethodID;
  1790.            struct GadgetInfo *dt_GInfo;
  1791.            STRPTR htop_String;
  1792.            ULONG htop_StringLen;
  1793.            ULONG htop_Red;
  1794.            ULONG htop_Green;
  1795.            ULONG htop_Blue;
  1796.         };
  1797.  
  1798.         htop_String -- pointer to the color string or NULL.
  1799.         htop_StringLen -- length of the htop_String.
  1800.         htop_Red -- red level 32 bit.
  1801.         htop_Green -- green level 32 bit.
  1802.         htop_Blue -- blue lebel 32 bit.
  1803.  
  1804.     RESULTS
  1805.         returns the pen number or -1 for a failure.
  1806.  
  1807.     NOTES
  1808.         This method works only if the hypertext object was added to a window
  1809.         with the AddDTObject() function.
  1810.  
  1811.     SEE ALSO
  1812.         graphics.library/ObtainBestPenA()
  1813.  
  1814. hypertext.datatype/HTDTM_RELEASE              hypertext.datatype/HTDTM_RELEASE
  1815.  
  1816.     NAME
  1817.         HTDTM_RELEASE -- release exclusive access of a hypertext object.
  1818.  
  1819.     FUNCTION
  1820.         This method is used to release a exclusive access to a hypertext
  1821.         object done by the HTDTM_OBTAIN method. Currently its the same as
  1822.         releasing the DTSpecialInfo semapore. But in future this might change
  1823.         so you have to use this method!
  1824.  
  1825.     INPUTS
  1826.         none
  1827.  
  1828.     SEE ALSO
  1829.         exec.library/ReleaseSemaphore(), HTDTM_OBTAIN, HTDTM_ATTEMPT
  1830.  
  1831. hypertext.datatype/HTDTM_RENDER                hypertext.datatype/HTDTM_RENDER
  1832.  
  1833.     NAME
  1834.         HTDTM_RENDER -- render the hypertext object on its own process.
  1835.  
  1836.     FUNCTION
  1837.         This function is used to render the hypertext object on its own
  1838.         process.
  1839.  
  1840.     INPUTS
  1841.         none
  1842.  
  1843.     SEE ALSO
  1844.         GM_RENDER
  1845.  
  1846. hypertext.datatype/HTDTM_SAVENODES          hypertext.datatype/HTDTM_SAVENODES
  1847.  
  1848.     NAME
  1849.         HTDTM_SAVENODES -- save node informations of the current document
  1850.  
  1851.     FUNCTION
  1852.         This method tries to save the node informations given by the specified
  1853.         list. The list have to contain HTNode structures.
  1854.  
  1855.     INPUTS
  1856.        struct htSaveNodes
  1857.        {
  1858.            ULONG MethodID;
  1859.            struct GadgetInfo *dt_GInfo;
  1860.            struct List *htsn_List;
  1861.        };
  1862.  
  1863.        htsn_List -- list of node informations to save
  1864.  
  1865.     RESULTS
  1866.        TRUE if the node information could be saved, otherwise FALSE.
  1867.  
  1868.     SEE ALSO
  1869.        HTDTM_LOADNODES
  1870.  
  1871. hypertext.datatype/HTDTM_SEARCH                hypertext.datatype/HTDTM_SEARCH
  1872.  
  1873.     NAME
  1874.         HTDTM_SEARCH -- search for a given string or pattern.
  1875.  
  1876.     FUNCTION
  1877.         This method searches for the occurance of the given string or pattern.
  1878.         If the HTDTSF_PROMPT flag is set it opens the search requester to let
  1879.         the user input the string or pattern to search for. If the
  1880.         HTDTSF_PATTERN flag is set the given string is interpreted as a
  1881.         pattern. HTDTSF_NOCASE ignores case in comparsion.
  1882.  
  1883.     INPUTS
  1884.         struct htSearch
  1885.         {
  1886.             ULONG MethodID;
  1887.             struct GadgetInfo *dt_GInfo;
  1888.             STRPTR hts_String;
  1889.             LONG hts_StringLen;
  1890.             ULONG hts_Flags;
  1891.         };
  1892.  
  1893.         hts_String -- string or pattern to search for
  1894.         hts_StringLen -- length of the given string or pattern
  1895.         hts_Flags -- flags, which controls the search. Following flags are
  1896.             currently supported :
  1897.  
  1898.             HTDTSF_NOCASE -- ignore case
  1899.             HTDTSF_PATTERN -- string is a pattern
  1900.             HTDTSF_PROMPT -- opens the search requester
  1901.  
  1902.     RESULTS
  1903.         TRUE if something was found, otherwise FALSE.
  1904.  
  1905.     SEE ALSO
  1906.         HTDTM_GUISEARCH
  1907.  
  1908. hypertext.datatype/OM_DISPOSE                    hypertext.datatype/OM_DISPOSE
  1909.  
  1910.     NAME
  1911.         OM_DISPOSE -- frees all allocated resources of a hypertext object
  1912.  
  1913.     FUNCTION
  1914.         This method tries to free all allocated resources of a hypertext
  1915.         object :
  1916.  
  1917.         1. It tries to quit all spawned applications.
  1918.         2. Dispose any cached objects
  1919.         3. Closes all fonts
  1920.         4. Dispose any embedded objects
  1921.         5. Dispose possibly background image
  1922.         6. Releases all allocated color pens
  1923.  
  1924.         After this it calls the superclass OM_DISPOSE method.
  1925.  
  1926.     INPUTS
  1927.         none
  1928.  
  1929.     RESULT
  1930.         none
  1931.  
  1932.     SEE ALSO
  1933.         datatypesclass/OM_DISPOSE, OM_NEW, datatypes.library/DisposeDTObject()
  1934.  
  1935. hypertext.datatype/OM_GET                            hypertext.datatype/OM_GET
  1936.  
  1937.     NAME
  1938.         OM_GET -- get attributes of a hypertext object.
  1939.  
  1940.     FUNCTION
  1941.         The OM_GET method is used to get attributes of a hypertext.datatype
  1942.         object. This method is processed first and then passed to the
  1943.         superclass if the attribute isn't recognized.
  1944.  
  1945.     INPUTS
  1946.         struct opGet
  1947.         {
  1948.             ULONG               MethodID;
  1949.             ULONG               opg_AttrID;
  1950.             ULONG               *opg_Storage;
  1951.         };
  1952.  
  1953.         opg_AttrID -- attributes long word id
  1954.         opg_Storage -- pointer to a data area to hold the value of the
  1955.             attribute
  1956.  
  1957.     RESULT
  1958.         zero for unsupported attributes, non-zero for supported attributes.
  1959.  
  1960.     ATTRIBUTES
  1961.         DTA_Domain (struct IBox *) -- objects domain box. This is overwritten,
  1962.             if a control panel is used.
  1963.  
  1964.         DTA_TextFont (struct TextFont *) -- Text font to use for normal texts,
  1965.             not explicitly specified using the HTDTSA_TextFont text segment
  1966.             Tag.
  1967.  
  1968.         DTA_TextAttr (struct TextAttr *) -- Text attribute structure to use
  1969.             for normal texts. This corresponds to the DTA_TextFont attribute.
  1970.  
  1971.         DTA_Title (STRPTR) -- Title of the hypertext object, which is normally
  1972.             displayed in the windows title bar. The string is copied, so that
  1973.             after the set method returns you can free its resources.
  1974.  
  1975.         DTA_NodeName (STRPTR) -- Name of node of this hypertext object.
  1976.             The set method copies the string.
  1977.  
  1978.         DTA_Methods (ULONG *) -- ~0 terminated MethodID list of supported
  1979.             methods.
  1980.  
  1981.         DTA_ControlPanel (BOOL) -- Indicates, if the hypertext datatype should
  1982.             (TRUE) create a control panel for the created object or not
  1983.             (FALSE).
  1984.  
  1985.         AGA_Secure (BOOL) -- Indicates, if its permitted (FALSE) to start
  1986.             external programms or not (TRUE). Only supported for compatibility
  1987.             with amigaguide.datatype. Please use HTDTA_Secure instead.
  1988.  
  1989.         HTDTA_Secure (BOOL) -- Indicates, if its permitted (FALSE) to start
  1990.             external programms or not (TRUE).
  1991.  
  1992.         HTDTA_HyperText (BOOL) -- Indicates, if the object is a hypertext
  1993.             object.
  1994.  
  1995.         HTDTA_SegmentList (struct List *) -- List of linked segments of the
  1996.             current object.
  1997.  
  1998.         HTDTA_WordDelim (STRPTR) -- String, which describes the delimiter
  1999.             characters to use for separating words. The string is not
  2000.             copied.
  2001.  
  2002.         HTDTA_Buffer (UBYTE *) -- Pointer to the raw hypertext data buffer, if
  2003.             any is available. Subclasses which uses IFF files don't provide
  2004.             this buffer. See catalog.datatype for example.
  2005.  
  2006.         HTDTA_BufferLen (ULONG) -- Length of raw hypertext data buffer.
  2007.  
  2008.         HTDTA_LoadBuffer (BOOL) -- Indicates, if the hypertext base class
  2009.             should load (TRUE) the entire ascii or binary file into a
  2010.             buffer and provide it for the subclass via HTDA_Buffer and
  2011.             HTDA_BufferLen.
  2012.  
  2013.         HTDTA_Pool (APTR) -- Memory pool of the current hypertext object.
  2014.  
  2015.         HTDTA_EmbeddedList (struct List *) -- List of all embedded objects.
  2016.             This list can only be walked trough with intuition's NextObject()
  2017.             function.
  2018.  
  2019.         HTDTA_UnderlineLink (BOOL) -- Indicates, if links should be shown as
  2020.             buttons (FALSE) like AmigaGuide links or should be underlined
  2021.             (TRUE) like most Web browsers do.
  2022.  
  2023.         HTDTA_Spacing (UWORD) -- Number of pixel between two lines. This value
  2024.             is used in HTDTM_LAYOUT method. Thus if you change the value you
  2025.             have to invoke DTM_PROCLAYOUT to reflect the change in the output.
  2026.  
  2027.         HTDTA_Contents (STRPTR) -- Defines the name of the contents object of
  2028.             the current hypertext object. The string is copied.
  2029.  
  2030.         HTDTA_Index (STRPTR) -- Defines the name of the index object of the
  2031.             current hypertext object. The string is copied.
  2032.  
  2033.         HTDTA_Help (STRPTR) -- Defines the name of the help object of the
  2034.             current hypertext object. The string is copied.
  2035.  
  2036.         HTDTA_Previous (STRPTR) -- Defines the name of the previous object of
  2037.             the current hypertext object. The string is copied.
  2038.  
  2039.         HTDTA_Next (STRPTR) -- Defines the name of the next object of the
  2040.             current hypertext object. The string is copied.
  2041.  
  2042.         HTDTA_TabWidth (LONG) -- number of space characters to use for a
  2043.             tabulator character.
  2044.  
  2045.         HTDTA_Background (STRPTR) -- file name of a picture to use for
  2046.             the background.
  2047.  
  2048.         HTDTA_BackgroundPen (LONG) -- pen number to use for background
  2049.             color.
  2050.  
  2051.         HTDTA_ForegroundPen (LONG) -- pen number to use for foreground
  2052.             color. This is normaly all standard texts.
  2053.  
  2054.         HTDTA_AltForegroundPen (LONG) -- pen number to use for foreground
  2055.             color, if background and foreground color are the same.
  2056.  
  2057.         HTDTA_ObjectDir (BPTR) -- used to get a shared lock on the directory
  2058.             of the object. It handles all different datatypes source types
  2059.             like IFF, misc or files. The returned lock must be free'd after
  2060.             you have finished your job with UnLock().
  2061.  
  2062.         HTDTA_Depth (LONG) -- recommended color depth for the hypertext
  2063.             object. This is used by applications to open an appropriate
  2064.             custom screen with at least this depth.
  2065.  
  2066.         HTDTA_FileHandle (BPTR) -- file handle from Open() of the hypertext
  2067.             object. This is used for obtaining file informations from
  2068.             DTST_RAM objects, which are part of an normal file. For example
  2069.             the hyperguide.datatype creates for each internal node a DTST_RAM
  2070.             object with HTDTA_Buffer and HTDTA_BufferLen set. ATTENTION this
  2071.             filehandle *must* not be closed !
  2072.             NOTE: This attribute should be overwritten from SubClass
  2073.                   implementors.
  2074.  
  2075.         HTDTA_NodeList (struct List *) -- used by the hypertext.datatype to
  2076.             obtain the list of internal nodes from the subclass.
  2077.             NOTE: This attribute should be overwritten from SubClass
  2078.                   implementors.
  2079.  
  2080.         HTDTA_ShowLink (BOOL) -- indicates, if a link should be shown in as
  2081.             DTA_Title when its activated via key or mouse actions.
  2082.  
  2083.         HTDTA_SeparatorIsFF (BOOL) -- indicates, if a separator should be
  2084.             treated as a form feed within printing and AscII export.
  2085.  
  2086.         HTDTA_NodeIndexing (BOOL) -- indicates, if internal nodes should be
  2087.             saved in a database.
  2088.             NOTE: This attribute should be overwritten from SubClass
  2089.                   implementors.
  2090.  
  2091.         HTDTA_PathList (struct List *) -- list of pathes to search of objects
  2092.             to go to. This list is object dependend and therefore relative
  2093.             pathes are relative to the objects directory.
  2094.             NOTE: This attribute should be overwritten from SubClass
  2095.                   implementors.
  2096.  
  2097.     SEE ALSO
  2098.         datatypesclass/OM_GET, OM_SET, OM_UPDATE, intuition.library/GetAttr()
  2099.  
  2100. hypertext.datatype/OM_NEW                            hypertext.datatype/OM_NEW
  2101.  
  2102.     NAME
  2103.         OM_NEW -- create a hypertext object
  2104.  
  2105.     FUNCTION
  2106.         This method first calls the superclass OM_NEW method and if this
  2107.         returns a non-NULL Object pointer, allocates all needed resources for
  2108.         a hypertext object. This method is really complex. Here is a short
  2109.         description whats going on :
  2110.  
  2111.         1. calls superclass to create the object
  2112.         2. initializes all fields with their defaults
  2113.         3. initializes some fields according to their hypertext.prefs values
  2114.         4. creates navigator buttons
  2115.         5. allocates the objects memory pool
  2116.         6. loads the file into a buffer and offers it via HTDTA_Buffer
  2117.            attribute (only for ASCII files)
  2118.         7. spawn a new process
  2119.         8. creates the ARexx port
  2120.  
  2121.     INPUTS
  2122.         struct opSet {
  2123.             ULONG               MethodID;
  2124.             struct TagItem      *ops_AttrList;
  2125.             struct GadgetInfo   *ops_GInfo;
  2126.         };
  2127.  
  2128.         ops_AttrList -- initial attribute values
  2129.         ops_GInfo -- always NULL for OM_NEW
  2130.  
  2131.     ATTRIBUTES
  2132.         DTA_TextAttr (struct TextAttr *) -- Text attribute structure to use
  2133.             for normal texts. This corresponds to the DTA_TextFont attribute.
  2134.  
  2135.             Defaults to a system standard font TextAttr.
  2136.  
  2137.         DTA_Title (STRPTR) -- Title of the hypertext object, which is normally
  2138.             displayed in the windows title bar. The string is copied, so that
  2139.             after the set method returns you can free its resources.
  2140.  
  2141.             Defaults to NULL.
  2142.  
  2143.         DTA_NodeName (STRPTR) -- Name of node of this hypertext object.
  2144.             The set method copies the string.
  2145.  
  2146.             Defaults to "main".
  2147.  
  2148.         DTA_ControlPanel (BOOL) -- Indicates, if the hypertext datatype should
  2149.             (TRUE) create a control panel for the created object or not
  2150.             (FALSE).
  2151.  
  2152.             Defaults to TRUE.
  2153.  
  2154.         AGA_Secure (BOOL) -- Indicates, if its permitted (FALSE) to start
  2155.             external programms or not (TRUE). Only supported for compatibility
  2156.             with amigaguide.datatype. Please use HTDTA_Secure instead.
  2157.  
  2158.             Defaults to FALSE.
  2159.  
  2160.         HTDTA_Secure (BOOL) -- Indicates, if its permitted (FALSE) to start
  2161.             external programms or not (TRUE).
  2162.  
  2163.             Defaults to FALSE.
  2164.  
  2165.         HTDTA_WordDelim (STRPTR) -- String, which describes the delimiter
  2166.             characters to use for separating words. The string is not
  2167.             copied.
  2168.  
  2169.             Defaults to " \t\n".
  2170.  
  2171.         HTDTA_Buffer (UBYTE *) -- Pointer to the raw hypertext data buffer, if
  2172.             any is available. Subclasses which uses IFF files don't provide
  2173.             this buffer. See catalog.datatype for example.
  2174.  
  2175.             For ascii and binary files the entire file is loaded into this
  2176.             buffer.
  2177.  
  2178.         HTDTA_BufferLen (ULONG) -- Length of raw hypertext data buffer.
  2179.  
  2180.             Defaults to length of the HTDS_Buffer.
  2181.  
  2182.         HTDTA_UnderlineLink (BOOL) -- Indicates, if links should be shown as
  2183.             buttons (FALSE) like AmigaGuide links or should be underlined
  2184.             (TRUE) like most Web browsers do.
  2185.  
  2186.             Defaults to FALSE.
  2187.  
  2188.         HTDTA_Spacing (UWORD) -- Number of pixel between two lines. This value
  2189.             is used in HTDTM_LAYOUT method. Thus if you change the value you
  2190.             have to invoke DTM_PROCLAYOUT to reflect the change in the output.
  2191.  
  2192.             Defaults to 1.
  2193.  
  2194.         HTDTA_Contents (STRPTR) -- Defines the name of the contents object of
  2195.             the current hypertext object. The string is copied.
  2196.  
  2197.             Defaults to global contents as specified in the prefs file or NULL
  2198.             is no global contents is specified.
  2199.  
  2200.         HTDTA_Index (STRPTR) -- Defines the name of the index object of the
  2201.             current hypertext object. The string is copied.
  2202.  
  2203.             Defaults to NULL.
  2204.  
  2205.         HTDTA_Help (STRPTR) -- Defines the name of the help object of the
  2206.             current hypertext object. The string is copied.
  2207.  
  2208.             Defaults to "HELP:<language>/HTDS_Help.hguide"
  2209.  
  2210.         HTDTA_Previous (STRPTR) -- Defines the name of the previous object of
  2211.             the current hypertext object. The string is copied.
  2212.  
  2213.             Defaults to NULL.
  2214.  
  2215.         HTDTA_Next (STRPTR) -- Defines the name of the next object of the
  2216.             current hypertext object. The string is copied.
  2217.  
  2218.             Defaults to NULL.
  2219.  
  2220.         HTDTA_TabWidth (LONG) -- number of space characters to use for a
  2221.             tabulator character.
  2222.  
  2223.             Defaults to 8.
  2224.  
  2225.         HTDTA_Background (STRPTR) -- file name of a picture to use for
  2226.             the background.
  2227.  
  2228.             Defaults to value specified in the prefs (DEFBGPIC) file or
  2229.             NULL if nothing was specified.
  2230.  
  2231.         HTDTA_BackgroundPen (LONG) -- pen number to use for background
  2232.             color.
  2233.  
  2234.             Defaults to value specified in the prefs (DEFBGPEN) file or
  2235.             0 if nothing was specified.
  2236.  
  2237.         HTDTA_ForegroundPen (LONG) -- pen number to use for foreground
  2238.             color. This is normaly all standard texts.
  2239.  
  2240.             Defaults to value specified in the prefs (DEFFGPEN) file or
  2241.             1 if nothing was specified.
  2242.  
  2243.         HTDTA_AltForegroundPen (LONG) -- pen number to use for foreground
  2244.             color, if background and foreground color are the same.
  2245.  
  2246.             Defaults to value specified in the prefs (DEFALTFGPEN) file or
  2247.             3 if nothing was specified.
  2248.  
  2249.         HTDTA_Depth (LONG) -- recommended color depth for the hypertext
  2250.             object. This is used by applications to open a appropriate
  2251.             custom screen with at least this depth.
  2252.  
  2253.         HTDTA_ShowLink (BOOL) -- indicates, if a link should be shown in as
  2254.             DTA_Title when its activated via key or mouse actions.
  2255.  
  2256.             Defaults to value specified in the prefs (SHOWLINK) file or
  2257.             FALSE if nothing was specified.
  2258.  
  2259.     RESULT
  2260.         pointer to the newly created hypertext object or NULL for a failure.
  2261.         If this method fails, a possible reason for failure is provided via
  2262.         the IoErr() function.
  2263.  
  2264.     SEE ALSO
  2265.         datatypesclass/OM_NEW, OM_DISPOSE, OM_SET,
  2266.         datatypes.library/NewDTObjectA()
  2267.  
  2268. hypertext.datatype/OM_NOTIFY                      hypertext.datatype/OM_NOTIFY
  2269.  
  2270.     NAME
  2271.         OM_NOTIFY -- notify attributes changes to the object
  2272.  
  2273.     FUNCTION
  2274.         This method is used to snoop some attributes like DTA_Busy to
  2275.         syncronize some internal variables. After snooping the method is
  2276.         directly passed to its superclass.
  2277.  
  2278.     INPUTS
  2279.         struct opUpdate
  2280.         {
  2281.             ULONG MethodID;
  2282.             struct TagItem *opu_AttrList;
  2283.             struct GadgetInfo *opu_GInfo;
  2284.             ULONG opu_Flags;
  2285.         };
  2286.  
  2287.         opu_AttrList -- list of notification attributes
  2288.         opu_GInfo -- GadgetInfo structure
  2289.         opu_Flags -- flag OPUF_INTERIM or zero
  2290.  
  2291.     RESULTS
  2292.         superclass results
  2293.  
  2294.     SEE ALSO
  2295.         datatypesclass/OM_NOTIFY, rootclass/OM_NOTIFY, rootclass/OM_UPDATE,
  2296.         OM_UPDATE
  2297.  
  2298. hypertext.datatype/OM_SET                            hypertext.datatype/OM_SET
  2299.  
  2300.     NAME
  2301.         OM_SET -- sets attributes of a hypertext object
  2302.  
  2303.     FUNCTION
  2304.         The OM_SET method is used to set attributes of a hypertext.datatype
  2305.         object. This method is processed first and then passed to the
  2306.         superclass.
  2307.  
  2308.     INPUTS
  2309.         struct opSet
  2310.         {
  2311.             ULONG               MethodID;
  2312.             struct TagItem      *ops_AttrList;
  2313.             struct GadgetInfo   *ops_GInfo;
  2314.         };
  2315.  
  2316.         ops_AttrList - list of new attributes
  2317.         ops_GInfo - GadgetInfo structure
  2318.  
  2319.     RESULT
  2320.         non zero if the hypertext object needs rendering, zero if not.
  2321.  
  2322.     ATTRIBUTES
  2323.         DTA_TextAttr (struct TextAttr *) -- Text attribute structure to use
  2324.             for normal texts. This corresponds to the DTA_TextFont attribute.
  2325.  
  2326.         DTA_Title (STRPTR) -- Title of the hypertext object, which is normally
  2327.             displayed in the windows title bar. The string is copied, so that
  2328.             after the set method returns you can free its resources.
  2329.  
  2330.         DTA_NodeName (STRPTR) -- Name of node of this hypertext object.
  2331.             The set method copies the string.
  2332.  
  2333.         AGA_Secure (BOOL) -- Indicates, if its permitted (FALSE) to start
  2334.             external programms or not (TRUE). Only supported for compatibility
  2335.             with amigaguide.datatype. Please use HTDTA_Secure instead.
  2336.  
  2337.         HTDTA_Secure (BOOL) -- Indicates, if its permitted (FALSE) to start
  2338.             external programms or not (TRUE).
  2339.  
  2340.         HTDTA_WordDelim (STRPTR) -- String, which describes the delimiter
  2341.             characters to use for separating words. The string is not
  2342.             copied.
  2343.  
  2344.         HTDTA_Buffer (UBYTE *) -- Pointer to the raw hypertext data buffer, if
  2345.             any is available. Subclasses which uses IFF files don't provide
  2346.             this buffer. See catalog.datatype for example.
  2347.  
  2348.         HTDTA_BufferLen (ULONG) -- Length of raw hypertext data buffer.
  2349.  
  2350.         HTDTA_UnderlineLink (BOOL) -- Indicates, if links should be shown as
  2351.             buttons (FALSE) like AmigaGuide links or should be underlined
  2352.             (TRUE) like most Web browsers do.
  2353.  
  2354.         HTDTA_Spacing (UWORD) -- Number of pixel between two lines. This value
  2355.             is used in HTDTM_LAYOUT method. Thus if you change the value you
  2356.             have to invoke DTM_PROCLAYOUT to reflect the change in the output.
  2357.  
  2358.         HTDTA_Contents (STRPTR) -- Defines the name of the contents object of
  2359.             the current hypertext object. The string is copied.
  2360.  
  2361.         HTDTA_Index (STRPTR) -- Defines the name of the index object of the
  2362.             current hypertext object. The string is copied.
  2363.  
  2364.         HTDTA_Help (STRPTR) -- Defines the name of the help object of the
  2365.             current hypertext object. The string is copied.
  2366.  
  2367.         HTDTA_Previous (STRPTR) -- Defines the name of the previous object of
  2368.             the current hypertext object. The string is copied.
  2369.  
  2370.         HTDTA_Next (STRPTR) -- Defines the name of the next object of the
  2371.             current hypertext object. The string is copied.
  2372.  
  2373.         HTDTA_TabWidth (LONG) -- number of space characters to use for a
  2374.             tabulator character.
  2375.  
  2376.         HTDTA_Background (STRPTR) -- file name of a picture to use for
  2377.             the background.
  2378.  
  2379.         HTDTA_BackgroundPen (LONG) -- pen number to use for background
  2380.             color.
  2381.  
  2382.         HTDTA_ForegroundPen (LONG) -- pen number to use for foreground
  2383.             color. This is normaly all standard texts.
  2384.  
  2385.         HTDTA_AltForegroundPen (LONG) -- pen number to use for foreground
  2386.             color, if background and foreground color are the same.
  2387.  
  2388.         HTDTA_Depth (LONG) -- recommended color depth for the hypertext
  2389.             object. This is used by applications to open a appropriate
  2390.             custom screen with at least this depth.
  2391.  
  2392.         HTDTA_ShowLink (BOOL) -- indicates, if a link should be shown in as
  2393.             DTA_Title when its activated via key or mouse actions.
  2394.  
  2395.         HTDTA_SeparatorIsFF (BOOL) -- indicates, if a separator should be
  2396.             treated as a form feed within printing and AscII export.
  2397.  
  2398.     SEE ALSO
  2399.         datatypesclass/OM_SET, OM_GET, OM_UPDATE, OM_NEW,
  2400.         datatypes.library/SetDTAttrsA()
  2401.  
  2402. hypertext.datatype/OM_UPDATE                      hypertext.datatype/OM_UPDATE
  2403.  
  2404.     NAME
  2405.         OM_UPDATE -- updates attributes of a hypertext object.
  2406.  
  2407.     FUNCTION
  2408.         The OM_UPDATE method is used to update attributes of a
  2409.         hypertext.datatype object. This method is processed first and then
  2410.         passed to the superclass. This method calls directly the OM_SET
  2411.         method, thus all attributes of this method are also supported. The
  2412.         following ATTRIBUTES section lists all attributes, which are only
  2413.         supported by the the OM_UPDATE method.
  2414.  
  2415.     INPUTS
  2416.         struct opUpdate
  2417.         {
  2418.             ULONG               MethodID;
  2419.             struct TagItem      *opu_AttrList;
  2420.             struct GadgetInfo   *opu_GInfo;
  2421.             ULONG               opu_Flags;
  2422.         };
  2423.  
  2424.         opu_AttrList -- list of new attributes
  2425.         opu_GInfo -- GadgetInfo structure
  2426.         opu_Flags -- flags indicating the status of this update method
  2427.  
  2428.     ATTRIBUTES
  2429.         HTDTA_ARexxCommand -- (STRPTR) arexx command, which should be invoked
  2430.             on the object.
  2431.  
  2432.     RESULT
  2433.         Non zero if the object needs to be rendered. Zero if there has nothing
  2434.         changed, so that rendering isn't needed.
  2435.  
  2436.     SEE ALSO
  2437.         datatypesclass/OM_UPDATE, OM_SET, rootclass/OM_NOTIFY
  2438.  
  2439.