mi32/xmhtmlp.h

Go to the documentation of this file.

/*****
* mi32/xmhtmlp.h : XmHTML Widget private header file
*
* This file Version  $Revision: 1.9 $
*
* Creation date:     Tue Nov 19 23:18:41 GMT+0100 1996
* Last modification:    $Date: 2003/09/15 13:49:56 $
* By:             $Author: fileserver!dwilliss $
* Current State:     $State: Exp $
*
* Author:            newt
* (C)Copyright 1995-1996 Ripley Software Development
* All Rights Reserved
*
* This file is part of the XmHTML Widget Library.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
*****/

#ifndef INC_MI32_XMHTMLP_H
#define INC_MI32_XMHTMLP_H

/*****
* $Source: /fileserver/sdt/tnt71/inc/mi32/RCS/xmhtmlp.h_v $
*****/
/*****
* ChangeLog 
* $Log: xmhtmlp.h_v $
* Revision 1.9  2003/09/15 13:49:56  fileserver!dwilliss
* Doxygen
*
* Revision 1.8  2000/11/16 14:33:28  mju
* *** empty log message ***
*
* Revision 1.7  2000/11/13 17:46:08  mju
* Ignore the whole thing in Genitor.
*
* Revision 1.6  2000/08/14 16:26:48  msmith
* *** empty log message ***
*
* Revision 1.5  1999/03/24 17:55:45  dwilliss
* *** empty log message ***
*
* Revision 1.4  1998/09/16 19:54:14  dwilliss
* *** empty log message ***
*
 * Revision 1.3  1998/09/16  17:21:58  coffee!dwilliss
 * *** empty log message ***
 *
 * Revision 1.2  1998/09/16  16:48:35  coffee!dwilliss
 * Update to 1.1.5
 *
* Revision 1.20  1998/04/27 06:57:28  newt
* Started initial work on a rewrite of the layout routines (XmHTMLSubDoc
* and XmHTMLLayer structures)
*
* Revision 1.19  1998/04/04 06:27:55  newt
* XmHTML Beta 1.1.3
*
* Revision 1.18  1997/10/26 23:50:04  newt
* Added internal symbol defines (_LIBRARY stuff)
*
* Revision 1.17  1997/10/23 00:24:47  newt
* XmHTML Beta 1.1.0 release
*
* Revision 1.16  1997/08/31 17:32:58  newt
* log edit
*
* Revision 1.15  1997/08/30 00:42:16  newt
* Reorganized a number of things and moved all private XmHTML functions to
* the XmHTMLI.h include file.
*
* Revision 1.14  1997/08/01 12:55:01  newt
* Progressive image loading changes.
*
* Revision 1.13  1997/05/28 01:43:05  newt
* Made all image options a long instead of a Byte. Additional protos for the
* XmNdecodeGIFProc resource.
*
* Revision 1.12  1997/04/29 14:23:03  newt
* Moved all XmHTML private functions in.
*
* Revision 1.11  1997/04/03 05:31:52  newt
* Added an additional base field to the XmHTMLWord structure.
*
* Revision 1.10  1997/03/28 07:06:26  newt
* Frame interface support.
*
* Revision 1.9  1997/03/20 08:06:11  newt
* XmNrepeatDelay, moved HTML enumeration table from XmHTML.h in here
*
* Revision 1.8  1997/03/11 19:50:50  newt
* Changes in XmHTMLImage, XmHTMLWord and XmHTMLObjectTable
*
* Revision 1.7  1997/03/04 18:46:42  newt
* XmHTMLImage changed for animation support; imagemap_fg and imagemap_draw added
*
* Revision 1.6  1997/03/04 00:56:58  newt
* Removed some obsolete fields
*
* Revision 1.5  1997/03/02 23:09:30  newt
* XmHTMLImage, XmHTMLImageMap, XmHTMLAnchor structs modified.
*
* Revision 1.4  1997/02/11 02:02:11  newt
* Removed obsolete fields from XmHTMLWord, XmHTMLObjectTable. 
* Added stuff for new anchor treatment.
*
* Revision 1.3  1997/01/09 06:55:56  newt
* expanded copyright marker
*
* Revision 1.2  1997/01/09 06:48:29  newt
* changes in XmHTMLWord. Added all image structures and enums.
*
* Revision 1.1  1996/12/19 02:17:16  newt
* Initial Revision
*
*****/ 

#ifndef _XmHTMLP_h_
#define _XmHTMLP_h_
#ifndef GENERATING_DOXYGEN_OUTPUT

#ifdef WIN32
/*
** Disable some really anoying warnings that VC++ 5.0 spews out
*/
#pragma warning (disable: 4018) /* '!=' : signed/unsigned mismatch */
#pragma warning (disable: 4761) /* integral size mismatch in argument; conversion supplied */
#pragma warning (disable: 4244) /* conversion from 'double ' to 'int ', possible loss of data */
#pragma warning (disable: 4305) /* truncation from 'const double ' to 'float ' */
#pragma warning (disable: 4113) /* function differs in parameter lists */
/* Make this one an error so we catch illegal things */
#pragma warning (error: 4133) /* 'function' : incompatible types - from 'unsigned short *' to 'char *' */
#endif

#include <X11/Xatom.h>     /* property defines */
#include <X11/IntrinsicP.h>   /* fast macros */
#include <X11/Xmu/Atoms.h> /* must be below, it includes X11/Intrinsic.h */

#include <Xm/XmP.h>     /* index defines & private motif functions */
#include <Xm/ManagerP.h>

/* Required includes */
#include <mi32/xmhtml.h>

