/*****
* HTML.h : XmHTML Widget public header file.
* Resource defines, enumerations and structures.
*
* This file Version $Revision: 1.5 $
*
* Creation date: Tue Apr 15 23:39:26 GMT+0100 1997
* Last modification: $Date: 1997/12/29 22:16:18 $
* By: $Author: unammx $
* Current State: $State: Exp $
*
* Author: newt
*
* Copyright (C) 1994-1997 by 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.
*
*****/
/*****
* $Source: /cvs/gnome/gnome-libs/gtk-xmhtml/HTML.h,v $
*****/
/*****
* ChangeLog
* $Log: HTML.h,v $
* Revision 1.5 1997/12/29 22:16:18 unammx
* This version does:
*
* - Sync with Koen to version Beta 1.1.2c of the XmHTML widget.
* Includes various table fixes.
*
* - Callbacks are now properly checked for the Gtk edition (ie,
* signals).
*
* Revision 1.4 1997/12/26 23:54:37 unammx
* More Gtk/XmHTML work: now a number of features can be configured on
* the widget, look at the gazillions of options in gtk-xmhtml.h for
* more information. This is probably not complete, I have to read
* over the XmHTML/Motif docs for figuring which other bits I am missing.
*
* Known bug: the parser is not fixing documents without
tags,
* so this means that the program is crashing if you pass a document
* withou the BODY. I bet this is caused by some mistake of mine in
* the handling of the old/new/current widgets as created by Motif.
*
* Miguel.
*
* Revision 1.3 1997/12/25 01:34:08 unammx
* Good news for the day:
*
* I have upgraded our XmHTML sources to XmHTML 1.1.1.
*
* This basically means that we got table support :-)
*
* Still left to do:
*
* - Set/Get gtk interface for all of the toys in the widget.
* - Frame support is broken, dunno why.
* - Form support (ie adding widgets to it)
*
* Miguel.
*
* Revision 1.2 1997/12/11 21:20:19 unammx
* Step 2: more gtk/xmhtml code, still non-working - mig
*
* Revision 1.1 1997/11/28 03:38:53 gnomecvs
* Work in progress port of XmHTML; No, it does not compile, don't even try -mig
*
* Revision 1.6 1997/10/23 00:24:27 newt
* XmHTML Beta 1.1.0 release
*
* Revision 1.5 1997/08/31 17:30:39 newt
* Removed HT_TEXTFLOW
*
* Revision 1.4 1997/08/30 00:22:46 newt
* Alpha channel resources: XmNalphaChannelProcessing and
* XmNimageRGBConversion. Updated comments and reorganized a bunch of things.
*
* Revision 1.3 1997/08/01 12:52:11 newt
* Progressive image loading changes
*
* Revision 1.2 1997/05/28 01:29:28 newt
* XmImage changes: added the XmImageConfig structure and configuration flags.
* Added support for the XmNdecodeGIFProc resource.
*
* Revision 1.1 1997/04/29 14:19:18 newt
* Initial Revision
*
*****/
#ifndef _HTML_h_
#define _HTML_h_
/* include our new resources */
#ifdef WITH_MOTIF
# include
#endif
/******************************************************************************
* Enumerations and other constants
******************************************************************************/
/*****
* HTML Elements internal id's
* This list is alphabetically sorted to speed up the searching process.
* DO NOT MODIFY
*****/
typedef enum{
HT_DOCTYPE, HT_A, HT_ADDRESS, HT_APPLET, HT_AREA, HT_B, HT_BASE, HT_BASEFONT,
HT_BIG, HT_BLOCKQUOTE, HT_BODY, HT_BR, HT_CAPTION, HT_CENTER, HT_CITE, HT_CODE,
HT_DD, HT_DFN, HT_DIR, HT_DIV, HT_DL, HT_DT, HT_EM, HT_FONT, HT_FORM, HT_FRAME,
HT_FRAMESET, HT_H1, HT_H2, HT_H3, HT_H4, HT_H5, HT_H6, HT_HEAD, HT_HR, HT_HTML,
HT_I, HT_IMG, HT_INPUT, HT_ISINDEX, HT_KBD, HT_LI, HT_LINK, HT_MAP, HT_MENU,
HT_META, HT_NOFRAMES, HT_OL, HT_OPTION, HT_P, HT_PARAM, HT_PRE, HT_SAMP,
HT_SCRIPT, HT_SELECT, HT_SMALL, HT_STRIKE, HT_STRONG, HT_STYLE, HT_SUB,
HT_SUP, HT_TAB, HT_TABLE, HT_TD, HT_TEXTAREA, HT_TH, HT_TITLE,
HT_TR, HT_TT, HT_U, HT_UL, HT_VAR, HT_ZTEXT
}htmlEnum;
/*****
* Corresponding HTML element name table. Indexing with the above enumeration
* will give the corresponding element name.
*****/
extern String html_tokens[];
/*****
* XmHTML defines the following callback reasons. This might produce strange
* results once Motif decides to uses enum values above 16383.
* Send us a mail at ripley@xs4all.nl if you get problems that are due to
* these enumeration values.
*****/
enum{
XmCR_HTML_ANCHORTRACK = 16384, /* XmNanchorTrackCallback */
XmCR_HTML_DOCUMENT, /* XmNdocumentCallback */
XmCR_HTML_FORM, /* XmNformCallback */
XmCR_HTML_FRAME, /* XmNframeCallback */
XmCR_HTML_FRAMECREATE, /* XmNframeCallback */
XmCR_HTML_FRAMEDESTROY, /* XmNframeCallback */
XmCR_HTML_IMAGEMAPACTIVATE, /* XmNimagemapCallback */
XmCR_HTML_IMAGEMAP, /* XmNimagemapCallback */
XmCR_HTML_LINK, /* XmNlinkCallback */
XmCR_HTML_MODIFYING_TEXT_VALUE, /* XmNmodifyVerifyCallback */
XmCR_HTML_MOTIONTRACK, /* XmNmotionTrackCallback */
XmCR_HTML_PARSER, /* XmNparserCallback */
XmCR_HTML_EVENT, /* XmNeventCallback */
XmCR_HTML_EVENTDESTROY /* XmNeventCallback */
};
/*****
* XmNeventCallback sub event types
*****/
enum{
/* Document/Frame specific events */
XmCR_HTML_LOAD = 0, /* onLoad */
XmCR_HTML_UNLOAD, /* onUnLoad */
/* HTML Form specific events */
XmCR_HTML_SUBMIT, /* onSubmit */
XmCR_HTML_RESET, /* onReset */
XmCR_HTML_FOCUS, /* onFocus */
XmCR_HTML_BLUR, /* onBlur */
XmCR_HTML_SELECT, /* onSelect */
XmCR_HTML_CHANGE, /* onChange */
/* object events */
XmCR_HTML_CLICK, /* onClick */
XmCR_HTML_DOUBLE_CLICK, /* onDblClick */
XmCR_HTML_MOUSEDOWN, /* onMouseDown */
XmCR_HTML_MOUSEUP, /* onMouseUp */
XmCR_HTML_MOUSEOVER, /* onMouseOver */
XmCR_HTML_MOUSEMOVE, /* onMouseMove */
XmCR_HTML_MOUSEOUT, /* onMouseOut */
XmCR_HTML_KEYPRESS, /* onKeyPress */
XmCR_HTML_KEYDOWN, /* onKeyDown */
XmCR_HTML_KEYUP, /* onKeyUp */
XmCR_HTML_USEREVENT /* must always be last */
};
/*****
* URL types XmHTML knows of.
* The hostnames, files and port numbers are only shown for demonstration
* purposes, XmHTML doesn't care whether they are present or not.
*****/
typedef enum{
ANCHOR_UNKNOWN = 0, /* unknown href */
ANCHOR_NAMED, /* name="...." */
ANCHOR_JUMP, /* href="#..." */
ANCHOR_FILE_LOCAL, /* href="file.html"
* href="file:/file.html" (clearly local)
* href="file:///file.html" (NULL host)
* href="file://localhost/file.html" (localhost)
*/
ANCHOR_FILE_REMOTE, /* href="file://foo.bar/file.html" */
ANCHOR_FTP, /* href="ftp://foo.bar/file" */
ANCHOR_HTTP, /* href="http://foo.bar/file.html" */
ANCHOR_SECURE_HTTP, /* href="https://foo.bar/file.html" */
ANCHOR_GOPHER, /* href="gopher://foo.bar:70" */
ANCHOR_WAIS, /* href="wais://foo.bar" */
ANCHOR_NEWS, /* href="news://foo.bar" */
ANCHOR_TELNET, /* href="telnet://foo.bar:23" */
ANCHOR_MAILTO, /* href="mailto:foo@bar" */
ANCHOR_EXEC, /* href="exec:foo_bar" */
ANCHOR_PIPE, /* href="pipe:foo_bar" */
ANCHOR_ABOUT, /* href="about:..." */
ANCHOR_INFO, /* href="info:.." */
ANCHOR_MAN, /* href="man:..." */
ANCHOR_FORM_IMAGE /* , only used internally */
}URLType;
/*****
* Procedure to be called whenever a script is encountered
* Arguments:
* Tidget: XmHTMLWidget id
* String: script source text
* TPointer: XmNclientData value
* Return value:
* data to be stored whenever a document event should be processed.
* This data is unused internally and is provided as the user_data
* argument in the XmHTMLEvent structure. For example, the return value
* could be a pointer into some internal procedural database, a ptr to a
* compiled script procedure or the script source text if you want to
* process it at some later time (when the event occurs).
*
* When NULL is returned the event in question is disabled.
*****/
typedef TPointer (*XmHTMLEventProc)(TWidget, String, TPointer);
/*****
* HTML Form component types
*****/
typedef enum{
FORM_TEXT = 1, /* textfield */
FORM_PASSWD, /* password textfield */
FORM_CHECK, /* checkbox */
FORM_RADIO, /* radiobox */
FORM_RESET, /* reset button */
FORM_FILE, /* filelisting */
FORM_SELECT, /* select parent */
FORM_OPTION, /* select child */
FORM_TEXTAREA, /* multiline edit field */
FORM_IMAGE, /* drawbutton */
FORM_HIDDEN, /* hidden input */
FORM_SUBMIT /* submit button */
}componentType;
/*****
* Supported HTML Form method types
*****/
enum{
XmHTML_FORM_GET = 0, /* method = get */
XmHTML_FORM_POST, /* method = post */
XmHTML_FORM_PIPE /* method = pipe */
};
/*****
* possible error codes for XmNparserCallback
*****/
typedef enum{
HTML_UNKNOWN_ELEMENT = 1, /* unknown HTML element */
HTML_BAD, /* very badly placed element */
HTML_OPEN_BLOCK, /* block still open while new block started */
HTML_CLOSE_BLOCK, /* block closed but was never opened */
HTML_OPEN_ELEMENT, /* unbalanced terminator */
HTML_NESTED, /* improperly nested element */
HTML_VIOLATION, /* bad content for current block/element */
HTML_NOTIFY, /* notification of text insertion/removal */
HTML_INTERNAL /* internal parser error */
}parserError;
/*****
* And corresponding values for XmNenableBadHTMLWarnings.
* These are or'd together.
* XmNONE disables warnings and XmHTML_ALL enables all warnings.
* See parserError for their meaning.
*****/
enum{
XmHTML_NONE = 0, /* no warnings */
XmHTML_UNKNOWN_ELEMENT = 1,
XmHTML_BAD = 2,
XmHTML_OPEN_BLOCK = 4,
XmHTML_CLOSE_BLOCK = 8,
XmHTML_OPEN_ELEMENT = 16,
XmHTML_NESTED = 32,
XmHTML_VIOLATION = 64,
XmHTML_ALL = 127 /* all warnings */
};
/*****
* possible action codes for the action field in the XmHTMLParserCallbackStruct
*****/
enum{
HTML_REMOVE = 1, /* remove offending element */
HTML_INSERT, /* insert missing element */
HTML_SWITCH, /* switch offending and expected element */
HTML_KEEP, /* keep offending element */
HTML_IGNORE, /* ignore, proceed as if nothing happened */
HTML_ALIAS, /* alias an unknown element to known one */
HTML_TERMINATE /* terminate parser */
};
/*****
* Possible return codes for XmHTMLImageGetType().
*****/
enum{
IMAGE_ERROR = 0, /* error on image loading */
IMAGE_UNKNOWN, /* unknown image */
IMAGE_XPM, /* X11 pixmap */
IMAGE_XBM, /* X11 bitmap */
IMAGE_GIF, /* CompuServe(C) Gif87a or Gif89a */
IMAGE_GIFANIM, /* animated gif */
IMAGE_GIFANIMLOOP, /* animated gif with loop extension */
IMAGE_GZF, /* compatible Gif87a or Gif89a */
IMAGE_GZFANIM, /* compatible animated gif */
IMAGE_GZFANIMLOOP, /* compatible animated gif */
IMAGE_JPEG, /* JPEG image */
IMAGE_PNG, /* PNG image */
IMAGE_FLG /* Fast Loadable Graphic */
};
/*****
* Possible return values for a function installed on the
* XmNprogressiveReadProc resource.
*****/
#define STREAM_OK 1 /* internally used value */
#define STREAM_END 0 /* data stream ended (no more data) */
#define STREAM_SUSPEND -1 /* data stream suspended (not enough data) */
#define STREAM_ABORT -2 /* data stream aborted */
#define STREAM_RESIZE -3 /* resize input buffer */
/*****
* Possible return values for the XmNdecodeGIFProc resource and
* values for the XmHTMLGIFStream state.
*****/
#define GIF_STREAM_OK 2
#define GIF_STREAM_END 1
#define GIF_STREAM_ERR 0
#define GIF_STREAM_INIT -1
#define GIF_STREAM_FINAL -2
/*****
* Possible return values from a number of image related routines.
* The actual meaning depends on the routine used.
*****/
typedef enum{
XmIMAGE_ERROR = 0, /* unknown error occured */
XmIMAGE_BAD, /* bad function call: missing arg or so */
XmIMAGE_UNKNOWN, /* provided XmImage/XmImageInfo unknown/unbound */
XmIMAGE_ALMOST, /* action completed, further response necessary */
XmIMAGE_OK /* action completed. */
}XmImageStatus;
/*****
* Possible values for transparency (value for the "bg" field in both
* XmImage and XmImageInfo structures). Possible values are:
*
* XmIMAGE_NONE
* indicates the image is not transparent
* XmIMAGE_TRANSPARENCY_BG
* indicates the image achieves transparency by substituting the current
* background setting (can be a single color or background image. Internally,
* such transparency is achieved by using a clipmask).
* XmIMAGE_TRANSPARENCY_ALPHA
* indicates the image achieves transparency by using an alpha channel.
* This transparency is currently only used by PNG images with an alpha
* channel or a tRNS chunk (which is expanded to an alpha channel internally).
*****/
enum{
XmIMAGE_NONE = 0,
XmIMAGE_TRANSPARENCY_BG,
XmIMAGE_TRANSPARENCY_ALPHA
};
/*****
* Possible values for the colorspace value.
*
* XmIMAGE_COLORSPACE_GRAYSCALE
* image contains only shades of gray. The colorcube is reduced to a 1D
* representation. All components in a shade have the same value. The
* pixel values are equal to the value of a single color component.
* XmIMAGE_COLORSPACE_INDEXED
* image uses a fixed palette. Colorcube is mapped to a 1D lookup-table.
* XmIMAGE_COLORSPACE_RGB
* image uses a full 3D colorcube.
*****/
enum{
/* XmIMAGE_NONE */
XmIMAGE_COLORSPACE_GRAYSCALE = 1,
XmIMAGE_COLORSPACE_INDEXED,
XmIMAGE_COLORSPACE_RGB
};
/*****
* XmImageInfo structure options field bits.
* The ``Set by default'' indicates a bit set when the XmHTMLImageDefaultProc
* is used to read an image. The ``Read Only'' indicates a bit you should
* consider as read-only.
* XmIMAGE_DELAYED
* Indicates the image is delayed, e.i. it will be provided at a later stage;
* XmIMAGE_DEFERRED_FREE
* Indicates XmHTML may free this structure when a new document is loaded.
* XmIMAGE_IMMEDIATE_FREE
* Indicates XmHTML may free this structure when XmHTML no longer needs it;
* XmIMAGE_RGB_SINGLE
* Indicates that the reds, greens and blues fields are allocated in a single
* memory area instead of three seperate memory arrays.
* XmIMAGE_ALLOW_SCALE
* Indicates that scaling an image is allowed.
* XmIMAGE_FRAME_IGNORE
* Use with animations: set this bit when a frame falls outside the logical
* screen area. No pixmap is created but the timeout for the frame is kept.
* XmIMAGE_CLIPMASK
* This bit is set when the returned XmImageInfo structure contains clipmask
* data. XmHTML uses this info to create a clipping bitmap. Changing this
* bit from set to unset will lead to a memory leak while changing it from
* unset to set *without* providing a clipmask yourself *will* cause an error
* to happen. You can set this bit when you are providing your own clipmask
* (to provide non-rectangular images for example), PROVIDED you fill the
* ``clip'' field with valid bitmap data (a stream of bytes in XYBitmap format
* and the same size of the image).
* XmIMAGE_SHARED_DATA
* This bit is set when images share data. XmHTML sets this bit when the image
* in question is an internal image, e.i., one for which the image data may
* never be freed. Be carefull setting this bit yourself, since it prevents
* XmHTML from freeing the image data present in the XmImageInfo structure.
* It can easily lead to memory leaks when an image is *not* an internal
* image.
* XmIMAGE_PROGRESSIVE
* Setting this bit will enable XmHTML progressive image loading. A function
* *must* have been installed on the XmNprogressiveReadProc resource *prior*
* to setting this bit. Installing a function on the XmNprogressiveEndProc
* is optional. When this bit is set all other bits will be ignored.
* XmIMAGE_DELAYED_CREATION
* This bit is read-only. It is used internally by XmHTML for images with
* an alpha channel. Alpha channel processing merges the current background
* with the original RGB data from the image and uses the result to compose
* the actual on-screen image (the merged data is stored in the ``data''
* field of the XmImageInfo structure). XmHTML needs to store the original
* data somewhere, and when this bit is set it is stored in the ``rgb'' field
* of the XmImageInfo structure.
* When this bit is set, the returned XmImageInfo may *NOT BE FREED* as long
* as the current document is alive. You can discard it as soon as a new
* document is loaded.
*****/
#define XmIMAGE_DELAYED (1<<1)
#define XmIMAGE_DEFERRED_FREE (1<<2) /* set by default */
#define XmIMAGE_IMMEDIATE_FREE (1<<3)
#define XmIMAGE_RGB_SINGLE (1<<4) /* set by default */
#define XmIMAGE_ALLOW_SCALE (1<<5) /* set by default */
#define XmIMAGE_FRAME_IGNORE (1<<6)
#define XmIMAGE_CLIPMASK (1<<7) /* Read Only */
#define XmIMAGE_SHARED_DATA (1<<8) /* Read Only */
#define XmIMAGE_PROGRESSIVE (1<<9)
#define XmIMAGE_DELAYED_CREATION (1<<10) /* Read Only */
/*****
* XmImageInfo animation disposal values
* A disposal method specifies what should be done before the current frame is
* rendered. Possible values are:
* XmIMAGE_DISPOSE_NONE
* do nothing, overlays the previous frame with the current frame.
* XmIMAGE_DISPOSE_BY_BACKGROUND
* Restore to background color. The area used by the previous frame must
* be restored to the background color/image
* XmIMAGE_DISPOSE_BY_PREVIOUS
* Restore to previous. The area used by the previous frame must be
* restored to what was there prior to rendering the previous frame.
*****/
enum{
/* XmIMAGE_NONE */
XmIMAGE_DISPOSE_NONE = 1, /* default behaviour */
XmIMAGE_DISPOSE_BY_BACKGROUND,
XmIMAGE_DISPOSE_BY_PREVIOUS
};
/*****
* Primary image cache actions
* (unimplemented)
*****/
#define IMAGE_STORE 0 /* store an image in the cache */
#define IMAGE_GET 1 /* retrieve an image from the cache */
#define IMAGE_DISCARD 2 /* discard an image from the cache */
/*****
* XmNperfectColors/XmNalphaChannelProcessing resource values.
*
* Note: these values are represented by the XmCEnableMode resource class.
*****/
enum{
/* XmAUTOMATIC */
XmALWAYS = 1,
XmNEVER
};
/*****
* Possible XmNimageMapToPalette/XmNimageRGBConversion resource values:
*
* XmQUICK
* RGBConversion:
* first checks if the 24bit image contains less than XmNmaxImageColors.
* If not, XmHTML will dither to a fixed palette. This is fast but has
* the disadvantage that the background color in an alpha channelled
* image will not be matched exactly.
* MapToPalette:
* Use closest distance algorithm to map colors to the palette. No
* error correction is performed. Reasonably fast, but quality
* heavily depends on the distribution of the colors in the image.
* XmBEST
* RGBConversion (default):
* first checks if the 24bit image contains less than XmNmaxImageColors.
* If it is, the actual image colors are used. If not, a histogram of the
* image is computed, the most used colors are selected and the resulting
* image is dithered to this palette.
* Offers best 24 to 8bit conversion and is probably faster than XmSLOW
* as only images with more than XmNmaxImageColors will be dithered.
* MapToPalette:
* Ordered dithering using predefined error matrices. Reasonably fast and
* quite good results;
* XmFAST
* RGBConversion:
* Skips the check and dithers to a fixed palette right away. This is the
* fastest way to do 24 to 8bit conversion but has the disadvantage that
* every 24bit image is dithered to a fixed palette, regardless of the
* actual no of colors in the image.
* MapToPalette:
* Simple ordered dithering. Fastest but probably the poorest results.
* XmSLOW
* RGBConversion:
* Skips the check and does histogram stuff right away.
* MapToPalette:
* closest distance algorithm to map image colors to the palette and use
* dynamic error correction. Slowest but best results;
* XmDISABLED
* RGBConversion:
* ignored;
* MapToPalette (default):
* Disables palette mapping;
*
* Note: these values are represented by the XmCConversionMode resource class.
*****/
typedef enum {
XmQUICK = 0,
XmBEST,
XmFAST,
XmSLOW,
XmDISABLED
} XmHTMLDitherType;
/*****
* Search directions: forward or backward search
*****/
typedef enum{
XmHTML_FORWARD,
XmHTML_BACKWARD
}XmHTMLDirection;
/*****
* XmHTMLPosition is a fully opaque type
*****/
typedef struct _XmHTMLObjectTableElement *XmHTMLPosition;
/*****
* Custom Papersize dimension unit type
* (under construction)
*****/
enum{
XmHTML_CHAR = 0,
XmHTML_CENTIMETER, /* 1cm = 0.39in */
XmHTML_MILLIMETER, /* 1mm = 0.1cm */
XmHTML_INCH, /* 1in = 2.54cm */
XmHTML_PICA, /* 1pc = 12pt */
XmHTML_POINT /* 1in = 72.27pt, 1cm = 28.45pt */
};
/*****
* XmHTMLTextGetFormatted paper size defines
* (under construction)
*****/
enum{
XmHTMLTEXT_PAPERSIZE_A4 = 0,
XmHTMLTEXT_PAPERSIZE_LETTER,
XmHTMLTEXT_PAPERSIZE_CUSTOM
};
/*****
* XmHTMLTextGetFormatted type definitions
* (under construction)
*****/
enum{
XmHTMLTEXT_PLAIN = 0, /* generate plain ASCII document */
XmHTMLTEXT_FORMATTED, /* generate formatted ASCII document */
XmHTMLTEXT_POSTSCRIPT /* generate formatted Postscript output */
};
/*****
* XmHTMLTextGetFormatted Postscript option bits
* (under construction)
* The MIMIC_FONTS bit instructs XmHTML to use any of the supported postscript
* fonts to approach the fonts used in the document. When set, all other font
* bits are ignored. When not used, the PSFONT bits can be or'd together.
* XmHTML will attempt to do the following mapping:
* PSFONT_ROMAN/PSFONT_CENTURY -> default text font;
* PSFONT_HELVETICA/PSFONT_LUCIDA -> fixed width font;
* If only one of the PSFONT bits is set, the entire document will be rendered
* in that font.
*****/
#define XmHTMLTEXT_ADDHEADER (1<<1)
#define XmHTMLTEXT_ADDFOOTER (1<<2)
#define XmHTMLTEXT_PSFONT_ROMAN (1<<3)
#define XmHTMLTEXT_PSFONT_HELVETICA (1<<4)
#define XmHTMLTEXT_PSFONT_CENTURY (1<<5)
#define XmHTMLTEXT_PSFONT_LUCIDA (1<<6)
#define XmHTMLTEXT_MIMIC_FONTS (1<<7)
/*****
* XmHTMLGetHeadAttributes mask bits
*****/
#define HeadClear ((unsigned char)0) /* clear everything */
#define HeadDocType (1<<0) /* fill doctype member */
#define HeadTitle (1<<1) /* fill title member */
#define HeadIsIndex (1<<2) /* fill isIndex member */
#define HeadBase (1<<3) /* fill Base member */
#define HeadMeta (1<<4) /* fill meta members */
#define HeadLink (1<<5) /* fill link members */
#define HeadScript (1<<6) /* fill script members */
#define HeadStyle (1<<7) /* fill Style members */
#define HeadAll ((unsigned char)~0) /* fill all members */
/*****
* XmImage frame selection flags.
* any positive number will return the requested frame. If larger than
* total framecount, last frame is returned.
*****/
#define AllFrames -1 /* do all frames */
#define FirstFrame -2 /* only use first frame */
#define LastFrame -3 /* only do last frame */
/*****
* XmImage configuration flags
*****/
#define ImageFSDither (1L<<1) /* Floyd-Steinberg on quantized images */
#define ImageCreateGC (1L<<2) /* create gc for image */
#define ImageWorkSpace (1L<<3) /* create animation workspace */
#define ImageClipmask (1L<<4) /* create clipmask */
#define ImageBackground (1L<<5) /* substitute background pixel */
#define ImageQuantize (1L<<6) /* quantize image */
#define ImageMaxColors (1L<<7) /* sets maximum colors */
#define ImageGifDecodeProc (1L<<8) /* gif lzw decoder function */
#define ImageGifzCmd (1L<<9) /* gif lzw uncompress command */
#define ImageFrameSelect (1L<<10)/* frame selection */
#define ImageScreenGamma (1L<<11)/* gamma correction. JPEG and PNG only */
/******************************************************************************
* Commonly used structures
******************************************************************************/
/*****
* Representation of parsed HTML elements
*****/
typedef struct _XmHTMLObject{
htmlEnum id; /* internal ID for this element */
String element; /* element text */
String attributes; /* element attributes (if any) */
Boolean is_end; /* true if this is a closing element */
Boolean terminated; /* true if element has closing counterpart */
Cardinal line; /* line number in input for this element */
struct _XmHTMLObject *next;
struct _XmHTMLObject *prev;
}XmHTMLObject;
/*****
* Custom papersize definition
*****/
typedef struct _XmHTMLPaperSize{
unsigned char unit_type; /* unit in which dimensions are specified */
unsigned char paper_type; /* type of paper: A4, US or custom */
Cardinal width; /* total paper width */
Cardinal height; /* total paper height */
Cardinal left_margin; /* left text margin */
Cardinal right_margin; /* right text margin */
Cardinal top_margin; /* top text margin */
Cardinal bottom_margin; /* bottom text margin */
}XmHTMLPaperSize;
/*****
* The following structure is returned by the XmHTMLImageDefaultProc convenience
* function. When a procedure for the XmNimageProc resource is installed,
* it *must* return this structure.
*****/
typedef struct _XmImageInfo
{
/* regular image fields */
String url; /* original location of image */
unsigned char *data; /* raw image data. ZPixmap format */
unsigned char *clip; /* raw clipmask data. XYBitmap format */
Dimension width; /* used image width, in pixels */
Dimension height; /* used image height, in pixels */
Dimension *reds; /* red image pixels */
Dimension *greens; /* green image pixels */
Dimension *blues; /* blue image pixels */
int bg; /* transparent pixel index/type */
unsigned int ncolors; /* Number of colors in the image */
unsigned int options; /* image option bits */
/* image classification fields and original data */
unsigned char type; /* image type, see the IMAGE_ enum above */
unsigned char depth; /* bits per pixel for this image */
unsigned char colorspace; /* colorspace for this image */
unsigned char transparency; /* transparency type for this image */
Dimension swidth; /* image width as read from image */
Dimension sheight; /* image height as read from image */
unsigned int scolors; /* Original number of colors in the image */
/* Special fields for images with an alpha channel */
unsigned char *alpha; /* alpha channel data */
float fg_gamma; /* image gamma */
/* Additional animation data */
int x; /* logical screen x-position for this frame */
int y; /* logical screen y-position for this frame */
int loop_count; /* animation loop count */
unsigned char dispose; /* image disposal method */
int timeout; /* frame refreshment in milliseconds */
int nframes; /* no of animation frames remaining */
struct _XmImageInfo *frame; /* ptr to next animation frame */
TPointer user_data; /* any data to be stored with this image */
}XmImageInfo, *XmImageInfoStruct;
/* XmHTML method to load images */
typedef XmImageInfo* (*XmImageProc)(TWidget, String, TPointer);
/****
* The next two structures constitute the XmImage definition which are used by
* the XmImageCreate and XmImageDestroy routines. Please note that the *only*
* safe way to destroy an XmImage is to use the XmImageDestroy function.
* XmHTML does not use the XmImage structure, it is provided for your
* convenience.
****/
/****
* Animation frame data.
****/
typedef struct{
int x; /* x position in logical screen */
int y; /* y position in logical screen */
int w; /* width of this particular frame */
int h; /* height of this particular frame */
int timeout; /* timeout for the next frame */
unsigned char dispose; /* previous frame disposal method */
TPixmap pixmap; /* actual image */
TPixmap clip; /* image clipmask */
TPixmap prev_state; /* previous screen state */
}XmImageFrame;
/*****
* Actual image definition.
* If you want access to the xcc member, include the XCC.h header file.
*****/
typedef struct{
String file; /* originating file */
unsigned char type; /* image type, see the IMAGE_ enum below */
TPixmap pixmap; /* actual image */
TPixmap clip; /* for transparant pixmaps */
unsigned int options; /* image option bits */
int width; /* current image width, in pixels */
int height; /* current image height, in pixels */
int ncolors; /* no of colors in this image */
int scolors; /* specified no of colors */
int swidth; /* image width as read from image */
int sheight; /* image height as read from image */
int depth; /* depth of this image */
int npixels; /* no of really allocated pixels */
TGC gc; /* graphics context for rendering */
/* animation data */
XmImageFrame *frames; /* array of animation frames */
int nframes; /* no of frames following */
int current_frame; /* current frame count */
int current_loop; /* current loop count */
int loop_count; /* maximum loop count */
TIntervalId proc_id; /* timer id for animations */
TWidget w; /* image owner */
TAppContext context; /* Application context for animations */
/* private data */
struct _XColorContext *xcc; /* a lot of visual info */
}XmImage;
/*****
* Link member information.
*****/
typedef struct
{
String url; /* value of URL tag */
String rel; /* value of REL tag */
String rev; /* value of REV tag */
String title; /* value of TITLE tag */
}XmHTMLLinkDataRec, *XmHTMLLinkDataPtr;
/*****
* Meta member information.
*****/
typedef struct
{
String http_equiv; /* value of HTTP-EQUIV tag */
String name; /* value of NAME tag */
String content; /* value of CONTENT tag */
}XmHTMLMetaDataRec, *XmHTMLMetaDataPtr;
/*****
* XmHTMLHeadAttributes definition
*****/
typedef struct{
String doctype; /* doctype data */
String title; /* document title */
Boolean is_index; /* true when the element exists */
String base; /* value of the element */
int num_meta; /* number of META info to process */
XmHTMLMetaDataPtr meta; /* array of META info to process */
int num_link; /* number of LINK info to process */
XmHTMLLinkDataPtr link; /* array of LINK info to process */
String style_type; /* value of the style type element tag */
String style; /* contents */
String script_lang; /* value of the language element tag */
String script; /* contents */
}XmHTMLHeadAttributes;
/*****
* XmHTMLFontCacheInfo definition. This structure is returned by the
* XmHTMLGetFontCacheInfo convenience routine and contains information about
* the font cache bound to the display of a given widget.
* The fonts and mapping arrays are in sync: when a name in the fonts array
* has a non-NULL entry at the corresponding position in the mapping array,
* the value of the mapping entry is the real font being used.
*****/
typedef struct{
int nentries; /* total no of cached fonts */
int nmaps; /* of which this many are mapped fonts */
int nlookups; /* no of search actions */
int nrequests; /* no of requests made */
int hits; /* no of hits */
int misses; /* no of misses */
String *fonts; /* array of font names, size nentries */
String *mapping; /* array of font mappings, size nentries */
int nwidgets; /* no of widgets using this cache */
WidgetList widgets; /* array of widgets */
}XmHTMLFontCacheInfo;
/*****
* forward declaration of XmHTMLAnchorCallback structure
*****/
typedef struct _XmHTMLAnchorCallbackStruct *XmHTMLAnchorPtr;
/*****
* XmHTMLXYToInfo return value
* This structure and any of it members may *never* be freed by the caller.
*****/
typedef struct
{
Cardinal line; /* line number at selected position */
Boolean is_map; /* true when clicked image is an imagemap */
int x,y; /* position relative to image corner */
XmImageInfo *image; /* image data */
XmHTMLAnchorPtr anchor; /* possible anchor data */
}XmHTMLInfoStructure, *XmHTMLInfoPtr;
/*****
* XmHTML progressive object loading
* (PLC stands for Progressive Loader Context)
*****/
typedef struct _XmHTMLPLCStream{
Cardinal total_in; /* no of bytes received so far */
Cardinal min_out; /* minimum number of bytes requested */
Cardinal max_out; /* maximum number of bytes requested */
TPointer user_data; /* any data registered on this PLC */
unsigned char pad[24]; /* reserved for future use */
}XmHTMLPLCStream;
/*****
* External GIF decoder stream object. This is the only argument to any
* procedure installed on the XmNdecodeGIFProc resource.
*
* The first block is kept up to date by XmHTML and is read-only. When state
* is GIF_STREAM_INIT, the decoder should initialize it's private data and store
* it in the external_state field so that it can be used for successive calls
* to the decoder. When state is GIF_STREAM_FINAL, the decoder should wrapup
* and flush all pending data. It can also choose to destruct it's internal
* data structures here (another call with state set to GIF_STREAM_END will be
* made when the internal loader is destroying it's internal objects as
* well).
*
* All following fields are the ``public'' fields and must be updated by the
* external decoder. The msg field can be set to an error message if the
* external decoder fails for some reason. XmHTML will then display this
* error message and abort this image.
*****/
typedef struct _XmHTMLGIFStream{
/* read-only fields */
int state; /* decoder state */
int codesize; /* initial LZW codesize */
Boolean is_progressive; /* when used by a progressive loader */
unsigned char *next_in; /* next input byte */
Cardinal avail_in; /* number of bytes available at next_in */
Cardinal total_in; /* total nb of input bytes read so far */
/* fields to be updated by caller */
unsigned char *next_out; /* next output byte should be put there */
Cardinal avail_out; /* remaining free space at next_out */
Cardinal total_out; /* total nb of bytes output so far */
String msg; /* last error message, or NULL */
TPointer external_state; /* room for decoder-specific data */
}XmHTMLGIFStream;
/* and the proto for the XmNdecodeGIFProc resource */
typedef int (*XmImageGifProc)(XmHTMLGIFStream*);
/*****
* Progressive Loading function prototypes.
* XmHTMLGetDataProc: proto for function installed on the
* XmNprogressiveReadProc resource;
* XmHTMLEndDataProc: proto for function installed on the
* XmNprogressiveEndProc resource;
*****/
typedef int (*XmHTMLGetDataProc)(XmHTMLPLCStream*, TPointer);
typedef void (*XmHTMLEndDataProc)(XmHTMLPLCStream*, TPointer, int, Boolean);
/*****
* possible values for the third argument on the EndDataProc
*****/
enum{
/* XmHTML_NONE = 0 */ /* PLCObject referenced by all objects */
XmPLC_IMAGE, /* PLCObject for an image */
XmPLC_DOCUMENT, /* PLCObject for a document */
XmPLC_FINISHED /* indicates all plc's have been processed */
};
/*****
* XmImage configuration
*****/
typedef struct{
unsigned long flags; /* XmImage configuration flags, see above */
int ncolors; /* desired number of colors */
int which_frames; /* animation frames selection flag */
int bg_color; /* background pixel on transparent images */
String z_cmd; /* gif uncompress command */
XmImageGifProc gif_proc; /* external gif decoder */
float gamma; /* gamma correction. JPEG and PNG only */
}XmImageConfig;
/******************************************************************************
* Callback structures
* Unless explicitly mentioned, *none* of these structures (or any of its
* members) may be freed.
******************************************************************************/
/*****
* XmNactivateCallback and XmNanchorTrackCallback callback structure.
*****/
typedef struct _XmHTMLAnchorCallbackStruct{
int reason; /* the reason the callback was called */
TEvent *event; /* event structure that triggered callback */
URLType url_type; /* type of url referenced */
Cardinal line; /* line number of the selected anchor */
String href; /* pointer to the anchor value */
String target; /* pointer to target value */
String rel; /* pointer to rel value */
String rev; /* pointer to rev value */
String title; /* pointer to title value */
Boolean is_frame; /* true when inside a frame */
Boolean doit; /* local anchor vetoing flag */
Boolean visited; /* local anchor visited flag */
}XmHTMLAnchorCallbackStruct;
typedef Boolean (*XmHTMLAnchorProc)(TWidget, String, TPointer);
/*****
* XmNeventCallback callback structure.
*****/
typedef struct{
int reason; /* the reason the event was called */
TEvent *event; /* event triggering this action */
int type; /* HTML4.0 event type, see above */
TPointer data; /* HTML4.0 event callback data */
}XmHTMLEventCallbackStruct;
/*****
* XmNdocumentCallback callback structure.
*****/
typedef struct
{
int reason; /* the reason the callback was called */
TEvent *event; /* always NULL for XmNdocumentCallback */
Boolean html32; /* True if document was HTML 3.2 conforming */
Boolean verified; /* True if document has been verified */
Boolean balanced; /* True if parser tree is balanced */
Boolean terminated; /* True if parser terminated prematurely */
int pass_level; /* current parser level count. Starts at 1 */
Boolean redo; /* perform another pass? */
}XmHTMLDocumentCallbackStruct, *XmHTMLDocumentPtr;
/*****
* XmNformCallback callback structure.
*****/
/*****
* Form Component data
*****/
typedef struct
{
componentType type; /* Form component type */
String name; /* component name */
String value; /* component value */
}XmHTMLFormDataRec, *XmHTMLFormDataPtr;
/*****
* Actual XmNformCallback callback structure.
*****/
typedef struct
{
int reason; /* the reason the callback was called */
TEvent *event; /* event structure that triggered callback */
String action; /* URL or cgi-bin destination */
String enctype; /* form encoding */
int method; /* Form Method, GET, POST or PIPE */
int ncomponents; /* no of components in this form */
XmHTMLFormDataPtr components;
}XmHTMLFormCallbackStruct, *XmHTMLFormPtr;
/*****
* XmNframeCallback callback structure.
* This callback is activated when one of the following events occurs:
* 1. XmHTML wants to create a frame, reason = XmCR_HTML_FRAMECREATE
* can be veto'd by setting doit to False and supplying a HTML widget
* id yourself;
* 2. XmHTML wants to destroy a frame, reason = XmCR_HTML_FRAMEDESTROY
* can be veto'd by setting doit to False (widget reuse).
* 3. XmHTML has finished creating a frame, reason = XmCR_HTML_FRAME.
* This is the time to attach callbacks and set additional resources on the
* newly created XmHTMLWidget.
*****/
typedef struct
{
int reason; /* the reason the callback was called */
TEvent *event; /* event structure that triggered callback */
String src; /* requested document */
String name; /* frame name */
TWidget html; /* XmHTML widget id */
Boolean doit; /* destroy/create vetoing flag */
}XmHTMLFrameCallbackStruct, *XmHTMLFramePtr;
/*****
* XmNimagemapCallback callback structure.
* callback reasons can be one of the following:
* XmCR_HTML_IMAGEMAP_ACTIVATE
* user clicked on an image. Valid fields are x, y and image_name. x and y
* are relative to the upper-left corner of the image. Only invoked when
* an image has it's ismap attribute set and no usemap is present for this
* image.
* XmCR_HTML_IMAGEMAP
* an image requires an external imagemap. The only valid field is map_name
* which contains the location of the imagemap to fetch. If the contents
* of this imagemap is set in the map_contents field, it will be loaded
* by the widget. Alternatively, one could also use the XmHTMLAddImagemap
* convenience routine to set an imagemap into the widget.
*****/
typedef struct
{
int reason; /* the reason the callback was called */
TEvent *event; /* event structure that triggered callback */
int x,y; /* position relative to the upper-left image corner */
String image_name; /* name of referenced image, value of src attribute */
String map_name; /* name of imagemap to fetch */
String map_contents;/* contents of fetched imagemap */
XmImageInfo *image; /* image data */
}XmHTMLImagemapCallbackStruct, *XmHTMLImagemapPtr;
/*****
* XmNlinkCallback callback structure.
*****/
typedef struct{
int reason; /* the reason the callback was called */
TEvent *event; /* event structure that triggered callback */
int num_link; /* number of LINK info to process */
XmHTMLLinkDataPtr link; /* array of LINK info to process */
}XmHTMLLinkCallbackStruct, *XmHTMLLinkPtr;
/* Don't add anything after this endif! */
#endif /* _HTML_h_ */