home *** CD-ROM | disk | FTP | other *** search
/ Amiga ACS 1998 #4 / amigaacscoverdisc1998-041998.iso / utilities / shareware / workbench / html_hdtc / developer / autodocs / html_hdtc.doc < prev    next >
Encoding:
Text File  |  1997-12-09  |  9.3 KB  |  325 lines
  1.  
  2.  
  3. TABLE OF CONTENTS
  4.  
  5. html.datatype/--datasheet--
  6. html.datatype/DTM_ASYNCLAYOUT
  7. html.datatype/DTM_GOTO
  8. html.datatype/DTM_PROCLAYOUT
  9. html.datatype/GM_LAYOUT
  10. html.datatype/OM_DISPOSE
  11. html.datatype/OM_NEW
  12. html.datatype/OM_NOTIFY
  13. html.datatype/OM_SET
  14. html.datatype/OM_UPDATE
  15.  
  16.  
  17. html.datatype/--datasheet--                        html.datatype/--datasheet--
  18.  
  19.     NAME
  20.         html.datatype -- hypertext datatype for HTML documents
  21.  
  22.     SUPERCLASS
  23.         hypertext.datatype
  24.  
  25.     DESCRIPTION
  26.         This datatype is used to handle HTML documents. It uses all features
  27.         the hypertext.datatype offers. But NOTE in the unregistered version of
  28.         HTDS you can only use five HTML documents at one time.
  29.  
  30.     METHODS
  31.         OM_NEW -- create a html Object.
  32.  
  33.         OM_DISPOSE -- dispose the html Object.
  34.  
  35.         OM_SET -- passes the method to the superclass and performs a refresh
  36.             if needed.
  37.  
  38.         OM_UPDATE -- passes the method to the superclass and performs a refresh
  39.             if needed.
  40.  
  41.         OM_NOTIFY -- snoops the HTDTA_ShowLink attribute to convert HTML path
  42.             definitions to Amiga paths.
  43.  
  44.         GM_LAYOUT -- passes the method to the superclass and performs a
  45.             asynchron layout request if needed.
  46.  
  47.         DTM_GOTO -- converts HTML path definitions to Amiga path definitions and
  48.             calls then the superclass for this method.
  49.  
  50.         DTM_ASYNCLAYOUT -- do the asynchron layout method.
  51.  
  52.         DTM_PROCLAYOUT -- layout method in a process context.
  53.  
  54.     ATTRIBUTES
  55.         None.
  56.  
  57.     NOTE
  58.         See html_hdtc.hguide for supported HTML tags and HTML tag attributes.
  59.  
  60.     SEE ALSO
  61.         hypertext.datatype, HTDS.hguide, html_hdtc.hguide
  62.  
  63. html.datatype/DTM_ASYNCLAYOUT                    html.datatype/DTM_ASYNCLAYOUT
  64.  
  65.     NAME
  66.         DTM_ASYNCLAYOUT -- asynchronously layout the object
  67.  
  68.     FUNCTION
  69.         This method performs now really the layout of the object.
  70.  
  71.     INPUTS
  72.         None.
  73.  
  74.     RESULT
  75.         Total number of vertical units.
  76.  
  77.     SEE ALSO
  78.         DTM_PROCLAYOUT, GM_LAYOUT, hypertext.datatype/GM_LAYOUT,
  79.         hypertext.datatype/HTDTM_LAYOUT
  80.  
  81. html.datatype/DTM_GOTO                                  html.datatype/DTM_GOTO
  82.  
  83.     NAME
  84.         DTM_GOTO -- load and display an other object
  85.  
  86.     FUNCTION
  87.         This method only converts HTML/Unix style file pathes to AmigaDOS
  88.         style pathes. It converts the URL to be loaded into an AmigaDOS
  89.         path and then calls the superclass with the converted path for
  90.         this method.
  91.  
  92.     INPUTS
  93.         struct dtGoto
  94.         {
  95.             ULONG MethodID;
  96.             struct GadgetInfo *dtg_GInfo;
  97.             STRPTR dtg_NodeName;
  98.             struct TagItem *dtg_AttrList;
  99.         };
  100.  
  101.         dtg_NodeName -- name of the node to go to. This also can be a complete
  102.             filename.
  103.         dtg_AttrList -- list of attributes, which specifies the object to go to.
  104.  
  105.     RESULTS
  106.         None defined.
  107.  
  108.     SEE ALSO
  109.         hypertext.datatype/DTM_GOTO
  110.  
  111. html.datatype/DTM_PROCLAYOUT                      html.datatype/DTM_PROCLAYOUT
  112.  
  113.     NAME
  114.         DTM_PROCLAYOUT -- performs a layout on a process context
  115.  
  116.     FUNCTION
  117.         This method performs a layout on a process context. Thus this method
  118.         must only be invoked from a process! It first calls the superclass
  119.         DTM_PROCLAYOUT method and then falls through the DTM_ASYNCLAYOUT
  120.         method.
  121.  
  122.     INPUTS
  123.         None.
  124.  
  125.     RESULT
  126.         None.
  127.  
  128.     EXAMPLE
  129.         ...
  130.         case DTM_PROCLAYOUT:
  131.            /* Tell everyone that we are busy doing things */
  132.            NotifyAttrs(obj, ((struct gpLayout *) msg)->gpl_GInfo, NULL,
  133.                        GA_ID,       ((struct Gadget *) obj)->GadgetID,
  134.                        DTA_Busy,    TRUE,
  135.                        TAG_DONE);
  136.  
  137.            /* Let the super-class partake and then fall through to our layout
  138.               method */
  139.            DoSuperMethodA (cl, obj, msg);
  140.         case DTM_ASYNCLAYOUT:
  141.            /* perform the layout now! */
  142.            break;
  143.         ...
  144.  
  145.     SEE ALSO
  146.         datatypes.library/DoAsyncLayout(), DTM_ASYNCLAYOUT,
  147.         hypertext.datatype/GM_LAYOUT
  148.  
  149. html.datatype/GM_LAYOUT                                html.datatype/GM_LAYOUT
  150.  
  151.     NAME
  152.         GM_LAYOUT -- starts layout of the HTML object
  153.  
  154.     FUNCTION
  155.         This method is directly passed to its superclass. If the superclass
  156.         returns zero the object needs to be layouted, which is done
  157.         asynchronously by calling the DoAsyncLayout() function. If it returns
  158.         non zero nothing has to be done.
  159.  
  160.     INPUTS
  161.         struct gpLayout
  162.         {
  163.            ULONG MethodID;
  164.            struct GadgetInfo *gpl_GInfo;
  165.            ULONG gpl_Initial;
  166.         };
  167.  
  168.         gpl_Initial - First call of GM_LAYOUT for this object
  169.  
  170.     RESULT
  171.         0   - start the asynchronous layout
  172.         !=0 - do nothing
  173.  
  174.     SEE ALSO
  175.         DTM_PROCLAYOUT, DTM_ASYNCLAYOUT, hypertext.datatype/GM_LAYOUT,
  176.         datatypes.library/DoAsyncLayout(), hypertext.datatype/HTDTM_LAYOUT
  177.  
  178. html.datatype/OM_DISPOSE                              html.datatype/OM_DISPOSE
  179.  
  180.     NAME
  181.         OM_DISPOSE -- frees all allocated resources of a HTML object
  182.  
  183.     FUNCTION
  184.         This method frees all allocated resources of a HTML object.
  185.         After this it calls the superclass OM_DISPOSE method.
  186.  
  187.     INPUTS
  188.         None.
  189.  
  190.     RESULT
  191.         None.
  192.  
  193.     SEE ALSO
  194.         hypertext.datatype/OM_DISPOSE, datatypes.library/DisposeDTObject(),
  195.         OM_NEW
  196.  
  197. html.datatype/OM_NEW                                      html.datatype/OM_NEW
  198.  
  199.     NAME
  200.         OM_NEW -- create a HTML object.
  201.  
  202.     FUNCTION
  203.         This method first calls the superclass OM_NEW method and if this
  204.         returns a valid Object pointer it sets some HTML specific values,
  205.         like underlining links instead of making buttons for links.
  206.  
  207.     INPUTS
  208.         struct opSet {
  209.             ULONG               MethodID;
  210.             struct TagItem      *ops_AttrList;
  211.             struct GadgetInfo   *ops_GInfo;
  212.         };
  213.  
  214.         ops_AttrList -- initial attribute values
  215.         ops_GInfo -- always NULL for OM_NEW
  216.  
  217.     RESULT
  218.         pointer to the newly created HTML object or NULL for a failure.
  219.         If this method fails, a possible reason for failure is provided via
  220.         the IoErr() function.
  221.  
  222.     SEE ALSO
  223.         hypertext.datatype/OM_NEW, OM_DISPOSE, OM_SET
  224.  
  225. html.datatype/OM_NOTIFY                                html.datatype/OM_NOTIFY
  226.  
  227.     NAME
  228.         OM_NOTIFY -- notify attributes changes to the object
  229.  
  230.     FUNCTION
  231.         This method is used to convert all URL's to AmigaDOS style pathes,
  232.         which are notified to the object using the DTA_Title tag, if the
  233.         HTDTA_ShowLink occurs in the opu_AttrList.
  234.  
  235.     INPUTS
  236.         struct opUpdate
  237.         {
  238.             ULONG MethodID;
  239.             struct TagItem *opu_AttrList;
  240.             struct GadgetInfo *opu_GInfo;
  241.             ULONG opu_Flags;
  242.         };
  243.  
  244.         opu_AttrList -- list of notification attributes
  245.         opu_GInfo -- GadgetInfo structure
  246.         opu_Flags -- flag OPUF_INTERIM or zero
  247.  
  248.     RESULTS
  249.         superclass results
  250.  
  251.     SEE ALSO
  252.         hypertext.datatype/OM_NOTIFY, rootclass/OM_NOTIFY,
  253.         rootclass/OM_UPDATE, OM_UPDATE
  254.  
  255. html.datatype/OM_SET                                      html.datatype/OM_SET
  256.  
  257.     NAME
  258.         OM_SET -- sets attributes of a HTML object
  259.  
  260.     FUNCTION
  261.         The OM_SET method is used to set attributes of a html.datatype
  262.         object. This method is processed first and then passed to its
  263.         superclass. If the result is non zero it calls the HTDTM_RENDER
  264.         method, which invokes the GM_RENDER method on the separate hypertext
  265.         process.
  266.  
  267.     INPUTS
  268.         struct opSet
  269.         {
  270.             ULONG               MethodID;
  271.             struct TagItem      *ops_AttrList;
  272.             struct GadgetInfo   *ops_GInfo;
  273.         };
  274.  
  275.         ops_AttrList - list of new attributes
  276.         ops_GInfo - GadgetInfo structure
  277.  
  278.     RESULT
  279.         non zero if the HTML object needs rendering, zero if not.
  280.  
  281.     ATTRIBUTES
  282.         None.
  283.  
  284.     SEE ALSO
  285.         hypertext.datatype/OM_SET, OM_UPDATE, OM_NEW,
  286.         datatypes.library/SetDTAttrsA()
  287.  
  288. html.datatype/OM_UPDATE                                html.datatype/OM_UPDATE
  289.  
  290.     NAME
  291.         OM_UPDATE -- updates attributes of a HTML object.
  292.  
  293.     FUNCTION
  294.         The OM_UPDATE method is used to update attributes of a HTML object.
  295.         This method is processed first and then passed to the superclass. This
  296.         method falls directly through the OM_SET method, thus all attributes
  297.         of this method are also supported. The following ATTRIBUTES section
  298.         lists all attributes, which are only supported by the the OM_UPDATE
  299.         method. If the result is non zero it calls the HTDTM_RENDER method,
  300.         which invokes the GM_RENDER method on the separate hypertext process.
  301.  
  302.     INPUTS
  303.         struct opUpdate
  304.         {
  305.             ULONG               MethodID;
  306.             struct TagItem      *opu_AttrList;
  307.             struct GadgetInfo   *opu_GInfo;
  308.             ULONG               opu_Flags;
  309.         };
  310.  
  311.         opu_AttrList -- list of new attributes
  312.         opu_GInfo -- GadgetInfo structure
  313.         opu_Flags -- flags indicating the status of this update method
  314.  
  315.     ATTRIBUTES
  316.         None.
  317.  
  318.     RESULT
  319.         Non zero if the object needs to be rendered. Zero if there has nothing
  320.         changed, so that rendering isn't needed.
  321.  
  322.     SEE ALSO
  323.         hypertext.datatype/OM_UPDATE, OM_SET, rootclass/OM_NOTIFY
  324.  
  325.