/*****
* NEVER define VERSION *or* _LIBRARY yourself. These are defines required
* for compiling the library. When defined, they pull in a number of other
* header files which are normally *not* installed.
*****/
#ifdef VERSION
# ifndef _LIBRARY
#  define _LIBRARY
# endif
#endif

/*****
* prevent multiple decls when building the lib.
* zconf.h (which gets included by png.h) also typedefs Byte to unsigned char.
* The compiler warning is annoying, so just don't typedef it again.
* XCC is an opaque object defined in XCCP.h
*****/
#ifdef _LIBRARY
# include "XCC.h"    /* XColorContext definitions and protos */
# ifdef _ZCONF_H
#  ifndef BYTE_ALREADY_TYPEDEFED
#   define BYTE_ALREADY_TYPEDEFED
#  endif 
# endif 
#else
  typedef struct _XColorContext *XCC;
#endif 

#ifndef BYTE_ALREADY_TYPEDEFED
#define BYTE_ALREADY_TYPEDEFED
typedef unsigned char Byte;
#endif 

/*****
* Currently, the only supported method of form scrolling is by
* mapping/unmapping all form elements
*****/
#define UNMAP_FORMS  1

_XFUNCPROTOBEGIN     
#ifdef __cplusplus
extern "C" {
#endif

/*****
* Class pointer and extension record definition
*****/
typedef struct {
  XtPointer    extension;  
}XmHTMLClassPart;

typedef struct _XmHTMLClassRec
{
   CoreClassPart     core_class;
   CompositeClassPart   composite_class;
   ConstraintClassPart  constraint_class;
   XmManagerClassPart   manager_class;
   XmHTMLClassPart      html_class;
}XmHTMLClassRec;

/*****
* A whole slew of states for all kinds of internal objects.
*****/

/*****
* Line styles
*****/
#define LINE_SOLID      (1<<1)   /* paint a solid line   */
#define LINE_DASHED     (1<<2)   /* paint a dashed line  */
#define LINE_SINGLE     (1<<3)   /* paint a single line  */
#define LINE_DOUBLE     (1<<4)   /* paint a double line  */
#define LINE_STRIKE     (1<<5)   /* render as strikeout  */
#define LINE_UNDER      (1<<6)   /* render as underline  */
#define NO_LINE         0     

/*****
* Spacing and anchor text data bits
*****/
#define TEXT_SPACE_NONE       (1<<0)   /* no spacing at all       */
#define TEXT_SPACE_LEAD       (1<<1)   /* add a leading space        */
#define TEXT_SPACE_TRAIL      (1<<2)   /* add a trailing space       */
#define TEXT_ANCHOR           (1<<3)   /* a regular anchor           */
#define TEXT_ANCHOR_INTERN    (1<<4)   /* internal anchor flag       */
#define TEXT_IMAGE            (1<<5)   /* indicates an image member  */
#define TEXT_FORM          (1<<6)   /* indicates a form member    */
#define TEXT_BREAK            (1<<7)   /* indicates a linebreak      */

/***** 
* HTML list marker enumeration type 
*****/
typedef enum{
   XmMARKER_NONE = 0, 
   XmMARKER_ARABIC = 10, 
   XmMARKER_ALPHA_LOWER, 
   XmMARKER_ALPHA_UPPER, 
   XmMARKER_ROMAN_LOWER,
   XmMARKER_ROMAN_UPPER,
   XmMARKER_DISC = 15,
   XmMARKER_SQUARE,
   XmMARKER_CIRCLE
}Marker;

/***** 
* Horizontal/Vertical alignment data 
*****/
typedef enum{
   XmHALIGN_NONE = 0,   
   XmHALIGN_LEFT,
   XmHALIGN_CENTER,
   XmHALIGN_RIGHT,
   XmHALIGN_JUSTIFY, 
   XmVALIGN_NONE = 8,   
   XmVALIGN_TOP,
   XmVALIGN_MIDDLE,
   XmVALIGN_BOTTOM,
   XmVALIGN_BASELINE
}Alignment;

/***** 
* Possible types of HTML objects. 
* All text types are only used when computing the screen layout
*****/
typedef enum{
   OBJ_NONE = 0,
   OBJ_TEXT,         
   OBJ_PRE_TEXT,     
   OBJ_BULLET,       
   OBJ_HRULE,        
   OBJ_TABLE,        
   OBJ_TABLE_FRAME,  
   OBJ_IMG,       
   OBJ_FORM,         
   OBJ_APPLET,       
   OBJ_BLOCK         
}ObjectType;

/*****
* linefeed types
*****/
#define CLEAR_NONE         -1    
#define CLEAR_SOFT         0     
#define CLEAR_HARD         1     
#define CLEAR_ALL       2     

/*****
* Server/client side and map type values 
*****/
typedef enum{
   XmMAP_NONE = 1,
   XmMAP_SERVER,
   XmMAP_CLIENT
}Imagemap;

/*****
* Image option bits.
* Each of these bits represents certain state information about an image.
*****/
#define IMG_ISBACKGROUND      (1L<<1)  /* is a background image         */
#define IMG_ISINTERNAL        (1L<<2)  /* is an internal image          */
#define IMG_ISCOPY            (1L<<3)  /* is a referential copy         */
#define IMG_ISANIM            (1L<<4)  /* is an animation               */
#define IMG_FRAMEREFRESH      (1L<<5)  /* set when running an animation */
#define IMG_HASDIMENSIONS     (1L<<6)  /* dimensions are given in <IMG> */
#define IMG_HASSTATE       (1L<<7)  /* current state pixmap present     */
#define IMG_INFOFREED         (1L<<8)  /* imageinfo has been freed         */
#define IMG_DELAYED_CREATION  (1L<<9)  /* create when needed            */
#define IMG_ORPHANED       (1L<<10)/* indicates orphaned image       */
#define IMG_PROGRESSIVE       (1L<<11)/* indicates image is being loaded   */

/*****
* Possible colorclass an image can have.
*****/
#define COLOR_CLASS_GRAYSCALE 0
#define COLOR_CLASS_INDEXED      1
#define COLOR_CLASS_RGB       2

/*****
* What type of scrolling a frame should employ.
*****/
typedef enum{
   FRAME_SCROLL_NONE = 1,
   FRAME_SCROLL_AUTO,
   FRAME_SCROLL_YES
}FrameScrolling;

/*****
* Possible types of frame sizes
*****/
typedef enum{
   FRAME_SIZE_FIXED = 1,         
   FRAME_SIZE_RELATIVE,       
   FRAME_SIZE_OPTIONAL           
}FrameSize;

/*****
* Possible Frame layout policies
*****/
typedef enum{
   FRAMESET_LAYOUT_ROWS = 1,     
   FRAMESET_LAYOUT_COLS = 2,     
   FRAMESET_LAYOUT_ROW_COLS = 4  
}FramesetLayout;

/*****
* The three possible anchor selection states
*****/
#define ANCHOR_UNSELECTED  (Byte)0     
#define ANCHOR_INSELECT    (Byte)1     
#define ANCHOR_SELECTED    (Byte)2     

/*****
* XmHTML font style bits
*****/
#define FONT_BOLD    (1<<1)
#define FONT_MEDIUM     (1<<2)
#define FONT_ITALIC     (1<<3)
#define FONT_REGULAR (1<<4)
#define FONT_FIXED      (1<<5)
#define FONT_SCALABLE   (1<<6)

/*****
* A XmHTML font. XmHTML uses it's own font definition for performance
* reasons (the layout routines use a *lot* of font properties).
*****/
typedef struct{
   Byte style;             
   String font_name;       
   String font_family;        
   XFontStruct *xfont;        

   /* font properties */
   int height;             
   int lineheight;            
   Cardinal isp;           
   Cardinal eol_sp;        
   int sup_xoffset;        
   int sup_yoffset;        
   int sub_xoffset;        
   int sub_yoffset;        
   int ul_offset;          
   Cardinal ul_thickness;     
   int st_offset;          
   Cardinal st_thickness;     
   short m_lbearing;       
   short m_rbearing;       
   short m_width;          
   short m_ascent;            
   short m_descent;        
}XmHTMLfont;

/**********
****** Definition of all possible Objects
**********/

/*****
* HTML4.0 Events
*****/
typedef struct _HTEvent{
   int         type;       
   XtPointer   data;       
}HTEvent;

/*****
* All possible events that HTML4.0 defines
* All fields are ptrs into XmHTML HTEvent array.
*****/
typedef struct _AllEvents{
   /* Document/Frame specific events */
   HTEvent     *onLoad;
   HTEvent     *onUnload;

   /* HTML Form specific events */
   HTEvent     *onSubmit;
   HTEvent     *onReset;
   HTEvent     *onFocus;
   HTEvent     *onBlur;
   HTEvent     *onSelect;
   HTEvent     *onChange;

   /* object events */
   HTEvent     *onClick;
   HTEvent     *onDblClick;
   HTEvent     *onMouseDown;
   HTEvent     *onMouseUp;
   HTEvent     *onMouseOver;
   HTEvent     *onMouseMove;
   HTEvent     *onMouseOut;
   HTEvent     *onKeyPress;
   HTEvent     *onKeyDown;
   HTEvent     *onKeyUp;
}AllEvents;

/*****
* Definition of an anchor 
* URLType is an enumeration type defined in HTML.h
*****/
typedef struct _XmHTMLAnchor{
   URLType           url_type;      
   String            name;       
   String            href;       
   String            target;        
   String            rel;        
   String            rev;        
   String            title;         
   AllEvents         *events;    
   Cardinal          line;       
   Boolean           visited;    
   struct _XmHTMLAnchor *next;         
}XmHTMLAnchor;

/*****
* Definition of a word (a word can be plain text, an image, a form member
* or a linebreak).
*****/
typedef struct _XmHTMLWord{
   int            x;       
   int               y;       
   Dimension         width;      
   Dimension         height;     
   Cardinal          line;    
   ObjectType        type;    
   String            word;    
   int            len;     
   XmHTMLfont        *font;      
   Byte           line_data;  
   Byte           spacing; 
   Byte           posbits; 
   AllEvents         *events; 
   struct _XmHTMLImage *image;      
   struct _XmHTMLForm   *form;      
   struct _XmHTMLExtObj *embed;  
   struct _XmHTMLWord   *base;      
   struct _XmHTMLWord   *self;      
   struct _XmHTMLObjectTable *owner;   
}XmHTMLWord;

/*****
* Definition of an embedded object to the parser.
*****/
typedef struct _XmHTMLParserTag{
   /* user-provided data fields */
   String         tag;        
   Boolean        terminated;    
   unsigned long  flags;         
   XtPointer      user_data;     

   /* internal fields */
   int            id;            
}XmHTMLParserTag;

/*****
* Definition of an embedded object. This object allows programmers to 
* dynamically extend XmHTML with private HTML tags.
*****/
typedef struct _XmHTMLExtObj{
   int            x;       
   int               y;       
   Dimension         width;      
   Dimension         height;     
   int               id;         
   String            name;    
   Widget            w;       

   XmHTMLParserTag      *tag;    
   XmHTMLTagAttributes  *attributes;

   /*****
   * Possible attributes that can influence the layout of an embedded object.
   * They are derived from the HTML4.0 OBJECT element.
   *****/
   Alignment         halign;     
   Alignment         valign;     
   Dimension         border;     
   AllEvents         *events; 

   XtPointer         user_data;  

   Boolean           scrollable; 
   Boolean           wrap;    
   Boolean        mapped;     

   struct _XmHTMLObjectTable *data;
   struct _XmHTMLExtObj *prev;      
   struct _XmHTMLExtObj *next;      
}XmHTMLExtObj;

/* area definition. See map.c for the full definition */
typedef struct _mapArea mapArea;

/*****
* Client-side imagemap information
* mapArea is a transparent object and is defined in map.c
*****/
typedef struct _XmHTMLImageMap{
   String            name;    
   int               nareas;     
   mapArea           *areas;     
   struct _XmHTMLImageMap *next; 
}XmHTMLImageMap;

/*****
* XmHTML's internal image format.
* One very important thing to note is that the meaning of the (width,height)
* and (swidth,sheight) members of this structure is exactly *OPPOSITE* to
* the members with the same name in the public structures (XmImageInfo and
* XmImage).
*****/
typedef struct _XmHTMLImage{
   /* Normal image data */
   Byte        magic;         
   String         url;        
   XmImageInfo    *html_image;   
   Pixmap         pixmap;        
   Pixmap         clip;       
   unsigned long  options;    
   int            width;         
   int            height;        
   int            npixels;    
   XCC             xcc;       

   /* Possible <IMG> attributes */
   int            swidth;        
   int            sheight;    
   String         alt;        
   Alignment      align;         
   Imagemap    map_type;      
   String         map_url;    
   Dimension      border;        
   Dimension      hspace;        
   Dimension      vspace;        

   struct _XmHTMLObjectTable *owner;   
   struct _XmHTMLImage *child;      
   struct _XmHTMLImage *next;    

   /* animation data */
   XmImageFrame   *frames;    
   int            nframes;    
   int            current_frame; 
   int            current_loop;  
   int            loop_count;    
   XtIntervalId   proc_id;    
   XmHTMLWidget   html;       
   XtAppContext   context;    

   /* other data */
   AllEvents         *events; 
}XmHTMLImage;

/*****
* The following structure is used to mimic file access in memory.
* It's only used for loading images, hence the name ImageBuffer.
*****/
typedef struct{
   char *file;             
   Byte *buffer;           
   Byte *curr_pos;            
   size_t next;            
   size_t size;            
   Boolean may_free;       
   unsigned char type;        
   int depth;              
}ImageBuffer;

/*****
* Definition of HTML form components
*****/
typedef struct _XmHTMLForm{
   int            x;          
   int         y;          
   Dimension      width;         
   Dimension      height;        
   Cardinal    line;       
   Widget         w;          
   Widget         child;         
   String         name;       
   Byte        type;       
   int            size;       
   int            maxlength;     
   String         value;         
   String         content;    
   Alignment      align;         
   Boolean        multiple;      
   int            selected;      
   Boolean     checked;    
   Boolean     mapped;        
   struct _XmHTMLForm *options;  
   struct _XmHTMLObjectTable *data;
   struct _XmHTMLFormData *parent;  
   struct _XmHTMLForm *prev;     
   struct _XmHTMLForm *next;     
}XmHTMLForm;

/*****
* Definition of form data
*****/
typedef struct _XmHTMLFormData{
   Widget      html;          
   Boolean     can_clip;         
   Pixmap      clip;          
   int         x;             
   int         y;             
   Dimension   width;            
   Dimension   height;           
   String      action;           
   int         method;           
   String      enctype;       
   int         ncomponents;      
   Widget      fileSB;           
   XmHTMLForm  *components;      
   struct _XmHTMLFormData *prev; 
   struct _XmHTMLFormData *next; 
}XmHTMLFormData;

/*****
* Definition of XmHTML tables
*
* Dimensions:
* positive -> absolute number;
* negative -> relative number;
* 0        -> no dimension specified;
*
* Each component in a table has a set of core properties. Properties are
* inherited from top to bottom and can be overriden.
*
* Content containers render the contents of all objects between
* start (inclusive) and end (exclusive).
*****/
/* possible framing types */
typedef enum{
   TFRAME_VOID = 0,        
   TFRAME_ABOVE,           
   TFRAME_BELOW,           
   TFRAME_LEFT,            
   TFRAME_RIGHT,           
   TFRAME_HSIDES,          
   TFRAME_VSIDES,          
   TFRAME_BOX,             
   TFRAME_BORDER           
}TableFraming;

/* possible ruling types */
typedef enum{
   TRULE_NONE = 0,            
   TRULE_GROUPS,           
   TRULE_ROWS,             
   TRULE_COLS,             
   TRULE_ALL               
}TableRuling;

/*****
* Properties shared by all table elements. These are inherited from top to
* bottom and can be overriden by the appropriate tag attributes.
*****/
typedef struct _TableProperties{
   int            border;           
   Alignment      halign;           
   Alignment      valign;           
   Pixel       bg;               
   XmHTMLImage    *bg_image;        
   TableFraming   framing;       
   TableRuling    ruling;           
   Boolean        nowrap;           
}TableProperties;

/*****
* a Cell, can be a header cell or a simple cell.
*****/
typedef struct _TableCell{
   Boolean        header;           
   int            width;            
   int            height;           
   int            rowspan;       
   int            colspan;       
   TableProperties   *properties;      
   struct _XmHTMLObjectTable *start;   
   struct _XmHTMLObjectTable *end;     
   struct _XmHTMLObjectTable *owner;   
   struct _TableRow *parent;        
}TableCell;

/* A row. A row consists of a number of Cells */
typedef struct _TableRow{
   TableCell      *cells;           
   int            ncells;           
   int            lastcell;         
   TableProperties   *properties;      
   struct _XmHTMLObjectTable *start;   
   struct _XmHTMLObjectTable *end;     
   struct _XmHTMLObjectTable *owner;   
   struct _XmHTMLTable *parent;     
}TableRow;

/*****
* A table. A table consists of a Caption and a number of Rows
* The caption is a special row: it has only one cell that stretches
* across the entire table: itself.
*****/
typedef struct _XmHTMLTable{
   /* overall table properties */
   int            width;            
   int            hmargin;       
   int            vmargin;       
   int            hpadding;         
   int            vpadding;         
   int            ncols;            
   TableProperties *properties;     

   TableRow    *caption;         
   TableRow    *rows;            
   int            nrows;            
   int            lastrow;       

   struct _XmHTMLTable *parent;     
   struct _XmHTMLTable *childs;     
   int            nchilds;       
   int            lastchild;        

   struct _XmHTMLObjectTable *start;   
   struct _XmHTMLObjectTable *end;     

   struct _XmHTMLObjectTable *owner;   

   struct _XmHTMLTable *next;       
}XmHTMLTable;

/*****
* Definition of formatted HTML elements
*****/
typedef struct _XmHTMLObjectTable{
   int            x;          
   int            y;          
   Dimension      width;         
   Dimension      height;        
   Cardinal    line;       
   Cardinal    id;            
   ObjectType     object_type;   
   String         text;       
   Byte        text_data;     
   int            len;        
   int            y_offset;      
   int            x_offset;      
   XmHTMLObject   *object;    
   XmHTMLAnchor   *anchor;    
   XmHTMLWord     *words;        
   XmHTMLForm     *form;         
   XmHTMLTable    *table;        
   int            n_words;    
   Byte        anchor_state;  
   Alignment      halign;        
   int            linefeed;      
   Dimension      ident;         
   Marker         marker;        
   int            list_level;    
   XmHTMLfont     *font;         
   Pixel       fg;            
   Pixel       bg;            
   struct _XmHTMLObjectTable *next;
   struct _XmHTMLObjectTable *prev;
}XmHTMLObjectTable, *XmHTMLObjectTableElement;

/*****
* Line lookups
*****/
typedef struct{
   Boolean        used;       
   int            y;          
   XmHTMLObjectTable *start;     
   XmHTMLObjectTable *end;       
}XmHTMLLineTable;

/*****
* The following two structures are not yet used by XmHTML. They are intended
* to serve as the basis for layered HTML documents (including transparent
* layers), progressive document loading and rendering to non-display
* devices.
*****/
typedef struct _XmHTMLSubDoc{
   int            x;          
   int            y;          
   Dimension      width;         
   Dimension      height;        
   Cardinal    nlines;        
   XmHTMLObject   *elements;     
   XmHTMLObjectTable *start;     
   XmHTMLObjectTable *end;    
   struct sd_funcs{
      void (*parse)();        /* subdoc parser function        */
      void (*format)();       /* subdoc formatter function     */
      void (*layout)();       /* subdoc layout function        */
      void (*paint)();        /* subdoc paint function         */
   }sd;
   struct _XmHTMLSubDoc *child;  
   struct _XmHTMLSubDoc *prev;      
   struct _XmHTMLSubDoc *next;      
   struct _ToolkitAbstraction *tka;
}XmHTMLSubDoc;

#define LAY_SCROLLABLE     (1<<1)   /* layer is scrollable           */
#define LAY_FIXED       (1<<2)   /* layer has fixed position         */
#define LAY_FIXED_REL      (1<<3)   /* layer fixed to position in doc   */
#define LAY_VISIBLE        (1<<4)   /* layer is visible              */
#define LAY_RAISE       (1<<5)   /* layer can be raised           */
#define LAY_LOWER       (1<<6)   /* layer can be lowered          */
#define LAY_SEND_EVENTS    (1<<7)   /* layer can send events         */
#define LAY_RECV_EVENTS    (1<<8)   /* layer can receive events         */
#define LAY_BG_IMAGE    (1<<9)   /* layer has background image    */
#define LAY_BG_COLOR    (1<<10)  /* layer has background color    */
#define LAY_TRANSPARENT    (1<<11)  /* layer is transparent          */
#define LAY_WINDOW         (1<<12)  /* layer has got a window        */
#define LAY_INPUT_OUTPUT   (1<<13)  /* layer can do input and output */
#define LAY_INPUT_ONLY     (1<<14)  /* layer can only accept input      */
#define LAY_OUTPUT_ONLY    (1<<15)  /* layer can only do output         */

typedef struct _XmHTMLLayer{
   struct _XmHTMLLayer *self;    
   int            x;          
   int            y;          
   Dimension      width;         
   Dimension      height;        
   unsigned long  flags;         
   unsigned long  state;         
   Byte        zpos;       
   XmHTMLImage    *background;   
   Pixel       bg;            
   Pixmap         mask;       
   Window         window;        
   XmHTMLSubDoc   *subdoc;    

   struct l_funcs{
      void (*send_event)();      /* layer send-event function     */
      void (*read_event)();      /* layer read-event function     */
      void (*pass_event)();      /* layer event passing function     */
      void (*refresh)();         /* layer refresh function        */
      void (*raise)();        /* layer raise function          */
      void (*lower)();        /* layer lower function          */
      void (*scroll)();       /* layer scroll function         */
      void (*map)();          /* layer map function            */
      void (*unmap)();        /* layer unmap function          */
   }lf;

   struct _XmHTMLLayer *parent;  
   struct _XmHTMLLayer *upper;      
   struct _XmHTMLLayer *lower;      
   struct _XmHTMLLayer *prev;    
   struct _XmHTMLLayer *next;    
}XmHTMLLayer;

/*****
* A stripped down array of all words that are searchable. Contains enough
* information to search for text and provide information about the
* selection that should be made to display the text found. 
*****/
struct _XmHTMLSearchableWord{
   String            word;    
   int            len;     
   Byte           spacing; 
   XmHTMLObjectTable *owner;     
   int               word_idx;   
};

/*****
* definition of frame childs
*****/
typedef struct _XmHTMLFrameWidget{
   int            x;          
   int            y;          
   Dimension      width;         
   Dimension      height;        
   Dimension      size_s;        
   FrameSize      size_type;     
   FrameScrolling scroll_type;   
   String         src;        
   String         name;       
   Dimension      margin_width;  
   Dimension      margin_height; 
   Boolean        resize;        
   int            border;        
   Widget         frame;         

   /* Frame resizing */
   int            drag_x;        
   int            drag_y;        

   /* Added June 11 by Eric Bello */
   Boolean        is_frameset;         
   struct _XmHTMLFrameWidget *frameset;   
   struct _XmHTMLFrameWidget *next;    
   struct _XmHTMLFrameWidget *prev;    
   struct _XmHTMLFrameWidget *children;   
   FramesetLayout layout;              
}XmHTMLFrameWidget;

/*****
* Definition of a Page
*****/
typedef struct _XmHTMLPage{
   XmHTMLObject      *start;        
   XmHTMLObject      *end;       

   int               page_no;    
   Boolean           redo_layout;   

   Boolean           input_complete;   

   /* anchor colors */
   Pixel          anchor_fg;
   Pixel          anchor_visited_fg;
   Pixel          anchor_target_fg;
   Pixel          anchor_activated_fg;
   Pixel          anchor_activated_bg;

   /* background image/color and text color resources */
   Pixel          body_bg;    
   Pixel          body_fg;    
   String            body_image_url;   
   XmHTMLImage         *body_image; 

   /* Formatted document resources */
   int               formatted_width;  
   int               formatted_height; 
   int               num_named_anchors;   
   int               anchor_words;  
   XmHTMLWord        *anchors;      
   XmHTMLObjectTable *named_anchors; 
   XmHTMLAnchor      *anchor_data;  
   XmHTMLObjectTable *formatted;    
   Cardinal       top_line;      
   Cardinal       nlines;        

   /* Table resources */
   XmHTMLTable       *tables;    

   /* HTML Form resources */
   XmHTMLFormData    *form_data;    
}XmHTMLPage;

/*****
* Parser state stack object
*****/
typedef struct _stateStack{
   htmlEnum id;               
   struct _stateStack *next;     
}stateStack;

/*****
* Progressive Loading Context. This is an opaque object fully defined in
* plc.h. It's a rather complex thing for all objects than can be loaded
* progressively. It maintains the state of each object (data as well as data
* processing functions) and does a bunch of nifty things.
*****/ 
typedef struct _PLC *PLCPtr;

/*****
* This struct is required to properly perform alpha channel processing.
* It contains information about the current background setting.
*
* Alpha channel processing is done for PNG images with (obviously) an alpha
* channel. The data used for creating the pixmap is a merger of the original
* image data with the current background setting (fixed color or an image).
* When a document with such an image contains a background image, XmHTML needs
* to redo this alpha processing whenever the document layout is changed: the
* exact result of this merger depends on the position of the image. This can
* be a rather slow process (alpha channels require floating point ops), and
* by at least storing the current background info we can achieve some
* performance increase. 
*****/
typedef struct _AlphaChannelInfo{
   int fb_maxsample;       
   int background[3];         
   int ncolors;            
   XColor *bg_cmap;        
}AlphaChannelInfo, *AlphaPtr;

/*****
* Toolkit independent rendering functions. This enables us to use the
* same engine for rendering to a display, text or postscript.
* 
* This abstraction makes it a *lot* easier when porting XmHTML to other
* toolkits, provided the display functions know how to deal/convert the
* X-specific types.
*****/
#define GC_FILL_SOLID            0
#define GC_FILL_TILED            1
#define GC_FILL_STIPPLED         2
#define GC_FILL_OPAQUE_STIPPLED     3

#define GC_CAP_NOT_LAST          0
#define GC_CAP_BUTT              1
#define GC_CAP_ROUND          2
#define GC_CAP_PROJECTING        3

#define GC_LINE_SOLID            0
#define GC_LINE_ON_OFF_DASH         1
#define GC_LINE_DOUBLE_DASH         2

#define GC_JOIN_MITER            0
#define GC_JOIN_ROUND            1
#define GC_JOIN_BEVEL            2

#define GC_GXcopy             0

#define GC_COORDMODE_ORIGIN         0
#define GC_COORDMODE_PREVIOUS    1

typedef struct _ToolkitAbstraction{
   Display *dpy;
   Drawable win;
   Window DefaultRoot;
   int width;
   int height;
   int widthMM;
   int heightMM;

   /*****
   * Xlib function wrappers
   *****/

   /* GC properties */
   int fill_style[4];
   int cap_style[4];
   int line_style[3];
   int join_style[3];
   int gc_func[2];
   int coord_mode[2];

   /* GC functions */
   GC   (*CreateGC)();
   int (*FreeGC)();
   int (*CopyGC)();
   int (*SetFunction)();
   int (*SetClipMask)();
   int (*SetClipOrigin)();
   int (*SetTile)();
   int (*SetTSOrigin)();
   int (*SetFillStyle)();
   int (*SetFont)();
   int (*SetForeground)();
   int (*SetBackground)();
   int (*SetLineAttributes)();

   /* Font Allocation functions */
   XFontStruct* (*LoadQueryFont)();
   int (*FreeFont)();
   int (*GetFontProperty)();
   int (*TextExtents)();

   /* Cursor & pointer functions */
   int (*UngrabPointer)();
   int (*DefineCursor)();
   int (*UndefineCursor)();
   int (*FreeCursor)();

   /* Color functions */
   int (*ParseColor)();
   int (*AllocColor)();
   int (*QueryColor)();
   int (*QueryColors)();
   int (*FreeColors)();

   /* Pixmap functions */
   Pixmap (*CreatePixmap)();
   Pixmap (*CreatePixmapFromBitmapData)();
   int    (*FreePixmap)();

   /* XImage functions */
   XImage *(*CreateImage)();
   void (*DestroyImage)();
   int  (*PutImage)();

   /* string/text functions */
   int (*TextWidth)();

   int (*DrawString)();
   int (*DrawLine)();
   int (*DrawLines)();
   int (*DrawRectangle)();
   int (*FillRectangle)();
   int (*DrawArc)();
   int (*FillArc)();

   /* misc. functions */
   int (*CopyArea)();
   int (*ClearArea)();
   int (*Sync)();

   /*****
   * X Toolkit Intrinsics wrappers
   *****/
   Boolean  (*IsRealized)();
   Boolean (*IsManaged)();
   void  (*ManageChild)();
   void  (*UnmanageChild)();
   void  (*MoveWidget)();
   void  (*ResizeWidget)();
   void  (*ConfigureWidget)();
   void  (*DestroyWidget)();
   void    (*SetMappedWhenManaged)();
   void  (*RemoveTimeOut)();
   XtIntervalId   (*AddTimeOut)();

   /*****
   * Motif Wrappers
   *****/
   void  (*DrawShadows)();

   /*****
   * Implementation specific data
   *****/
   void *data;
   void (*FreeData)(void*);

}ToolkitAbstraction;

/*****
* HTML Parser data
*****/
typedef struct _Parser{
   String source;          
   int index;              
   int len;             
   int num_lines;          
   Dimension line_len;        
   Dimension cnt;          

   /* text insertion function */
   void (*store_text)();      /* text insertion function          */

   /* running list of inserted elements */
   int num_elements;       
   int num_text;           
   XmHTMLObject *head;        
   XmHTMLObject *current;     
   XmHTMLObject *last;        

   stateStack state_base;     
   stateStack *state_stack;   

   int cstart;             
   int cend;               
   int inserted;           

   Cardinal err_count;        
   Cardinal loop_count;    
   Boolean strict_checking;   
   Boolean have_body;         
   Byte warn;              
   Boolean bad_html;       
   Boolean html32;            
   Boolean  automatic;        
   Boolean do_icons;       

   Widget widget;          
}Parser;

/*****
* XmHTMLPart definition 
*****/
typedef struct _XmHTMLPart {
   /* Original document Resources */
   String            value;      
   String            source;     
   String            mime_type;  
   Byte           mime_id; 
   Boolean           input_complete;   

   /* Anchor resources */
   Cursor            anchor_cursor;
   Boolean           anchor_display_cursor;
   Boolean           anchor_buttons;

   /* anchor colors */
   Pixel          anchor_fg;
   Pixel          anchor_visited_fg;
   Pixel          anchor_target_fg;
   Pixel          anchor_activated_fg;
   Pixel          anchor_activated_bg;
   Boolean           highlight_on_enter;     

   /* anchor underlining styles */
   Byte           anchor_underline_type;
   Byte           anchor_visited_underline_type;
   Byte           anchor_target_underline_type;

   /* internal underlining styles, translated from above */
   Byte           anchor_line;
   Byte           anchor_target_line;
   Byte           anchor_visited_line;

   Position       anchor_position_x;   
   Position       anchor_position_y;   
   XmHTMLObjectTable *armed_anchor;    
   XmHTMLAnchor      *anchor_current_cursor_element;
   XmHTMLAnchorProc  anchor_visited_proc;

   /* background image/color and text color resources */
   Boolean           body_colors_enabled;
   Boolean           body_images_enabled;
   Boolean           allow_color_switching;
   Boolean           allow_form_coloring; 
   Boolean           freeze_animations;
   Boolean           icon_entities_enabled;
   Byte           icon_valign;
   Pixel          body_bg;    
   Pixel          body_fg;    
   String            body_image_url;   
   String            def_body_image_url;  
   XmHTMLImage         *body_image; 
   GC             bg_gc;         

   /* Font resources */
   String            charset;
   String            font_family;
   String            font_family_fixed;
   String            font_sizes;
   String            font_sizes_fixed;
   XmHTMLfont        *default_font;
   Byte           string_direction;
   Byte           alignment;
   Alignment         default_halign;
   Boolean           allow_font_switching;
   int               tabwidth;

   /* Image resources */
   Boolean           images_enabled;   
   int               max_image_colors; 
   float          screen_gamma;  
   XmImageProc       image_proc;    
   XmImageGifProc    gif_proc;      
   String            zCmd;       
   XmHTMLImage       *images;    
   Boolean           delayed_creation; 
   XCC               xcc;        

   Byte           map_to_palette;   
   String            palette;    

   /* Imagemap resources */
   XmHTMLImageMap    *image_maps;   
   Pixel          imagemap_fg;   
   Boolean           imagemap_draw; 

   /* Frame resources */
   Boolean           is_frame;      
   FrameScrolling    scroll_type;   
   int               frame_border;  
   int               nframes;    
   XmHTMLFrameWidget **frames;      

   /* Document resources */
   Boolean           strict_checking;
   Boolean           enable_outlining;
   Byte           bad_html_warnings;
   XtPointer         client_data;   

   /* Private Resources */
   Dimension         margin_width;  
   Dimension         margin_height;
   Widget            work_area;     
   Dimension         work_width;    
   Dimension         work_height;

   Boolean           resize_height; 
   Boolean           resize_width;  

   /* Progressive Loader Context buffer and interval */
   PLCPtr            plc_buffer;    
   int               num_plcs;      
   int               plc_def_delay; 
   int               plc_delay;     
   int               plc_min_delay; 
   int               plc_max_delay; 
   XtIntervalId      plc_proc_id;   
   XmHTMLGetDataProc get_data;      
   XmHTMLEndDataProc end_data;      
   Boolean           plc_suspended; 
   GC             plc_gc;        

   XmHTMLLoadType    load_type;     

   /* perform final dithering pass/use image colors */
   Byte           perfect_colors;

   /* Internal stuff for alpha channelled PNG images */
   AlphaPtr       alpha_buffer;
   Byte           rgb_conv_mode; 
   Byte           alpha_processing; 

   /* 
   * Fallback colors, required for proper color resetting between documents
   * with and without a <body> color spec.
   */
   Pixel          anchor_fg_save;
   Pixel          anchor_visited_fg_save;
   Pixel          anchor_target_fg_save;
   Pixel          anchor_activated_fg_save;
   Pixel          anchor_activated_bg_save;
   Pixel          body_bg_save;
   Pixel          body_fg_save;

   /* Scrollbar resources */
   Widget            hsb;        
   Widget            vsb;        
   Byte           sb_policy;     
   Byte           sb_placement;  
   int               scroll_x;      
   int               scroll_y;      
   Boolean           needs_hsb;     
   Boolean           needs_vsb;     

   /* Callback resources */
   XtCallbackList    activate_callback;
   XtCallbackList    arm_callback;
   XtCallbackList    anchor_track_callback;
   XtCallbackList    frame_callback;
   XtCallbackList    form_callback;
   XtCallbackList    input_callback;
   XtCallbackList    link_callback;
   XtCallbackList    motion_track_callback;
   XtCallbackList    imagemap_callback;
   XtCallbackList    document_callback;
   XtCallbackList    focus_callback;
   XtCallbackList    losing_focus_callback;
   XtCallbackList    event_callback;
   XtCallbackList    object_callback;
   XtCallbackList    page_callback;

   Boolean           need_tracking; 

   XmHTMLEventProc      event_proc;    
   HTEvent           *events;    
   int               nevents;    
   AllEvents         *body_events;  

   /* Formatted document resources */
   int               formatted_width;  
   int               formatted_height; 
   int               num_named_anchors;   
   int               anchor_words;  
   XmHTMLWord        *anchors;      
   XmHTMLObject      *elements;     
   XmHTMLObjectTable *named_anchors; 
   XmHTMLAnchor      *anchor_data;  
   XmHTMLObjectTable *formatted;    
   XmHTMLObjectTable *paint_start;  
   XmHTMLObjectTable *paint_end;    
   int               paint_x;    
   int               paint_y;    
   int               paint_width;   
   int               paint_height;  
   Cardinal       top_line;      
   Cardinal       nlines;        
   XmHTMLLineTable      *line_table;   

   /* Progressive document loading */
   XmHTMLObject      *first_element;   
   XmHTMLObject      *last_element; 
   XmHTMLObjectTable *first_formatted;
   XmHTMLObjectTable *last_formatted;

   /* Table resources */
   XmHTMLTable       *tables;    

   /* Embedded object resources */
   XmHTMLExtObj      *embedded;     

   /* Anchor activation resources */
   int               press_x;    
   int               press_y;
   Time           pressed_time;  
   Time           selected_time; 
   XmHTMLAnchor      *selected;     
   XmHTMLObjectTable *current_anchor;

   /* Text selection resources */
   XmHTMLObjectTable *selection;    
   int               select_start;  
   int               select_end;    

   /* HTML Form resources */
   XmHTMLFormData    *form_data;    

   /* Misc. resources */
   int               repeat_delay;  
   Boolean           smooth_scroll; 
   GC             gc;            
   Boolean           in_layout;     /* layout blocking flag.
                               * Also used as SetValues blocking
                               * flag by the parser.
                               */
   int               visibility;    

   ToolkitAbstraction   *tka;       

#ifdef DEBUG
   Boolean           debug_disable_warnings; 
   Boolean           debug_full_output;   
   Boolean           debug_save_clipmasks; 
   Boolean           debug_no_loopcount;  
   String            debug_prefix;     
   String            debug_levels;     
#endif

   unsigned char pad[60];           

}XmHTMLPart;

typedef struct _XmHTMLRec
{
   CorePart    core;
   CompositePart  composite;
   ConstraintPart constraint;
   XmManagerPart  manager;
   XmHTMLPart     html;
} XmHTMLRec;

/* Define subclassing level index to be used with ResolvePartOffset */
#define XmHTMLIndex     (XmManagerIndex+1)

externalref XmHTMLClassRec xmHTMLClassRec;


/***
* Prototypes that I moved here from XmHTMLI.h so I could export them
***/
XMHTMLEXPORT void _XmHTMLComputeLayout(XmHTMLWidget html);
XMHTMLEXPORT void _XmHTMLPaint(XmHTMLWidget html, struct _XmHTMLObjectTable *start, 
      struct _XmHTMLObjectTable *end); 

/***n
* Pull in internal function proto's & warnings when building the library.
*****/
#ifdef _LIBRARY
#include "XmHTMLI.h"
#include "HTMLWarnings.h"
#endif

#ifdef __cplusplus
}
#endif
_XFUNCPROTOEND

#endif 
/* Don't add anything after this endif! */
#endif 

#endif  // INC_MI32_XMHTMLP_H

---