doc/gtkhtml-decl.txt

   1 <MACRO>
   2 <NAME>GTK_HTML_EMBEDDED</NAME>
   3 #define GTK_HTML_EMBEDDED(obj)         G_TYPE_CHECK_INSTANCE_CAST (obj, gtk_html_embedded_get_type (), GtkHTMLEmbedded)
   4 </MACRO>
   5 <MACRO>
   6 <NAME>GTK_HTML_EMBEDDED_CLASS</NAME>
   7 #define GTK_HTML_EMBEDDED_CLASS(klass) G_TYPE_CHECK_CLASS_CAST (klass, gtk_html_embedded_get_type (), GtkHTMLEmbeddedClass)
   8 </MACRO>
   9 <MACRO>
  10 <NAME>GTK_IS_HTML_EMBEDDED</NAME>
  11 #define GTK_IS_HTML_EMBEDDED(obj)      G_TYPE_CHECK_INSTANCE_TYPE (obj, gtk_html_embedded_get_type ())
  12 </MACRO>
  13 <STRUCT>
  14 <NAME>GtkHTMLEmbedded</NAME>
  15 struct GtkHTMLEmbedded {
  16         GtkBin bin;
  17
  18         /* class id of this object */
  19         char *classid;
  20         char *name;
  21         char *type;
  22         char *data;
  23
  24         /* parameters to class */
  25         int width, height;
  26         GHashTable *params;
  27
  28         GtkHTMLEmbeddedPrivate *priv;
  29
  30         int descent;
  31 };
  32 </STRUCT>
  33 <FUNCTION>
  34 <NAME>gtk_html_embedded_get_type</NAME>
  35 <RETURNS>guint  </RETURNS>
  36 void
  37 </FUNCTION>
  38 <FUNCTION>
  39 <NAME>gtk_html_embedded_new</NAME>
  40 <RETURNS>GtkWidget      *</RETURNS>
  41 char *classid, char *name, char *type, char *data, int width, int height
  42 </FUNCTION>
  43 <FUNCTION>
  44 <NAME>gtk_html_embedded_set_parameter</NAME>
  45 <RETURNS>void  </RETURNS>
  46 GtkHTMLEmbedded *ge, char *param, char *value
  47 </FUNCTION>
  48 <FUNCTION>
  49 <NAME>gtk_html_embedded_get_parameter</NAME>
  50 <RETURNS>char  *</RETURNS>
  51 GtkHTMLEmbedded *ge, char *param
  52 </FUNCTION>
  53 <FUNCTION>
  54 <NAME>gtk_html_embedded_set_descent</NAME>
  55 <RETURNS>void  </RETURNS>
  56 GtkHTMLEmbedded *ge, int descent
  57 </FUNCTION>
  58 <ENUM>
  59 <NAME>GtkHTMLCommandType</NAME>
  60 typedef enum {
  61         GTK_HTML_COMMAND_UNDO,
  62         GTK_HTML_COMMAND_REDO,
  63         GTK_HTML_COMMAND_COPY,
  64         GTK_HTML_COMMAND_CUT,
  65         GTK_HTML_COMMAND_PASTE,
  66
  67         GTK_HTML_COMMAND_CUT_LINE,
  68
  69         GTK_HTML_COMMAND_INSERT_PARAGRAPH,
  70         GTK_HTML_COMMAND_INSERT_RULE,
  71         GTK_HTML_COMMAND_INSERT_RULE_PARAM,
  72         GTK_HTML_COMMAND_INSERT_IMAGE_PARAM,
  73
  74         GTK_HTML_COMMAND_MAKE_LINK,
  75         GTK_HTML_COMMAND_REMOVE_LINK,
  76
  77         GTK_HTML_COMMAND_DELETE,
  78         GTK_HTML_COMMAND_DELETE_BACK,
  79         GTK_HTML_COMMAND_DELETE_BACK_OR_INDENT_DEC,
  80
  81         GTK_HTML_COMMAND_SET_MARK,
  82         GTK_HTML_COMMAND_DISABLE_SELECTION,
  83
  84         GTK_HTML_COMMAND_BOLD_ON,
  85         GTK_HTML_COMMAND_BOLD_OFF,
  86         GTK_HTML_COMMAND_BOLD_TOGGLE,
  87
  88         GTK_HTML_COMMAND_ITALIC_ON,
  89         GTK_HTML_COMMAND_ITALIC_OFF,
  90         GTK_HTML_COMMAND_ITALIC_TOGGLE,
  91
  92         GTK_HTML_COMMAND_UNDERLINE_ON,
  93         GTK_HTML_COMMAND_UNDERLINE_OFF,
  94         GTK_HTML_COMMAND_UNDERLINE_TOGGLE,
  95
  96         GTK_HTML_COMMAND_STRIKEOUT_ON,
  97         GTK_HTML_COMMAND_STRIKEOUT_OFF,
  98         GTK_HTML_COMMAND_STRIKEOUT_TOGGLE,
  99
 100         GTK_HTML_COMMAND_SIZE_MINUS_2,
 101         GTK_HTML_COMMAND_SIZE_MINUS_1,
 102         GTK_HTML_COMMAND_SIZE_PLUS_0,
 103         GTK_HTML_COMMAND_SIZE_PLUS_1,
 104         GTK_HTML_COMMAND_SIZE_PLUS_2,
 105         GTK_HTML_COMMAND_SIZE_PLUS_3,
 106         GTK_HTML_COMMAND_SIZE_PLUS_4,
 107
 108         GTK_HTML_COMMAND_SIZE_INCREASE,
 109         GTK_HTML_COMMAND_SIZE_DECREASE,
 110
 111         GTK_HTML_COMMAND_ALIGN_LEFT,
 112         GTK_HTML_COMMAND_ALIGN_CENTER,
 113         GTK_HTML_COMMAND_ALIGN_RIGHT,
 114
 115         GTK_HTML_COMMAND_INDENT_ZERO,
 116         GTK_HTML_COMMAND_INDENT_INC,
 117         GTK_HTML_COMMAND_INDENT_DEC,
 118         GTK_HTML_COMMAND_INDENT_PARAGRAPH,
 119
 120         GTK_HTML_COMMAND_PARAGRAPH_STYLE_NORMAL,
 121         GTK_HTML_COMMAND_PARAGRAPH_STYLE_H1,
 122         GTK_HTML_COMMAND_PARAGRAPH_STYLE_H2,
 123         GTK_HTML_COMMAND_PARAGRAPH_STYLE_H3,
 124         GTK_HTML_COMMAND_PARAGRAPH_STYLE_H4,
 125         GTK_HTML_COMMAND_PARAGRAPH_STYLE_H5,
 126         GTK_HTML_COMMAND_PARAGRAPH_STYLE_H6,
 127         GTK_HTML_COMMAND_PARAGRAPH_STYLE_ADDRESS,
 128         GTK_HTML_COMMAND_PARAGRAPH_STYLE_PRE,
 129         GTK_HTML_COMMAND_PARAGRAPH_STYLE_ITEMDOTTED,
 130         GTK_HTML_COMMAND_PARAGRAPH_STYLE_ITEMROMAN,
 131         GTK_HTML_COMMAND_PARAGRAPH_STYLE_ITEMDIGIT,
 132
 133         GTK_HTML_COMMAND_MODIFY_SELECTION_UP,
 134         GTK_HTML_COMMAND_MODIFY_SELECTION_DOWN,
 135         GTK_HTML_COMMAND_MODIFY_SELECTION_LEFT,
 136         GTK_HTML_COMMAND_MODIFY_SELECTION_RIGHT,
 137         GTK_HTML_COMMAND_MODIFY_SELECTION_PAGEUP,
 138         GTK_HTML_COMMAND_MODIFY_SELECTION_PAGEDOWN,
 139         GTK_HTML_COMMAND_MODIFY_SELECTION_BOL,
 140         GTK_HTML_COMMAND_MODIFY_SELECTION_EOL,
 141         GTK_HTML_COMMAND_MODIFY_SELECTION_BOD,
 142         GTK_HTML_COMMAND_MODIFY_SELECTION_EOD,
 143
 144         GTK_HTML_COMMAND_CAPITALIZE_WORD,
 145         GTK_HTML_COMMAND_UPCASE_WORD,
 146         GTK_HTML_COMMAND_DOWNCASE_WORD,
 147
 148         GTK_HTML_COMMAND_SPELL_SUGGEST,
 149         GTK_HTML_COMMAND_SPELL_PERSONAL_DICTIONARY_ADD,
 150         GTK_HTML_COMMAND_SPELL_SESSION_DICTIONARY_ADD,
 151
 152         GTK_HTML_COMMAND_SEARCH,
 153         GTK_HTML_COMMAND_SEARCH_INCREMENTAL_FORWARD,
 154         GTK_HTML_COMMAND_SEARCH_INCREMENTAL_BACKWARD,
 155         GTK_HTML_COMMAND_SEARCH_REGEX,
 156
 157         GTK_HTML_COMMAND_FOCUS_FORWARD,
 158         GTK_HTML_COMMAND_FOCUS_BACKWARD,
 159
 160         GTK_HTML_COMMAND_POPUP_MENU,
 161         GTK_HTML_COMMAND_PROPERTIES_DIALOG,
 162
 163         GTK_HTML_COMMAND_CURSOR_FORWARD,
 164         GTK_HTML_COMMAND_CURSOR_BACKWARD
 165 } GtkHTMLCommandType;
 166 </ENUM>
 167 <ENUM>
 168 <NAME>GtkHTMLCursorSkipType</NAME>
 169 typedef enum {
 170         GTK_HTML_CURSOR_SKIP_ONE,
 171         GTK_HTML_CURSOR_SKIP_WORD,
 172         GTK_HTML_CURSOR_SKIP_PAGE,
 173         GTK_HTML_CURSOR_SKIP_ALL
 174 } GtkHTMLCursorSkipType;
 175 </ENUM>
 176 <ENUM>
 177 <NAME>GtkHTMLEditorEventType</NAME>
 178 typedef enum {
 179         GTK_HTML_EDITOR_EVENT_COMMAND,
 180         GTK_HTML_EDITOR_EVENT_IMAGE_URL
 181 } GtkHTMLEditorEventType;
 182 </ENUM>
 183 <ENUM>
 184 <NAME>GtkHTMLEtchStyle</NAME>
 185 typedef enum {
 186         GTK_HTML_ETCH_IN,
 187         GTK_HTML_ETCH_OUT,
 188         GTK_HTML_ETCH_NONE
 189 } GtkHTMLEtchStyle;
 190 </ENUM>
 191 <ENUM>
 192 <NAME>GtkHTMLFontStyle</NAME>
 193 typedef enum {
 194         GTK_HTML_FONT_STYLE_DEFAULT = 0,
 195         GTK_HTML_FONT_STYLE_SIZE_1 = 1,
 196         GTK_HTML_FONT_STYLE_SIZE_2 = 2,
 197         GTK_HTML_FONT_STYLE_SIZE_3 = 3,
 198         GTK_HTML_FONT_STYLE_SIZE_4 = 4,
 199         GTK_HTML_FONT_STYLE_SIZE_5 = 5,
 200         GTK_HTML_FONT_STYLE_SIZE_6 = 6,
 201         GTK_HTML_FONT_STYLE_SIZE_7 = 7,
 202         GTK_HTML_FONT_STYLE_SIZE_MASK = 0x7,
 203         GTK_HTML_FONT_STYLE_BOLD        = 1 << 3,
 204         GTK_HTML_FONT_STYLE_ITALIC      = 1 << 4,
 205         GTK_HTML_FONT_STYLE_UNDERLINE   = 1 << 5,
 206         GTK_HTML_FONT_STYLE_STRIKEOUT   = 1 << 6,
 207         GTK_HTML_FONT_STYLE_FIXED       = 1 << 7,
 208         GTK_HTML_FONT_STYLE_SUBSCRIPT   = 1 << 8,
 209         GTK_HTML_FONT_STYLE_SUPERSCRIPT = 1 << 9
 210 } GtkHTMLFontStyle;
 211 </ENUM>
 212 <ENUM>
 213 <NAME>GtkHTMLParagraphAlignment</NAME>
 214 typedef enum {
 215         GTK_HTML_PARAGRAPH_ALIGNMENT_LEFT,
 216         GTK_HTML_PARAGRAPH_ALIGNMENT_RIGHT,
 217         GTK_HTML_PARAGRAPH_ALIGNMENT_CENTER
 218 } GtkHTMLParagraphAlignment;
 219 </ENUM>
 220 <ENUM>
 221 <NAME>GtkHTMLParagraphStyle</NAME>
 222 typedef enum {
 223         GTK_HTML_PARAGRAPH_STYLE_NORMAL,
 224         GTK_HTML_PARAGRAPH_STYLE_H1,
 225         GTK_HTML_PARAGRAPH_STYLE_H2,
 226         GTK_HTML_PARAGRAPH_STYLE_H3,
 227         GTK_HTML_PARAGRAPH_STYLE_H4,
 228         GTK_HTML_PARAGRAPH_STYLE_H5,
 229         GTK_HTML_PARAGRAPH_STYLE_H6,
 230         GTK_HTML_PARAGRAPH_STYLE_ADDRESS,
 231         GTK_HTML_PARAGRAPH_STYLE_PRE,
 232         GTK_HTML_PARAGRAPH_STYLE_ITEMDOTTED,
 233         GTK_HTML_PARAGRAPH_STYLE_ITEMROMAN,
 234         GTK_HTML_PARAGRAPH_STYLE_ITEMDIGIT
 235 } GtkHTMLParagraphStyle;
 236 </ENUM>
 237 <ENUM>
 238 <NAME>GtkHTMLStreamStatus</NAME>
 239 typedef enum {
 240         GTK_HTML_STREAM_OK,
 241         GTK_HTML_STREAM_ERROR
 242 } GtkHTMLStreamStatus;
 243 </ENUM>
 244 <FUNCTION>
 245 <NAME>gtk_html_im_focus_in</NAME>
 246 <RETURNS>void  </RETURNS>
 247 GtkHTML *html
 248 </FUNCTION>
 249 <FUNCTION>
 250 <NAME>gtk_html_im_focus_out</NAME>
 251 <RETURNS>void  </RETURNS>
 252 GtkHTML *html
 253 </FUNCTION>
 254 <FUNCTION>
 255 <NAME>gtk_html_im_realize</NAME>
 256 <RETURNS>void  </RETURNS>
 257 GtkHTML *html
 258 </FUNCTION>
 259 <FUNCTION>
 260 <NAME>gtk_html_im_unrealize</NAME>
 261 <RETURNS>void  </RETURNS>
 262 GtkHTML *html
 263 </FUNCTION>
 264 <FUNCTION>
 265 <NAME>gtk_html_im_size_allocate</NAME>
 266 <RETURNS>void  </RETURNS>
 267 GtkHTML *html
 268 </FUNCTION>
 269 <FUNCTION>
 270 <NAME>gtk_html_im_style_set</NAME>
 271 <RETURNS>void  </RETURNS>
 272 GtkHTML *html
 273 </FUNCTION>
 274 <FUNCTION>
 275 <NAME>gtk_html_handle_key_event</NAME>
 276 <RETURNS>gint  </RETURNS>
 277 GtkHTML     *html,GdkEventKey *event,gboolean    *update_styles
 278 </FUNCTION>
 279 <STRUCT>
 280 <NAME>GtkHTMLPrivate</NAME>
 281 struct GtkHTMLPrivate {
 282         guint idle_handler_id;
 283         guint scroll_timeout_id;
 284
 285         GtkHTMLParagraphStyle paragraph_style;
 286         guint paragraph_indentation;
 287         GtkHTMLParagraphAlignment paragraph_alignment;
 288         GtkHTMLFontStyle insertion_font_style;
 289
 290         gint last_selection_type;
 291         gchar *content_type;
 292
 293 #ifdef GTKHTML_HAVE_GCONF
 294         guint set_font_id;
 295 #endif
 296 #ifdef GTK_HTML_USE_XIM
 297         GdkICAttr *ic_attr;
 298         GdkIC *ic;
 299 #endif
 300 };
 301 </STRUCT>
 302 <FUNCTION>
 303 <NAME>gtk_html_private_calc_scrollbars</NAME>
 304 <RETURNS>void  </RETURNS>
 305 GtkHTML            *html
 306 </FUNCTION>
 307 <FUNCTION>
 308 <NAME>gtk_html_editor_event_command</NAME>
 309 <RETURNS>void  </RETURNS>
 310 GtkHTML            *html,GtkHTMLCommandType  com_type
 311 </FUNCTION>
 312 <FUNCTION>
 313 <NAME>gtk_html_isearch</NAME>
 314 <RETURNS>void  </RETURNS>
 315 GtkHTML *html, gboolean forward
 316 </FUNCTION>
 317 <STRUCT>
 318 <NAME>GtkHTMLStream</NAME>
 319 struct GtkHTMLStream {
 320         GtkHTMLStreamWriteFunc write_func;
 321         GtkHTMLStreamCloseFunc close_func;
 322         gpointer user_data;
 323 };
 324 </STRUCT>
 325 <FUNCTION>
 326 <NAME>gtk_html_stream_new</NAME>
 327 <RETURNS>GtkHTMLStream  *</RETURNS>
 328 GtkHTML                *html,GtkHTMLStreamWriteFunc  write_func,GtkHTMLStreamCloseFunc  close_func,gpointer                user_data
 329 </FUNCTION>
 330 <FUNCTION>
 331 <NAME>gtk_html_stream_write</NAME>
 332 <RETURNS>void  </RETURNS>
 333 GtkHTMLStream          *stream,const gchar            *buffer,size_t                  size
 334 </FUNCTION>
 335 <FUNCTION>
 336 <NAME>gtk_html_stream_destroy</NAME>
 337 <RETURNS>void  </RETURNS>
 338 GtkHTMLStream          *stream
 339 </FUNCTION>
 340 <FUNCTION>
 341 <NAME>gtk_html_stream_close</NAME>
 342 <RETURNS>void  </RETURNS>
 343 GtkHTMLStream          *stream,GtkHTMLStreamStatus     status
 344 </FUNCTION>
 345 <FUNCTION>
 346 <NAME>gtk_html_stream_ref</NAME>
 347 <RETURNS>GtkHTMLStream  *</RETURNS>
 348 GtkHTMLStream          *handle
 349 </FUNCTION>
 350 <FUNCTION>
 351 <NAME>gtk_html_stream_unref</NAME>
 352 <RETURNS>void  </RETURNS>
 353 GtkHTMLStream          *handle
 354 </FUNCTION>
 355 <STRUCT>
 356 <NAME>GtkHTML</NAME>
 357 </STRUCT>
 358 <STRUCT>
 359 <NAME>GtkHTMLClass</NAME>
 360 </STRUCT>
 361 <STRUCT>
 362 <NAME>GtkHTMLClassProperties</NAME>
 363 </STRUCT>
 364 <STRUCT>
 365 <NAME>GtkHTMLEditorAPI</NAME>
 366 </STRUCT>
 367 <STRUCT>
 368 <NAME>GtkHTMLEmbedded</NAME>
 369 </STRUCT>
 370 <STRUCT>
 371 <NAME>GtkHTMLEmbeddedClass</NAME>
 372 </STRUCT>
 373 <STRUCT>
 374 <NAME>GtkHTMLEmbeddedPrivate</NAME>
 375 </STRUCT>
 376 <STRUCT>
 377 <NAME>GtkHTMLPrivate</NAME>
 378 </STRUCT>
 379 <STRUCT>
 380 <NAME>GtkHTMLStream</NAME>
 381 </STRUCT>
 382 <USER_FUNCTION>
 383 <NAME>GtkHTMLStreamCloseFunc</NAME>
 384 <RETURNS>void </RETURNS>
 385 GtkHTMLStream *stream,
 386                                          GtkHTMLStreamStatus status,
 387                                          gpointer user_data
 388 </USER_FUNCTION>
 389 <USER_FUNCTION>
 390 <NAME>GtkHTMLStreamWriteFunc</NAME>
 391 <RETURNS>void </RETURNS>
 392 GtkHTMLStream *stream,
 393                                          const gchar *buffer,
 394                                          guint size,
 395                                          gpointer user_data
 396 </USER_FUNCTION>
 397 <USER_FUNCTION>
 398 <NAME>GtkHTMLSaveReceiverFn</NAME>
 399 <RETURNS>gboolean </RETURNS>
 400 gpointer     engine,
 401                                               const gchar *data,
 402                                               guint        len,
 403                                               gpointer     user_data
 404 </USER_FUNCTION>
 405 <USER_FUNCTION>
 406 <NAME>GtkHTMLPrintCallback</NAME>
 407 <RETURNS>void </RETURNS>
 408 GtkHTML *html, GnomePrintContext *print_context,
 409                                       gdouble x, gdouble y, gdouble width, gdouble height, gpointer user_data
 410 </USER_FUNCTION>
 411 <MACRO>
 412 <NAME>GTK_TYPE_HTML</NAME>
 413 #define GTK_TYPE_HTML                  (gtk_html_get_type ())
 414 </MACRO>
 415 <MACRO>
 416 <NAME>GTK_HTML</NAME>
 417 #define GTK_HTML(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_HTML, GtkHTML))
 418 </MACRO>
 419 <MACRO>
 420 <NAME>GTK_HTML_CLASS</NAME>
 421 #define GTK_HTML_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_HTML, GtkHTMLClass))
 422 </MACRO>
 423 <MACRO>
 424 <NAME>GTK_IS_HTML</NAME>
 425 #define GTK_IS_HTML(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_HTML))
 426 </MACRO>
 427 <MACRO>
 428 <NAME>GTK_IS_HTML_CLASS</NAME>
 429 #define GTK_IS_HTML_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_HTML))
 430 </MACRO>
 431 <STRUCT>
 432 <NAME>GtkHTML</NAME>
 433 struct GtkHTML {
 434         GtkLayout layout;
 435
 436         GtkBindingSet        *editor_bindings;
 437         GtkWidget            *iframe_parent;
 438         GtkHTMLEditorAPI     *editor_api;
 439         gpointer              editor_data;
 440         HTMLEngine           *engine;
 441
 442         /* The URL of the link over which the pointer currently is.  NULL if
 443            the pointer is not over a link.  */
 444         gchar *pointer_url;
 445
 446         /* The cursors we use within the widget.  */
 447         GdkCursor *hand_cursor;
 448         GdkCursor *arrow_cursor;
 449         GdkCursor *ibeam_cursor;
 450
 451         gint selection_x1, selection_y1;
 452
 453         guint in_selection : 1;
 454         guint button1_pressed : 1;
 455         guint load_in_progress : 1;
 456
 457         guint debug : 1;
 458         guint allow_selection : 1;
 459
 460         guint hadj_connection;
 461         guint vadj_connection;
 462
 463         gboolean binding_handled;
 464         GtkHTMLPrivate *priv;
 465 };
 466 </STRUCT>
 467 <STRUCT>
 468 <NAME>GtkHTMLEditorAPI</NAME>
 469 struct GtkHTMLEditorAPI
 470 {
 471         /* spell checking methods */
 472         gboolean  (* check_word)              (GtkHTML *html, const gchar *word, gpointer data);
 473         void      (* suggestion_request)      (GtkHTML *html, const gchar *word, gpointer data);
 474         void      (* add_to_session)          (GtkHTML *html, const gchar *word, gpointer data);
 475         void      (* add_to_personal)         (GtkHTML *html, const gchar *word, gpointer data);
 476
 477         /* unhandled commands */
 478         gboolean  (* command)                 (GtkHTML *html, GtkHTMLCommandType com_type, gpointer data);
 479
 480         GtkArg  * (* event)                   (GtkHTML *html, GtkHTMLEditorEventType event_type, GtkArg **args, gpointer data);
 481
 482         /* input line */
 483         GtkEntry * (* create_input_line)      (GtkHTML *html, gpointer data);
 484 };
 485 </STRUCT>
 486 <FUNCTION>
 487 <NAME>gtk_html_get_type</NAME>
 488 <RETURNS>GtkType  </RETURNS>
 489 void
 490 </FUNCTION>
 491 <FUNCTION>
 492 <NAME>gtk_html_construct</NAME>
 493 <RETURNS>void  </RETURNS>
 494 GtkWidget        *html
 495 </FUNCTION>
 496 <FUNCTION>
 497 <NAME>gtk_html_new</NAME>
 498 <RETURNS>GtkWidget  *</RETURNS>
 499 void
 500 </FUNCTION>
 501 <FUNCTION>
 502 <NAME>gtk_html_new_from_string</NAME>
 503 <RETURNS>GtkWidget  *</RETURNS>
 504 const gchar      *str,gint              len
 505 </FUNCTION>
 506 <FUNCTION>
 507 <NAME>gtk_html_set_editor_api</NAME>
 508 <RETURNS>void  </RETURNS>
 509 GtkHTML          *html,GtkHTMLEditorAPI *api,gpointer          data
 510 </FUNCTION>
 511 <FUNCTION>
 512 <NAME>gtk_html_set_iframe_parent</NAME>
 513 <RETURNS>void  </RETURNS>
 514 GtkHTML *html,GtkWidget *parent
 515 </FUNCTION>
 516 <FUNCTION>
 517 <NAME>gtk_html_enable_debug</NAME>
 518 <RETURNS>void  </RETURNS>
 519 GtkHTML  *html,gboolean  debug
 520 </FUNCTION>
 521 <FUNCTION>
 522 <NAME>gtk_html_allow_selection</NAME>
 523 <RETURNS>void  </RETURNS>
 524 GtkHTML  *html,gboolean  allow
 525 </FUNCTION>
 526 <FUNCTION>
 527 <NAME>gtk_html_select_word</NAME>
 528 <RETURNS>void  </RETURNS>
 529 GtkHTML  *html
 530 </FUNCTION>
 531 <FUNCTION>
 532 <NAME>gtk_html_select_line</NAME>
 533 <RETURNS>void  </RETURNS>
 534 GtkHTML  *html
 535 </FUNCTION>
 536 <FUNCTION>
 537 <NAME>gtk_html_request_paste</NAME>
 538 <RETURNS>int  </RETURNS>
 539 GtkHTML  *html,gint      type,gint32    time
 540 </FUNCTION>
 541 <FUNCTION>
 542 <NAME>gtk_html_begin</NAME>
 543 <RETURNS>GtkHTMLStream  *</RETURNS>
 544 GtkHTML             *html
 545 </FUNCTION>
 546 <FUNCTION>
 547 <NAME>gtk_html_begin_content</NAME>
 548 <RETURNS>GtkHTMLStream  *</RETURNS>
 549 GtkHTML             *html,gchar               *content_type
 550 </FUNCTION>
 551 <FUNCTION>
 552 <NAME>gtk_html_write</NAME>
 553 <RETURNS>void  </RETURNS>
 554 GtkHTML             *html,GtkHTMLStream       *handle,const gchar         *buffer,size_t               size
 555 </FUNCTION>
 556 <FUNCTION>
 557 <NAME>gtk_html_end</NAME>
 558 <RETURNS>void  </RETURNS>
 559 GtkHTML             *html,GtkHTMLStream       *handle,GtkHTMLStreamStatus  status
 560 </FUNCTION>
 561 <FUNCTION>
 562 <NAME>gtk_html_load_empty</NAME>
 563 <RETURNS>void  </RETURNS>
 564 GtkHTML             *html
 565 </FUNCTION>
 566 <FUNCTION>
 567 <NAME>gtk_html_load_from_string</NAME>
 568 <RETURNS>void  </RETURNS>
 569 GtkHTML             *html,const gchar         *str,gint                 len
 570 </FUNCTION>
 571 <FUNCTION>
 572 <NAME>gtk_html_save</NAME>
 573 <RETURNS>gboolean  </RETURNS>
 574 GtkHTML               *html,GtkHTMLSaveReceiverFn  receiver,gpointer               data
 575 </FUNCTION>
 576 <FUNCTION>
 577 <NAME>gtk_html_export</NAME>
 578 <RETURNS>gboolean  </RETURNS>
 579 GtkHTML               *html,const char            *type,GtkHTMLSaveReceiverFn  receiver,gpointer               data
 580 </FUNCTION>
 581 <FUNCTION>
 582 <NAME>gtk_html_set_editable</NAME>
 583 <RETURNS>void  </RETURNS>
 584 GtkHTML       *html,gboolean       editable
 585 </FUNCTION>
 586 <FUNCTION>
 587 <NAME>gtk_html_get_editable</NAME>
 588 <RETURNS>gboolean  </RETURNS>
 589 const GtkHTML *html
 590 </FUNCTION>
 591 <FUNCTION>
 592 <NAME>gtk_html_print_with_header_footer</NAME>
 593 <RETURNS>void  </RETURNS>
 594 GtkHTML              *html,GnomePrintContext    *print_context,gdouble               header_height,gdouble               footer_height,GtkHTMLPrintCallback  header_print,GtkHTMLPrintCallback  footer_print,gpointer              user_data
 595 </FUNCTION>
 596 <FUNCTION>
 597 <NAME>gtk_html_print</NAME>
 598 <RETURNS>void  </RETURNS>
 599 GtkHTML              *html,GnomePrintContext    *print_context
 600 </FUNCTION>
 601 <FUNCTION>
 602 <NAME>gtk_html_get_title</NAME>
 603 <RETURNS>const gchar  *</RETURNS>
 604 GtkHTML *html
 605 </FUNCTION>
 606 <FUNCTION>
 607 <NAME>gtk_html_jump_to_anchor</NAME>
 608 <RETURNS>gboolean  </RETURNS>
 609 GtkHTML *html,const gchar *anchor
 610 </FUNCTION>
 611 <FUNCTION>
 612 <NAME>gtk_html_get_paragraph_style</NAME>
 613 <RETURNS>GtkHTMLParagraphStyle  </RETURNS>
 614 GtkHTML                   *html
 615 </FUNCTION>
 616 <FUNCTION>
 617 <NAME>gtk_html_set_paragraph_style</NAME>
 618 <RETURNS>void  </RETURNS>
 619 GtkHTML                   *html,GtkHTMLParagraphStyle      style
 620 </FUNCTION>
 621 <FUNCTION>
 622 <NAME>gtk_html_set_indent</NAME>
 623 <RETURNS>void  </RETURNS>
 624 GtkHTML                   *html,gint                       level
 625 </FUNCTION>
 626 <FUNCTION>
 627 <NAME>gtk_html_modify_indent_by_delta</NAME>
 628 <RETURNS>void  </RETURNS>
 629 GtkHTML                   *html,gint                       delta
 630 </FUNCTION>
 631 <FUNCTION>
 632 <NAME>gtk_html_set_font_style</NAME>
 633 <RETURNS>void  </RETURNS>
 634 GtkHTML                   *html,GtkHTMLFontStyle           and_mask,GtkHTMLFontStyle           or_mask
 635 </FUNCTION>
 636 <FUNCTION>
 637 <NAME>gtk_html_set_color</NAME>
 638 <RETURNS>void  </RETURNS>
 639 GtkHTML                   *html,HTMLColor                 *color
 640 </FUNCTION>
 641 <FUNCTION>
 642 <NAME>gtk_html_toggle_font_style</NAME>
 643 <RETURNS>void  </RETURNS>
 644 GtkHTML                   *html,GtkHTMLFontStyle           style
 645 </FUNCTION>
 646 <FUNCTION>
 647 <NAME>gtk_html_get_paragraph_alignment</NAME>
 648 <RETURNS>GtkHTMLParagraphAlignment  </RETURNS>
 649 GtkHTML                   *html
 650 </FUNCTION>
 651 <FUNCTION>
 652 <NAME>gtk_html_set_paragraph_alignment</NAME>
 653 <RETURNS>void  </RETURNS>
 654 GtkHTML                   *html,GtkHTMLParagraphAlignment  alignment
 655 </FUNCTION>
 656 <FUNCTION>
 657 <NAME>gtk_html_cut</NAME>
 658 <RETURNS>void  </RETURNS>
 659 GtkHTML *html
 660 </FUNCTION>
 661 <FUNCTION>
 662 <NAME>gtk_html_copy</NAME>
 663 <RETURNS>void  </RETURNS>
 664 GtkHTML *html
 665 </FUNCTION>
 666 <FUNCTION>
 667 <NAME>gtk_html_paste</NAME>
 668 <RETURNS>void  </RETURNS>
 669 GtkHTML *html
 670 </FUNCTION>
 671 <FUNCTION>
 672 <NAME>gtk_html_undo</NAME>
 673 <RETURNS>void  </RETURNS>
 674 GtkHTML *html
 675 </FUNCTION>
 676 <FUNCTION>
 677 <NAME>gtk_html_redo</NAME>
 678 <RETURNS>void  </RETURNS>
 679 GtkHTML *html
 680 </FUNCTION>
 681 <FUNCTION>
 682 <NAME>gtk_html_set_default_background_color</NAME>
 683 <RETURNS>void  </RETURNS>
 684 GtkHTML     *html,GdkColor    *c
 685 </FUNCTION>
 686 <FUNCTION>
 687 <NAME>gtk_html_set_default_content_type</NAME>
 688 <RETURNS>void  </RETURNS>
 689 GtkHTML     *html,gchar       *content_type
 690 </FUNCTION>
 691 <FUNCTION>
 692 <NAME>gtk_html_get_object_by_id</NAME>
 693 <RETURNS>gpointer  </RETURNS>
 694 GtkHTML     *html,const gchar *id
 695 </FUNCTION>
 696 <FUNCTION>
 697 <NAME>gtk_html_editor_command</NAME>
 698 <RETURNS>void  </RETURNS>
 699 GtkHTML     *html,const gchar *command_name
 700 </FUNCTION>
 701 <FUNCTION>
 702 <NAME>gtk_html_edit_make_cursor_visible</NAME>
 703 <RETURNS>gboolean  </RETURNS>
 704 GtkHTML     *html
 705 </FUNCTION>
 706 <FUNCTION>
 707 <NAME>gtk_html_debug_log</NAME>
 708 <RETURNS>void  </RETURNS>
 709 GtkHTML     *html,const gchar *format,...
 710 </FUNCTION>
 711 <FUNCTION>
 712 <NAME>gtk_html_debug_dump_tree</NAME>
 713 <RETURNS>void  </RETURNS>
 714 HTMLObject  *o,gint         level
 715 </FUNCTION>
 716 <FUNCTION>
 717 <NAME>gtk_html_debug_dump_object_type</NAME>
 718 <RETURNS>void  </RETURNS>
 719 HTMLObject  *o
 720 </FUNCTION>
 721 <FUNCTION>
 722 <NAME>gtk_html_debug_dump_table</NAME>
 723 <RETURNS>void  </RETURNS>
 724 HTMLObject  *o,gint         level
 725 </FUNCTION>
 726 <FUNCTION>
 727 <NAME>gtk_html_debug_dump_tree_simple</NAME>
 728 <RETURNS>void  </RETURNS>
 729 HTMLObject  *o,gint         level
 730 </FUNCTION>
 731 <FUNCTION>
 732 <NAME>gtk_html_debug_dump_list_simple</NAME>
 733 <RETURNS>void  </RETURNS>
 734 GList       *list,gint         level
 735 </FUNCTION>
 736 <FUNCTION>
 737 <NAME>gtk_html_debug_dump_object</NAME>
 738 <RETURNS>void  </RETURNS>
 739 HTMLObject  *o,gint         level
 740 </FUNCTION>
 741 <MACRO>
 742 <NAME>GTK_HTML_FONT_STYLE_SIZE_MAX</NAME>
 743 #define GTK_HTML_FONT_STYLE_SIZE_MAX 7
 744 </MACRO>
 745 <MACRO>
 746 <NAME>GTK_HTML_FONT_STYLE_MAX</NAME>
 747 #define GTK_HTML_FONT_STYLE_MAX                                                                 \
 748         (GTK_HTML_FONT_STYLE_SIZE_MASK | GTK_HTML_FONT_STYLE_BOLD | GTK_HTML_FONT_STYLE_ITALIC  \
 749          | GTK_HTML_FONT_STYLE_UNDERLINE | GTK_HTML_FONT_STYLE_STRIKEOUT | GTK_HTML_FONT_STYLE_FIXED \
 750          | GTK_HTML_FONT_STYLE_SUBSCRIPT | GTK_HTML_FONT_STYLE_SUPERSCRIPT)
 751 </MACRO>
 752 <MACRO>
 753 <NAME>GTK_HTML_FONT_STYLE_MAX_FONT</NAME>
 754 #define GTK_HTML_FONT_STYLE_MAX_FONT      ((GTK_HTML_FONT_STYLE_ITALIC) << 1)
 755 </MACRO>
 756 <MACRO>
 757 <NAME>GTK_HTML_FONT_STYLE_MAX_FONT_MASK</NAME>
 758 #define GTK_HTML_FONT_STYLE_MAX_FONT_MASK (GTK_HTML_FONT_STYLE_MAX_FONT - 1)
 759 </MACRO>
 760 <FUNCTION>
 761 <NAME>gtk_html_font_style_merge</NAME>
 762 <RETURNS>GtkHTMLFontStyle  </RETURNS>
 763 GtkHTMLFontStyle a, GtkHTMLFontStyle b
 764 </FUNCTION>
 765 <MACRO>
 766 <NAME>HTML_ANCHOR</NAME>
 767 #define HTML_ANCHOR(x) ((HTMLAnchor *) x)
 768 </MACRO>
 769 <MACRO>
 770 <NAME>HTML_ANCHOR_CLASS</NAME>
 771 #define HTML_ANCHOR_CLASS(x) ((HTMLAnchorClass *) x)
 772 </MACRO>
 773 <STRUCT>
 774 <NAME>HTMLAnchor</NAME>
 775 struct HTMLAnchor {
 776         HTMLObject object;
 777
 778         GString *name;
 779 };
 780 </STRUCT>
 781 <FUNCTION>
 782 <NAME>html_anchor_type_init</NAME>
 783 <RETURNS>void  </RETURNS>
 784 void
 785 </FUNCTION>
 786 <FUNCTION>
 787 <NAME>html_anchor_class_init</NAME>
 788 <RETURNS>void  </RETURNS>
 789 HTMLAnchorClass *klass,HTMLType         type,guint            object_size
 790 </FUNCTION>
 791 <FUNCTION>
 792 <NAME>html_anchor_new</NAME>
 793 <RETURNS>HTMLObject   *</RETURNS>
 794 const gchar     *name
 795 </FUNCTION>
 796 <FUNCTION>
 797 <NAME>html_anchor_init</NAME>
 798 <RETURNS>void  </RETURNS>
 799 HTMLAnchor      *anchor,HTMLAnchorClass *klass,const gchar     *name
 800 </FUNCTION>
 801 <FUNCTION>
 802 <NAME>html_anchor_get_name</NAME>
 803 <RETURNS>const gchar  *</RETURNS>
 804 HTMLAnchor      *anchor
 805 </FUNCTION>
 806 <MACRO>
 807 <NAME>HTML_BUTTON</NAME>
 808 #define HTML_BUTTON(x) ((HTMLButton *) (x))
 809 </MACRO>
 810 <MACRO>
 811 <NAME>HTML_BUTTON_CLASS</NAME>
 812 #define HTML_BUTTON_CLASS(x) ((HTMLButtonClass *) (x))
 813 </MACRO>
 814 <STRUCT>
 815 <NAME>HTMLButton</NAME>
 816 struct HTMLButton {
 817         HTMLEmbedded element;
 818         HTMLButtonType type;
 819 };
 820 </STRUCT>
 821 <VARIABLE>
 822 <NAME>html_button_class</NAME>
 823 extern HTMLButtonClass html_button_class;
 824 </VARIABLE>
 825 <FUNCTION>
 826 <NAME>html_button_type_init</NAME>
 827 <RETURNS>void  </RETURNS>
 828 void
 829 </FUNCTION>
 830 <FUNCTION>
 831 <NAME>html_button_class_init</NAME>
 832 <RETURNS>void  </RETURNS>
 833 HTMLButtonClass *klass,HTMLType         type,guint            object_size
 834 </FUNCTION>
 835 <FUNCTION>
 836 <NAME>html_button_init</NAME>
 837 <RETURNS>void  </RETURNS>
 838 HTMLButton      *button,HTMLButtonClass *klass,GtkWidget       *parent,gchar           *name,gchar           *value,HTMLButtonType   type
 839 </FUNCTION>
 840 <FUNCTION>
 841 <NAME>html_button_new</NAME>
 842 <RETURNS>HTMLObject  *</RETURNS>
 843 GtkWidget       *parent,gchar           *name,gchar           *value,HTMLButtonType   type
 844 </FUNCTION>
 845 <MACRO>
 846 <NAME>HTML_CHECKBOX</NAME>
 847 #define HTML_CHECKBOX(x) ((HTMLCheckBox *) (x))
 848 </MACRO>
 849 <MACRO>
 850 <NAME>HTML_CHECKBOX_CLASS</NAME>
 851 #define HTML_CHECKBOX_CLASS(x) ((HTMLCheckBoxClass *) (x))
 852 </MACRO>
 853 <STRUCT>
 854 <NAME>HTMLCheckBox</NAME>
 855 struct HTMLCheckBox {
 856         HTMLEmbedded element;
 857         gint default_checked;
 858 };
 859 </STRUCT>
 860 <VARIABLE>
 861 <NAME>html_checkbox_class</NAME>
 862 extern HTMLCheckBoxClass html_checkbox_class;
 863 </VARIABLE>
 864 <FUNCTION>
 865 <NAME>html_checkbox_type_init</NAME>
 866 <RETURNS>void  </RETURNS>
 867 void
 868 </FUNCTION>
 869 <FUNCTION>
 870 <NAME>html_checkbox_class_init</NAME>
 871 <RETURNS>void  </RETURNS>
 872 HTMLCheckBoxClass *klass,HTMLType           type,guint              object_size
 873 </FUNCTION>
 874 <FUNCTION>
 875 <NAME>html_checkbox_init</NAME>
 876 <RETURNS>void  </RETURNS>
 877 HTMLCheckBox      *checkbox,HTMLCheckBoxClass *klass,GtkWidget         *parent,gchar             *name,gchar             *value,gboolean           checked
 878 </FUNCTION>
 879 <FUNCTION>
 880 <NAME>html_checkbox_new</NAME>
 881 <RETURNS>HTMLObject  *</RETURNS>
 882 GtkWidget         *parent,gchar             *name,gchar             *value,gboolean           checked
 883 </FUNCTION>
 884 <MACRO>
 885 <NAME>HTML_CLUE</NAME>
 886 #define HTML_CLUE(x) ((HTMLClue *)(x))
 887 </MACRO>
 888 <MACRO>
 889 <NAME>HTML_CLUE_CLASS</NAME>
 890 #define HTML_CLUE_CLASS(x) ((HTMLClueClass *)(x))
 891 </MACRO>
 892 <STRUCT>
 893 <NAME>HTMLClue</NAME>
 894 struct HTMLClue {
 895         HTMLObject object;
 896
 897         HTMLObject *head;
 898         HTMLObject *tail;
 899         HTMLObject *curr;
 900
 901         HTMLVAlignType valign;
 902         HTMLHAlignType halign;
 903 };
 904 </STRUCT>
 905 <VARIABLE>
 906 <NAME>html_clue_class</NAME>
 907 extern HTMLClueClass html_clue_class;
 908 </VARIABLE>
 909 <FUNCTION>
 910 <NAME>html_clue_type_init</NAME>
 911 <RETURNS>void  </RETURNS>
 912 void
 913 </FUNCTION>
 914 <FUNCTION>
 915 <NAME>html_clue_class_init</NAME>
 916 <RETURNS>void  </RETURNS>
 917 HTMLClueClass *klass,HTMLType       type,guint          object_size
 918 </FUNCTION>
 919 <FUNCTION>
 920 <NAME>html_clue_init</NAME>
 921 <RETURNS>void  </RETURNS>
 922 HTMLClue      *clue,HTMLClueClass *klass
 923 </FUNCTION>
 924 <FUNCTION>
 925 <NAME>html_clue_get_left_clear</NAME>
 926 <RETURNS>gint  </RETURNS>
 927 HTMLClue      *clue,gint           y
 928 </FUNCTION>
 929 <FUNCTION>
 930 <NAME>html_clue_get_right_clear</NAME>
 931 <RETURNS>gint  </RETURNS>
 932 HTMLClue      *clue,gint           y
 933 </FUNCTION>
 934 <FUNCTION>
 935 <NAME>html_clue_find_free_area</NAME>
 936 <RETURNS>void  </RETURNS>
 937 HTMLClue      *clue,gint           y,gint           width,gint           height,gint           indent,gint          *y_pos,gint          *lmargin,gint          *rmargin
 938 </FUNCTION>
 939 <FUNCTION>
 940 <NAME>html_clue_append_right_aligned</NAME>
 941 <RETURNS>void  </RETURNS>
 942 HTMLClue      *clue,HTMLClue      *aclue
 943 </FUNCTION>
 944 <FUNCTION>
 945 <NAME>html_clue_append_left_aligned</NAME>
 946 <RETURNS>void  </RETURNS>
 947 HTMLClue      *clue,HTMLClue      *aclue
 948 </FUNCTION>
 949 <FUNCTION>
 950 <NAME>html_clue_appended</NAME>
 951 <RETURNS>gboolean  </RETURNS>
 952 HTMLClue      *clue,HTMLClue      *aclue
 953 </FUNCTION>
 954 <FUNCTION>
 955 <NAME>html_clue_append_after</NAME>
 956 <RETURNS>void  </RETURNS>
 957 HTMLClue      *clue,HTMLObject    *o,HTMLObject    *where
 958 </FUNCTION>
 959 <FUNCTION>
 960 <NAME>html_clue_append</NAME>
 961 <RETURNS>void  </RETURNS>
 962 HTMLClue      *clue,HTMLObject    *o
 963 </FUNCTION>
 964 <FUNCTION>
 965 <NAME>html_clue_prepend</NAME>
 966 <RETURNS>void  </RETURNS>
 967 HTMLClue      *clue,HTMLObject    *o
 968 </FUNCTION>
 969 <FUNCTION>
 970 <NAME>html_clue_remove</NAME>
 971 <RETURNS>void  </RETURNS>
 972 HTMLClue      *clue,HTMLObject    *o
 973 </FUNCTION>
 974 <MACRO>
 975 <NAME>HTML_CLUEALIGNED</NAME>
 976 #define HTML_CLUEALIGNED(x)       ((HTMLClueAligned *)(x))
 977 </MACRO>
 978 <MACRO>
 979 <NAME>HTML_CLUEALIGNED_CLASS</NAME>
 980 #define HTML_CLUEALIGNED_CLASS(x) ((HTMLClueAlignedClass *)(x))
 981 </MACRO>
 982 <STRUCT>
 983 <NAME>HTMLClueAligned</NAME>
 984 struct HTMLClueAligned {
 985         HTMLClue clue;
 986
 987         HTMLClueAligned *next_aligned;
 988 };
 989 </STRUCT>
 990 <VARIABLE>
 991 <NAME>html_cluealigned_class</NAME>
 992 extern HTMLClueAlignedClass html_cluealigned_class;
 993 </VARIABLE>
 994 <FUNCTION>
 995 <NAME>html_cluealigned_type_init</NAME>
 996 <RETURNS>void  </RETURNS>
 997 void
 998 </FUNCTION>
 999 <FUNCTION>
1000 <NAME>html_cluealigned_class_init</NAME>
1001 <RETURNS>void  </RETURNS>
1002 HTMLClueAlignedClass *klass,HTMLType              type,guint                 object_size
1003 </FUNCTION>
1004 <FUNCTION>
1005 <NAME>html_cluealigned_init</NAME>
1006 <RETURNS>void  </RETURNS>
1007 HTMLClueAligned      *aligned,HTMLClueAlignedClass *klass,HTMLObject           *parent,gint                  x,gint                  y,gint                  max_width,gint                  percent
1008 </FUNCTION>
1009 <FUNCTION>
1010 <NAME>html_cluealigned_new</NAME>
1011 <RETURNS>HTMLObject  *</RETURNS>
1012 HTMLObject           *parent,gint                  x,gint                  y,gint                  max_width,gint                  percent
1013 </FUNCTION>
1014 <MACRO>
1015 <NAME>HTML_CLUEFLOW</NAME>
1016 #define HTML_CLUEFLOW(x) ((HTMLClueFlow *)(x))
1017 </MACRO>
1018 <MACRO>
1019 <NAME>HTML_CLUEFLOW_CLASS</NAME>
1020 #define HTML_CLUEFLOW_CLASS(x) ((HTMLClueFlowClass *)(x))
1021 </MACRO>
1022 <STRUCT>
1023 <NAME>HTMLClueFlow</NAME>
1024 struct HTMLClueFlow {
1025         HTMLClue clue;
1026
1027         /* Paragraph style.  */
1028         HTMLClueFlowStyle style;
1029
1030         /* Indentation level for blockquote and lists.  */
1031         guint8 level;
1032 };
1033 </STRUCT>
1034 <VARIABLE>
1035 <NAME>html_clueflow_class</NAME>
1036 extern HTMLClueFlowClass html_clueflow_class;
1037 </VARIABLE>
1038 <FUNCTION>
1039 <NAME>html_clueflow_type_init</NAME>
1040 <RETURNS>void  </RETURNS>
1041 void
1042 </FUNCTION>
1043 <FUNCTION>
1044 <NAME>html_clueflow_class_init</NAME>
1045 <RETURNS>void  </RETURNS>
1046 HTMLClueFlowClass  *klass,HTMLType            type,guint               object_size
1047 </FUNCTION>
1048 <FUNCTION>
1049 <NAME>html_clueflow_init</NAME>
1050 <RETURNS>void  </RETURNS>
1051 HTMLClueFlow       *flow,HTMLClueFlowClass  *klass,HTMLClueFlowStyle   style,guint8              indentation
1052 </FUNCTION>
1053 <FUNCTION>
1054 <NAME>html_clueflow_new</NAME>
1055 <RETURNS>HTMLObject         *</RETURNS>
1056 HTMLClueFlowStyle   style,guint8              indentation
1057 </FUNCTION>
1058 <FUNCTION>
1059 <NAME>html_clueflow_new_from_flow</NAME>
1060 <RETURNS>HTMLObject         *</RETURNS>
1061 HTMLClueFlow       *flow
1062 </FUNCTION>
1063 <FUNCTION>
1064 <NAME>html_clueflow_get_default_font_style</NAME>
1065 <RETURNS>GtkHTMLFontStyle  </RETURNS>
1066 const HTMLClueFlow *self
1067 </FUNCTION>
1068 <FUNCTION>
1069 <NAME>html_clueflow_split</NAME>
1070 <RETURNS>HTMLClueFlow       *</RETURNS>
1071 HTMLClueFlow       *clue,HTMLObject         *child
1072 </FUNCTION>
1073 <FUNCTION>
1074 <NAME>html_clueflow_set_style</NAME>
1075 <RETURNS>void  </RETURNS>
1076 HTMLClueFlow       *flow,HTMLEngine         *engine,HTMLClueFlowStyle   style
1077 </FUNCTION>
1078 <FUNCTION>
1079 <NAME>html_clueflow_get_style</NAME>
1080 <RETURNS>HTMLClueFlowStyle  </RETURNS>
1081 HTMLClueFlow       *flow
1082 </FUNCTION>
1083 <FUNCTION>
1084 <NAME>html_clueflow_set_halignment</NAME>
1085 <RETURNS>void  </RETURNS>
1086 HTMLClueFlow       *flow,HTMLEngine         *engine,HTMLHAlignType      alignment
1087 </FUNCTION>
1088 <FUNCTION>
1089 <NAME>html_clueflow_get_halignment</NAME>
1090 <RETURNS>HTMLHAlignType  </RETURNS>
1091 HTMLClueFlow       *flow
1092 </FUNCTION>
1093 <FUNCTION>
1094 <NAME>html_clueflow_modify_indentation_by_delta</NAME>
1095 <RETURNS>void  </RETURNS>
1096 HTMLClueFlow       *flow,HTMLEngine         *engine,gint                indentation
1097 </FUNCTION>
1098 <FUNCTION>
1099 <NAME>html_clueflow_set_indentation</NAME>
1100 <RETURNS>void  </RETURNS>
1101 HTMLClueFlow       *flow,HTMLEngine         *engine,guint8              indentation
1102 </FUNCTION>
1103 <FUNCTION>
1104 <NAME>html_clueflow_get_indentation</NAME>
1105 <RETURNS>guint8  </RETURNS>
1106 HTMLClueFlow       *flow
1107 </FUNCTION>
1108 <FUNCTION>
1109 <NAME>html_clueflow_set_properties</NAME>
1110 <RETURNS>void  </RETURNS>
1111 HTMLClueFlow       *flow,HTMLEngine         *engine,HTMLClueFlowStyle   style,guint8              indentation,HTMLHAlignType      alignment
1112 </FUNCTION>
1113 <FUNCTION>
1114 <NAME>html_clueflow_get_properties</NAME>
1115 <RETURNS>void  </RETURNS>
1116 HTMLClueFlow       *flow,HTMLClueFlowStyle  *style_return,guint8             *indentation_return,HTMLHAlignType     *alignment_return
1117 </FUNCTION>
1118 <FUNCTION>
1119 <NAME>html_clueflow_remove_text_slaves</NAME>
1120 <RETURNS>void  </RETURNS>
1121 HTMLClueFlow       *flow
1122 </FUNCTION>
1123 <FUNCTION>
1124 <NAME>html_clueflow_spell_check</NAME>
1125 <RETURNS>void  </RETURNS>
1126 HTMLClueFlow       *flow,HTMLEngine         *e,HTMLInterval       *i
1127 </FUNCTION>
1128 <MACRO>
1129 <NAME>SPELL_CHECK</NAME>
1130 #define SPELL_CHECK(f, e) if (f && HTML_OBJECT_TYPE (f) == HTML_TYPE_CLUEFLOW) \
1131                                    html_clueflow_spell_check (HTML_CLUEFLOW (f), e, NULL)
1132 </MACRO>
1133 <MACRO>
1134 <NAME>HTML_CLUEH</NAME>
1135 #define HTML_CLUEH(x) ((HTMLClueH *)(x))
1136 </MACRO>
1137 <MACRO>
1138 <NAME>HTML_CLUEH_CLASS</NAME>
1139 #define HTML_CLUEH_CLASS(X) ((HTMLClueHClass *)(x))
1140 </MACRO>
1141 <STRUCT>
1142 <NAME>HTMLClueH</NAME>
1143 struct HTMLClueH {
1144         HTMLClue clue;
1145
1146         gshort indent;
1147 };
1148 </STRUCT>
1149 <VARIABLE>
1150 <NAME>html_clue_h_class</NAME>
1151 extern HTMLClueHClass html_clue_h_class;
1152 </VARIABLE>
1153 <FUNCTION>
1154 <NAME>html_clueh_type_init</NAME>
1155 <RETURNS>void  </RETURNS>
1156 void
1157 </FUNCTION>
1158 <FUNCTION>
1159 <NAME>html_clueh_class_init</NAME>
1160 <RETURNS>void  </RETURNS>
1161 HTMLClueHClass *klass,HTMLType        type,guint           object_size
1162 </FUNCTION>
1163 <FUNCTION>
1164 <NAME>html_clueh_init</NAME>
1165 <RETURNS>void  </RETURNS>
1166 HTMLClueH      *clue,HTMLClueHClass *klass,gint            x,gint            y,gint            max_width
1167 </FUNCTION>
1168 <FUNCTION>
1169 <NAME>html_clueh_new</NAME>
1170 <RETURNS>HTMLObject  *</RETURNS>
1171 gint            x,gint            y,gint            max_width
1172 </FUNCTION>
1173 <MACRO>
1174 <NAME>HTML_CLUEV</NAME>
1175 #define HTML_CLUEV(x) ((HTMLClueV *)(x))
1176 </MACRO>
1177 <MACRO>
1178 <NAME>HTML_CLUEV_CLASS</NAME>
1179 #define HTML_CLUEV_CLASS(x) ((HTMLClueVClass *)(x))
1180 </MACRO>
1181 <STRUCT>
1182 <NAME>HTMLClueV</NAME>
1183 struct HTMLClueV {
1184         HTMLClue clue;
1185
1186         /* FIXME: htmlcluealigned */
1187         HTMLObject *align_left_list;
1188         HTMLObject *align_right_list;
1189         gushort padding;
1190 };
1191 </STRUCT>
1192 <VARIABLE>
1193 <NAME>html_cluev_class</NAME>
1194 extern HTMLClueVClass html_cluev_class;
1195 </VARIABLE>
1196 <FUNCTION>
1197 <NAME>html_cluev_type_init</NAME>
1198 <RETURNS>void  </RETURNS>
1199 void
1200 </FUNCTION>
1201 <FUNCTION>
1202 <NAME>html_cluev_class_init</NAME>
1203 <RETURNS>void  </RETURNS>
1204 HTMLClueVClass *klass,HTMLType        type,guint           object_size
1205 </FUNCTION>
1206 <FUNCTION>
1207 <NAME>html_cluev_init</NAME>
1208 <RETURNS>void  </RETURNS>
1209 HTMLClueV      *cluev,HTMLClueVClass *klass,gint            x,gint            y,gint            percent
1210 </FUNCTION>
1211 <FUNCTION>
1212 <NAME>html_cluev_new</NAME>
1213 <RETURNS>HTMLObject  *</RETURNS>
1214 gint            x,gint            y,gint            percent
1215 </FUNCTION>
1216 <STRUCT>
1217 <NAME>HTMLColor</NAME>
1218 struct HTMLColor {
1219         GdkColor color;
1220         gboolean allocated;
1221         guint refcount;
1222 };
1223 </STRUCT>
1224 <FUNCTION>
1225 <NAME>html_color_new</NAME>
1226 <RETURNS>HTMLColor  *</RETURNS>
1227 void
1228 </FUNCTION>
1229 <FUNCTION>
1230 <NAME>html_color_new_from_gdk_color</NAME>
1231 <RETURNS>HTMLColor  *</RETURNS>
1232 const GdkColor *color
1233 </FUNCTION>
1234 <FUNCTION>
1235 <NAME>html_color_new_from_rgb</NAME>
1236 <RETURNS>HTMLColor  *</RETURNS>
1237 gushort red, gushort green, gushort blue
1238 </FUNCTION>
1239 <FUNCTION>
1240 <NAME>html_color_ref</NAME>
1241 <RETURNS>void  </RETURNS>
1242 HTMLColor *color
1243 </FUNCTION>
1244 <FUNCTION>
1245 <NAME>html_color_unref</NAME>
1246 <RETURNS>void  </RETURNS>
1247 HTMLColor *color
1248 </FUNCTION>
1249 <FUNCTION>
1250 <NAME>html_color_alloc</NAME>
1251 <RETURNS>void  </RETURNS>
1252 HTMLColor *color, HTMLPainter *painter
1253 </FUNCTION>
1254 <FUNCTION>
1255 <NAME>html_color_free</NAME>
1256 <RETURNS>void  </RETURNS>
1257 HTMLColor *color, HTMLPainter *painter
1258 </FUNCTION>
1259 <FUNCTION>
1260 <NAME>html_color_equal</NAME>
1261 <RETURNS>gboolean  </RETURNS>
1262 HTMLColor *color1, HTMLColor *color2
1263 </FUNCTION>
1264 <FUNCTION>
1265 <NAME>html_color_set</NAME>
1266 <RETURNS>void  </RETURNS>
1267 HTMLColor *color, GdkColor *c
1268 </FUNCTION>
1269 <STRUCT>
1270 <NAME>HTMLColorSet</NAME>
1271 struct HTMLColorSet
1272 {
1273         HTMLColor *color [HTMLColors];
1274         gboolean changed [HTMLColors];
1275
1276         /* slave sets - they must be updated when setting this one
1277            engine has master set and painters have slave ones
1278          */
1279         GSList  *slaves;
1280 };
1281 </STRUCT>
1282 <FUNCTION>
1283 <NAME>html_colorset_new</NAME>
1284 <RETURNS>HTMLColorSet      *</RETURNS>
1285 GtkWidget *w
1286 </FUNCTION>
1287 <FUNCTION>
1288 <NAME>html_colorset_destroy</NAME>
1289 <RETURNS>void  </RETURNS>
1290 HTMLColorSet *set
1291 </FUNCTION>
1292 <FUNCTION>
1293 <NAME>html_colorset_add_slave</NAME>
1294 <RETURNS>void  </RETURNS>
1295 HTMLColorSet *set,HTMLColorSet *slave
1296 </FUNCTION>
1297 <FUNCTION>
1298 <NAME>html_colorset_set_color</NAME>
1299 <RETURNS>void  </RETURNS>
1300 HTMLColorSet *set,GdkColor *color,HTMLColorId idx
1301 </FUNCTION>
1302 <FUNCTION>
1303 <NAME>html_colorset_get_color</NAME>
1304 <RETURNS>HTMLColor         *</RETURNS>
1305 HTMLColorSet *set,HTMLColorId idx
1306 </FUNCTION>
1307 <FUNCTION>
1308 <NAME>html_colorset_get_color_allocated</NAME>
1309 <RETURNS>HTMLColor         *</RETURNS>
1310 HTMLPainter *painter,HTMLColorId idx
1311 </FUNCTION>
1312 <FUNCTION>
1313 <NAME>html_colorset_set_by</NAME>
1314 <RETURNS>void  </RETURNS>
1315 HTMLColorSet *s, HTMLColorSet *o
1316 </FUNCTION>
1317 <FUNCTION>
1318 <NAME>html_colorset_set_unchanged</NAME>
1319 <RETURNS>void  </RETURNS>
1320 HTMLColorSet *s, HTMLColorSet *o
1321 </FUNCTION>
1322 <FUNCTION>
1323 <NAME>html_colorset_set_style</NAME>
1324 <RETURNS>void  </RETURNS>
1325 HTMLColorSet *s, GtkStyle *style
1326 </FUNCTION>
1327 <STRUCT>
1328 <NAME>HTMLCursor</NAME>
1329 struct HTMLCursor {
1330         HTMLObject *object;
1331         guint offset;
1332
1333         gint target_x;
1334         guint have_target_x : 1;
1335
1336         gint position;
1337 };
1338 </STRUCT>
1339 <FUNCTION>
1340 <NAME>html_cursor_new</NAME>
1341 <RETURNS>HTMLCursor  *</RETURNS>
1342 void
1343 </FUNCTION>
1344 <FUNCTION>
1345 <NAME>html_cursor_destroy</NAME>
1346 <RETURNS>void  </RETURNS>
1347 HTMLCursor       *cursor
1348 </FUNCTION>
1349 <FUNCTION>
1350 <NAME>html_cursor_dup</NAME>
1351 <RETURNS>HTMLCursor  *</RETURNS>
1352 const HTMLCursor *cursor
1353 </FUNCTION>
1354 <FUNCTION>
1355 <NAME>html_cursor_copy</NAME>
1356 <RETURNS>void  </RETURNS>
1357 HTMLCursor       *dest,const HTMLCursor *src
1358 </FUNCTION>
1359 <FUNCTION>
1360 <NAME>html_cursor_home</NAME>
1361 <RETURNS>void  </RETURNS>
1362 HTMLCursor *cursor,HTMLEngine *engine
1363 </FUNCTION>
1364 <FUNCTION>
1365 <NAME>html_cursor_forward</NAME>
1366 <RETURNS>gboolean  </RETURNS>
1367 HTMLCursor *cursor,HTMLEngine *engine
1368 </FUNCTION>
1369 <FUNCTION>
1370 <NAME>html_cursor_backward</NAME>
1371 <RETURNS>gboolean  </RETURNS>
1372 HTMLCursor *cursor,HTMLEngine *engine
1373 </FUNCTION>
1374 <FUNCTION>
1375 <NAME>html_cursor_forward_n</NAME>
1376 <RETURNS>gboolean  </RETURNS>
1377 HTMLCursor *cursor,HTMLEngine *e,guint      n
1378 </FUNCTION>
1379 <FUNCTION>
1380 <NAME>html_cursor_backward_n</NAME>
1381 <RETURNS>gboolean  </RETURNS>
1382 HTMLCursor *cursor,HTMLEngine *e,guint      n
1383 </FUNCTION>
1384 <FUNCTION>
1385 <NAME>html_cursor_up</NAME>
1386 <RETURNS>gboolean  </RETURNS>
1387 HTMLCursor *cursor,HTMLEngine *engine
1388 </FUNCTION>
1389 <FUNCTION>
1390 <NAME>html_cursor_down</NAME>
1391 <RETURNS>gboolean  </RETURNS>
1392 HTMLCursor *cursor,HTMLEngine *engine
1393 </FUNCTION>
1394 <FUNCTION>
1395 <NAME>html_cursor_beginning_of_document</NAME>
1396 <RETURNS>void  </RETURNS>
1397 HTMLCursor *cursor,HTMLEngine *engine
1398 </FUNCTION>
1399 <FUNCTION>
1400 <NAME>html_cursor_end_of_document</NAME>
1401 <RETURNS>void  </RETURNS>
1402 HTMLCursor *cursor,HTMLEngine *engine
1403 </FUNCTION>
1404 <FUNCTION>
1405 <NAME>html_cursor_beginning_of_line</NAME>
1406 <RETURNS>gboolean  </RETURNS>
1407 HTMLCursor *cursor,HTMLEngine *engine
1408 </FUNCTION>
1409 <FUNCTION>
1410 <NAME>html_cursor_end_of_line</NAME>
1411 <RETURNS>gboolean  </RETURNS>
1412 HTMLCursor *cursor,HTMLEngine *engine
1413 </FUNCTION>
1414 <FUNCTION>
1415 <NAME>html_cursor_beginning_of_paragraph</NAME>
1416 <RETURNS>gboolean  </RETURNS>
1417 HTMLCursor *cursor,HTMLEngine *engine
1418 </FUNCTION>
1419 <FUNCTION>
1420 <NAME>html_cursor_end_of_paragraph</NAME>
1421 <RETURNS>gboolean  </RETURNS>
1422 HTMLCursor *cursor,HTMLEngine *engine
1423 </FUNCTION>
1424 <FUNCTION>
1425 <NAME>html_cursor_jump_to</NAME>
1426 <RETURNS>gboolean  </RETURNS>
1427 HTMLCursor *cursor,HTMLEngine *engine,HTMLObject *obj,guint       offset
1428 </FUNCTION>
1429 <FUNCTION>
1430 <NAME>html_cursor_normalize</NAME>
1431 <RETURNS>void  </RETURNS>
1432 HTMLCursor *cursor
1433 </FUNCTION>
1434 <FUNCTION>
1435 <NAME>html_cursor_get_position</NAME>
1436 <RETURNS>gint  </RETURNS>
1437 HTMLCursor *cursor
1438 </FUNCTION>
1439 <FUNCTION>
1440 <NAME>html_cursor_jump_to_position</NAME>
1441 <RETURNS>void  </RETURNS>
1442 HTMLCursor *cursor,HTMLEngine *engine,gint        position
1443 </FUNCTION>
1444 <FUNCTION>
1445 <NAME>html_cursor_get_current_char</NAME>
1446 <RETURNS>unicode_char_t  </RETURNS>
1447 const HTMLCursor *cursor
1448 </FUNCTION>
1449 <FUNCTION>
1450 <NAME>html_cursor_get_prev_char</NAME>
1451 <RETURNS>unicode_char_t  </RETURNS>
1452 const HTMLCursor *cursor
1453 </FUNCTION>
1454 <FUNCTION>
1455 <NAME>html_cursor_equal</NAME>
1456 <RETURNS>gboolean  </RETURNS>
1457 const HTMLCursor *a,const HTMLCursor *b
1458 </FUNCTION>
1459 <FUNCTION>
1460 <NAME>html_cursor_precedes</NAME>
1461 <RETURNS>gboolean  </RETURNS>
1462 const HTMLCursor *a,const HTMLCursor *b
1463 </FUNCTION>
1464 <FUNCTION>
1465 <NAME>html_cursor_follows</NAME>
1466 <RETURNS>gboolean  </RETURNS>
1467 const HTMLCursor *a,const HTMLCursor *b
1468 </FUNCTION>
1469 <STRUCT>
1470 <NAME>HTMLDrawQueueClearElement</NAME>
1471 struct HTMLDrawQueueClearElement {
1472         gint x, y;
1473         guint width, height;
1474         GdkColor *background_color;
1475         GdkPixbuf *background_image;
1476         guint background_image_x_offset, background_image_y_offset;
1477 };
1478 </STRUCT>
1479 <STRUCT>
1480 <NAME>HTMLDrawQueue</NAME>
1481 struct HTMLDrawQueue {
1482         /* The associated engine.  */
1483         HTMLEngine *engine;
1484
1485         /* Elements to be drawn.  */
1486         GList *elems;
1487         /* Pointer to the last element in the list, for faster appending.  */
1488         GList *last;
1489
1490         /* Elements to be cleared (HTMLDrawQueueClearElement).  */
1491         GList *clear_elems;
1492         /* Pointer to the last element.  */
1493         GList *clear_last;
1494 };
1495 </STRUCT>
1496 <FUNCTION>
1497 <NAME>html_draw_queue_new</NAME>
1498 <RETURNS>HTMLDrawQueue  *</RETURNS>
1499 HTMLEngine    *engine
1500 </FUNCTION>
1501 <FUNCTION>
1502 <NAME>html_draw_queue_destroy</NAME>
1503 <RETURNS>void  </RETURNS>
1504 HTMLDrawQueue *queue
1505 </FUNCTION>
1506 <FUNCTION>
1507 <NAME>html_draw_queue_flush</NAME>
1508 <RETURNS>void  </RETURNS>
1509 HTMLDrawQueue *queue
1510 </FUNCTION>
1511 <FUNCTION>
1512 <NAME>html_draw_queue_clear</NAME>
1513 <RETURNS>void  </RETURNS>
1514 HTMLDrawQueue *queue
1515 </FUNCTION>
1516 <FUNCTION>
1517 <NAME>html_draw_queue_add</NAME>
1518 <RETURNS>void  </RETURNS>
1519 HTMLDrawQueue *queue,HTMLObject    *object
1520 </FUNCTION>
1521 <FUNCTION>
1522 <NAME>html_draw_queue_add_clear</NAME>
1523 <RETURNS>void  </RETURNS>
1524 HTMLDrawQueue  *queue,gint            x,gint            y,guint           width,guint           height,const GdkColor *background_color
1525 </FUNCTION>
1526 <FUNCTION>
1527 <NAME>html_draw_queue_add_clear_with_background</NAME>
1528 <RETURNS>void  </RETURNS>
1529 HTMLDrawQueue  *queue,gint            x,gint            y,guint           width,guint           height,GdkPixbuf      *background_image,guint           image_x_offset,guint           image_y_offset
1530 </FUNCTION>
1531 <MACRO>
1532 <NAME>HTML_EMBEDDED</NAME>
1533 #define HTML_EMBEDDED(x) ((HTMLEmbedded *)(x))
1534 </MACRO>
1535 <MACRO>
1536 <NAME>HTML_EMBEDDED_CLASS</NAME>
1537 #define HTML_EMBEDDED_CLASS(x) ((HTMLEmbeddedClass *)(x))
1538 </MACRO>
1539 <STRUCT>
1540 <NAME>HTMLEmbedded</NAME>
1541 struct HTMLEmbedded {
1542         HTMLObject object;
1543
1544         gchar *name;
1545         gchar *value;
1546         HTMLForm *form;
1547         GtkWidget *widget, *parent;
1548         gint16 width, height;
1549
1550         gint abs_x, abs_y;
1551 };
1552 </STRUCT>
1553 <VARIABLE>
1554 <NAME>html_embedded_class</NAME>
1555 extern HTMLEmbeddedClass html_embedded_class;
1556 </VARIABLE>
1557 <FUNCTION>
1558 <NAME>html_embedded_type_init</NAME>
1559 <RETURNS>void  </RETURNS>
1560 void
1561 </FUNCTION>
1562 <FUNCTION>
1563 <NAME>html_embedded_class_init</NAME>
1564 <RETURNS>void  </RETURNS>
1565 HTMLEmbeddedClass *klass,HTMLType           type,guint              object_size
1566 </FUNCTION>
1567 <FUNCTION>
1568 <NAME>html_embedded_init</NAME>
1569 <RETURNS>void  </RETURNS>
1570 HTMLEmbedded      *element,HTMLEmbeddedClass *klass,GtkWidget         *parent,gchar             *name,gchar             *value
1571 </FUNCTION>
1572 <FUNCTION>
1573 <NAME>html_embedded_set_widget</NAME>
1574 <RETURNS>void  </RETURNS>
1575 HTMLEmbedded      *element,GtkWidget         *widget
1576 </FUNCTION>
1577 <FUNCTION>
1578 <NAME>html_embedded_get_name</NAME>
1579 <RETURNS>gchar         *</RETURNS>
1580 HTMLEmbedded      *element
1581 </FUNCTION>
1582 <FUNCTION>
1583 <NAME>html_embedded_set_form</NAME>
1584 <RETURNS>void  </RETURNS>
1585 HTMLEmbedded      *element,HTMLForm          *form
1586 </FUNCTION>
1587 <FUNCTION>
1588 <NAME>html_embedded_reset</NAME>
1589 <RETURNS>void  </RETURNS>
1590 HTMLEmbedded      *element
1591 </FUNCTION>
1592 <FUNCTION>
1593 <NAME>html_embedded_encode</NAME>
1594 <RETURNS>gchar         *</RETURNS>
1595 HTMLEmbedded      *element
1596 </FUNCTION>
1597 <FUNCTION>
1598 <NAME>html_embedded_encode_string</NAME>
1599 <RETURNS>gchar         *</RETURNS>
1600 gchar             *str
1601 </FUNCTION>
1602 <FUNCTION>
1603 <NAME>html_embedded_new_widget</NAME>
1604 <RETURNS>HTMLEmbedded  *</RETURNS>
1605 GtkWidget         *parent,GtkHTMLEmbedded   *eb
1606 </FUNCTION>
1607 <FUNCTION>
1608 <NAME>html_embedded_size_recalc</NAME>
1609 <RETURNS>void  </RETURNS>
1610 HTMLEmbedded      *em
1611 </FUNCTION>
1612 <FUNCTION>
1613 <NAME>html_engine_get_current_clueflow_style</NAME>
1614 <RETURNS>HTMLClueFlowStyle  </RETURNS>
1615 HTMLEngine *engine
1616 </FUNCTION>
1617 <FUNCTION>
1618 <NAME>html_engine_get_current_clueflow_indentation</NAME>
1619 <RETURNS>guint  </RETURNS>
1620 HTMLEngine *engine
1621 </FUNCTION>
1622 <FUNCTION>
1623 <NAME>html_engine_get_current_clueflow_alignment</NAME>
1624 <RETURNS>HTMLHAlignType  </RETURNS>
1625 HTMLEngine *engine
1626 </FUNCTION>
1627 <FUNCTION>
1628 <NAME>html_engine_set_clueflow_style</NAME>
1629 <RETURNS>gboolean  </RETURNS>
1630 HTMLEngine                     *engine,HTMLClueFlowStyle               style,HTMLHAlignType                  alignment,gint                            indentation_delta,HTMLEngineSetClueFlowStyleMask  mask,gboolean                        do_undo
1631 </FUNCTION>
1632 <FUNCTION>
1633 <NAME>html_engine_get_current_clueflow_style</NAME>
1634 <RETURNS>HTMLClueFlowStyle  </RETURNS>
1635 HTMLEngine *engine
1636 </FUNCTION>
1637 <FUNCTION>
1638 <NAME>html_engine_get_current_clueflow_indentation</NAME>
1639 <RETURNS>guint  </RETURNS>
1640 HTMLEngine *engine
1641 </FUNCTION>
1642 <FUNCTION>
1643 <NAME>html_engine_get_current_clueflow_alignment</NAME>
1644 <RETURNS>HTMLHAlignType  </RETURNS>
1645 HTMLEngine *engine
1646 </FUNCTION>
1647 <FUNCTION>
1648 <NAME>html_engine_hide_cursor</NAME>
1649 <RETURNS>void  </RETURNS>
1650 HTMLEngine *engine
1651 </FUNCTION>
1652 <FUNCTION>
1653 <NAME>html_engine_show_cursor</NAME>
1654 <RETURNS>void  </RETURNS>
1655 HTMLEngine *engine
1656 </FUNCTION>
1657 <FUNCTION>
1658 <NAME>html_engine_draw_cursor_in_area</NAME>
1659 <RETURNS>void  </RETURNS>
1660 HTMLEngine *engine,gint        x,gint        y,gint        width,gint        height
1661 </FUNCTION>
1662 <FUNCTION>
1663 <NAME>html_engine_setup_blinking_cursor</NAME>
1664 <RETURNS>void  </RETURNS>
1665 HTMLEngine *engine
1666 </FUNCTION>
1667 <FUNCTION>
1668 <NAME>html_engine_stop_blinking_cursor</NAME>
1669 <RETURNS>void  </RETURNS>
1670 HTMLEngine *engine
1671 </FUNCTION>
1672 <FUNCTION>
1673 <NAME>html_engine_reset_blinking_cursor</NAME>
1674 <RETURNS>void  </RETURNS>
1675 HTMLEngine *engine
1676 </FUNCTION>
1677 <FUNCTION>
1678 <NAME>html_engine_update_insertion_font_style</NAME>
1679 <RETURNS>gboolean  </RETURNS>
1680 HTMLEngine       *engine
1681 </FUNCTION>
1682 <FUNCTION>
1683 <NAME>html_engine_get_font_style</NAME>
1684 <RETURNS>GtkHTMLFontStyle  </RETURNS>
1685 HTMLEngine       *engine
1686 </FUNCTION>
1687 <FUNCTION>
1688 <NAME>html_engine_get_document_font_style</NAME>
1689 <RETURNS>GtkHTMLFontStyle  </RETURNS>
1690 HTMLEngine       *engine
1691 </FUNCTION>
1692 <FUNCTION>
1693 <NAME>html_engine_set_font_style</NAME>
1694 <RETURNS>gboolean  </RETURNS>
1695 HTMLEngine       *engine,GtkHTMLFontStyle  and_mask,GtkHTMLFontStyle  or_mask
1696 </FUNCTION>
1697 <FUNCTION>
1698 <NAME>html_engine_toggle_font_style</NAME>
1699 <RETURNS>gboolean  </RETURNS>
1700 HTMLEngine       *engine,GtkHTMLFontStyle  style
1701 </FUNCTION>
1702 <FUNCTION>
1703 <NAME>html_engine_font_size_inc_dec</NAME>
1704 <RETURNS>void  </RETURNS>
1705 HTMLEngine       *e,gboolean          inc
1706 </FUNCTION>
1707 <FUNCTION>
1708 <NAME>html_engine_update_insertion_color</NAME>
1709 <RETURNS>gboolean  </RETURNS>
1710 HTMLEngine       *engine
1711 </FUNCTION>
1712 <FUNCTION>
1713 <NAME>html_engine_set_color</NAME>
1714 <RETURNS>gboolean  </RETURNS>
1715 HTMLEngine       *engine,HTMLColor        *color
1716 </FUNCTION>
1717 <FUNCTION>
1718 <NAME>html_engine_get_color</NAME>
1719 <RETURNS>HTMLColor  *</RETURNS>
1720 HTMLEngine       *engine
1721 </FUNCTION>
1722 <FUNCTION>
1723 <NAME>html_engine_get_document_color</NAME>
1724 <RETURNS>HTMLColor  *</RETURNS>
1725 HTMLEngine       *engine
1726 </FUNCTION>
1727 <FUNCTION>
1728 <NAME>html_engine_update_insertion_url_and_target</NAME>
1729 <RETURNS>gboolean  </RETURNS>
1730 HTMLEngine       *engine
1731 </FUNCTION>
1732 <FUNCTION>
1733 <NAME>html_engine_get_url</NAME>
1734 <RETURNS>const gchar  *</RETURNS>
1735 HTMLEngine       *e
1736 </FUNCTION>
1737 <FUNCTION>
1738 <NAME>html_engine_set_url</NAME>
1739 <RETURNS>void  </RETURNS>
1740 HTMLEngine       *e,const gchar      *url
1741 </FUNCTION>
1742 <FUNCTION>
1743 <NAME>html_engine_get_target</NAME>
1744 <RETURNS>const gchar  *</RETURNS>
1745 HTMLEngine       *e
1746 </FUNCTION>
1747 <FUNCTION>
1748 <NAME>html_engine_set_target</NAME>
1749 <RETURNS>void  </RETURNS>
1750 HTMLEngine       *e,const gchar      *url
1751 </FUNCTION>
1752 <FUNCTION>
1753 <NAME>html_engine_get_document_url</NAME>
1754 <RETURNS>const gchar  *</RETURNS>
1755 HTMLEngine       *e
1756 </FUNCTION>
1757 <FUNCTION>
1758 <NAME>html_engine_get_document_target</NAME>
1759 <RETURNS>const gchar  *</RETURNS>
1760 HTMLEngine       *e
1761 </FUNCTION>
1762 <FUNCTION>
1763 <NAME>html_engine_insert_image</NAME>
1764 <RETURNS>void  </RETURNS>
1765 HTMLEngine     *e,const gchar    *file,const gchar    *url,const gchar    *target,gint16          width,gint16          height,gboolean        percent_width,gboolean        percent_height,gint8           border,HTMLColor *border_color,HTMLHAlignType  halign,HTMLVAlignType  valign,gint8           hspace,gint8           vspace
1766 </FUNCTION>
1767 <FUNCTION>
1768 <NAME>html_engine_move_cursor</NAME>
1769 <RETURNS>guint  </RETURNS>
1770 HTMLEngine               *e,HTMLEngineCursorMovement  movement,guint                     count
1771 </FUNCTION>
1772 <FUNCTION>
1773 <NAME>html_engine_jump_to_object</NAME>
1774 <RETURNS>void  </RETURNS>
1775 HTMLEngine               *e,HTMLObject               *object,guint                     offset
1776 </FUNCTION>
1777 <FUNCTION>
1778 <NAME>html_engine_jump_at</NAME>
1779 <RETURNS>void  </RETURNS>
1780 HTMLEngine               *e,gint                      x,gint                      y
1781 </FUNCTION>
1782 <FUNCTION>
1783 <NAME>html_engine_beginning_of_document</NAME>
1784 <RETURNS>void  </RETURNS>
1785 HTMLEngine *engine
1786 </FUNCTION>
1787 <FUNCTION>
1788 <NAME>html_engine_end_of_document</NAME>
1789 <RETURNS>void  </RETURNS>
1790 HTMLEngine *engine
1791 </FUNCTION>
1792 <FUNCTION>
1793 <NAME>html_engine_beginning_of_line</NAME>
1794 <RETURNS>gboolean  </RETURNS>
1795 HTMLEngine *engine
1796 </FUNCTION>
1797 <FUNCTION>
1798 <NAME>html_engine_end_of_line</NAME>
1799 <RETURNS>gboolean  </RETURNS>
1800 HTMLEngine *engine
1801 </FUNCTION>
1802 <FUNCTION>
1803 <NAME>html_engine_scroll_down</NAME>
1804 <RETURNS>gint  </RETURNS>
1805 HTMLEngine *engine,gint        amount
1806 </FUNCTION>
1807 <FUNCTION>
1808 <NAME>html_engine_scroll_up</NAME>
1809 <RETURNS>gint  </RETURNS>
1810 HTMLEngine *engine,gint        amount
1811 </FUNCTION>
1812 <FUNCTION>
1813 <NAME>html_engine_forward_word</NAME>
1814 <RETURNS>gboolean  </RETURNS>
1815 HTMLEngine *engine
1816 </FUNCTION>
1817 <FUNCTION>
1818 <NAME>html_engine_backward_word</NAME>
1819 <RETURNS>gboolean  </RETURNS>
1820 HTMLEngine *engine
1821 </FUNCTION>
1822 <FUNCTION>
1823 <NAME>html_engine_insert_rule</NAME>
1824 <RETURNS>void  </RETURNS>
1825 HTMLEngine     *e,gint            length,gint            percent,gint            size,gboolean        shade,HTMLHAlignType  halign
1826 </FUNCTION>
1827 <FUNCTION>
1828 <NAME>html_rule_set</NAME>
1829 <RETURNS>void  </RETURNS>
1830 HTMLRule       *rule,HTMLEngine     *e,gint            length,gint            percent,gint            size,gboolean        shade,HTMLHAlignType  halign
1831 </FUNCTION>
1832 <FUNCTION>
1833 <NAME>html_engine_edit_selection_updater_new</NAME>
1834 <RETURNS>HTMLEngineEditSelectionUpdater  *</RETURNS>
1835 HTMLEngine                     *engine
1836 </FUNCTION>
1837 <FUNCTION>
1838 <NAME>html_engine_edit_selection_updater_destroy</NAME>
1839 <RETURNS>void  </RETURNS>
1840 HTMLEngineEditSelectionUpdater *updater
1841 </FUNCTION>
1842 <FUNCTION>
1843 <NAME>html_engine_edit_selection_updater_reset</NAME>
1844 <RETURNS>void  </RETURNS>
1845 HTMLEngineEditSelectionUpdater *updater
1846 </FUNCTION>
1847 <FUNCTION>
1848 <NAME>html_engine_edit_selection_updater_schedule</NAME>
1849 <RETURNS>void  </RETURNS>
1850 HTMLEngineEditSelectionUpdater *updater
1851 </FUNCTION>
1852 <FUNCTION>
1853 <NAME>html_engine_edit_selection_updater_update_now</NAME>
1854 <RETURNS>void  </RETURNS>
1855 HTMLEngineEditSelectionUpdater *updater
1856 </FUNCTION>
1857 <FUNCTION>
1858 <NAME>html_engine_create_table</NAME>
1859 <RETURNS>HTMLObject  *</RETURNS>
1860 HTMLEngine *e,gint width,gint percent,gint padding,gint spacing,gint border
1861 </FUNCTION>
1862 <FUNCTION>
1863 <NAME>html_engine_insert_table</NAME>
1864 <RETURNS>void  </RETURNS>
1865 HTMLEngine *e, gint *values
1866 </FUNCTION>
1867 <FUNCTION>
1868 <NAME>html_engine_insert_table_cell</NAME>
1869 <RETURNS>HTMLObject  *</RETURNS>
1870 HTMLEngine *e,gint percent,gint rs,gint cs,gint pad,gint width,HTMLImagePointer *imagePtr
1871 </FUNCTION>
1872 <FUNCTION>
1873 <NAME>html_engine_capitalize_word</NAME>
1874 <RETURNS>void  </RETURNS>
1875 HTMLEngine       *e
1876 </FUNCTION>
1877 <FUNCTION>
1878 <NAME>html_engine_upcase_downcase_word</NAME>
1879 <RETURNS>void  </RETURNS>
1880 HTMLEngine       *e,gboolean          up
1881 </FUNCTION>
1882 <FUNCTION>
1883 <NAME>html_engine_undo</NAME>
1884 <RETURNS>void  </RETURNS>
1885 HTMLEngine                *e
1886 </FUNCTION>
1887 <FUNCTION>
1888 <NAME>html_engine_redo</NAME>
1889 <RETURNS>void  </RETURNS>
1890 HTMLEngine                *e
1891 </FUNCTION>
1892 <FUNCTION>
1893 <NAME>html_engine_set_mark</NAME>
1894 <RETURNS>void  </RETURNS>
1895 HTMLEngine                *e
1896 </FUNCTION>
1897 <FUNCTION>
1898 <NAME>html_engine_select_word_editable</NAME>
1899 <RETURNS>void  </RETURNS>
1900 HTMLEngine                *e
1901 </FUNCTION>
1902 <FUNCTION>
1903 <NAME>html_engine_select_line_editable</NAME>
1904 <RETURNS>void  </RETURNS>
1905 HTMLEngine                *e
1906 </FUNCTION>
1907 <FUNCTION>
1908 <NAME>html_engine_clipboard_push</NAME>
1909 <RETURNS>void  </RETURNS>
1910 HTMLEngine                *e
1911 </FUNCTION>
1912 <FUNCTION>
1913 <NAME>html_engine_clipboard_pop</NAME>
1914 <RETURNS>void  </RETURNS>
1915 HTMLEngine                *e
1916 </FUNCTION>
1917 <FUNCTION>
1918 <NAME>html_engine_clipboard_clear</NAME>
1919 <RETURNS>void  </RETURNS>
1920 HTMLEngine                *e
1921 </FUNCTION>
1922 <FUNCTION>
1923 <NAME>html_engine_selection_push</NAME>
1924 <RETURNS>void  </RETURNS>
1925 HTMLEngine                *e
1926 </FUNCTION>
1927 <FUNCTION>
1928 <NAME>html_engine_selection_pop</NAME>
1929 <RETURNS>void  </RETURNS>
1930 HTMLEngine                *e
1931 </FUNCTION>
1932 <FUNCTION>
1933 <NAME>html_engine_cut_and_paste_begin</NAME>
1934 <RETURNS>void  </RETURNS>
1935 HTMLEngine                *e,gchar                     *op_name
1936 </FUNCTION>
1937 <FUNCTION>
1938 <NAME>html_engine_cut_and_paste_end</NAME>
1939 <RETURNS>void  </RETURNS>
1940 HTMLEngine                *e
1941 </FUNCTION>
1942 <FUNCTION>
1943 <NAME>html_engine_cut_and_paste</NAME>
1944 <RETURNS>void  </RETURNS>
1945 HTMLEngine                *e,gchar                     *op_name,HTMLObjectForallFunc       iterator,gpointer                   data
1946 </FUNCTION>
1947 <FUNCTION>
1948 <NAME>html_engine_spell_check_range</NAME>
1949 <RETURNS>void  </RETURNS>
1950 HTMLEngine                *e,HTMLCursor                *begin,HTMLCursor                *end
1951 </FUNCTION>
1952 <FUNCTION>
1953 <NAME>html_engine_set_data_by_type</NAME>
1954 <RETURNS>void  </RETURNS>
1955 HTMLEngine                *e,HTMLType                   object_type,const gchar               *key,const gpointer             value
1956 </FUNCTION>
1957 <FUNCTION>
1958 <NAME>html_engine_ensure_editable</NAME>
1959 <RETURNS>void  </RETURNS>
1960 HTMLEngine                *e
1961 </FUNCTION>
1962 <FUNCTION>
1963 <NAME>html_engine_new_text</NAME>
1964 <RETURNS>HTMLObject                 *</RETURNS>
1965 HTMLEngine                *e,const gchar               *text,gint                       len
1966 </FUNCTION>
1967 <FUNCTION>
1968 <NAME>html_engine_new_text_empty</NAME>
1969 <RETURNS>HTMLObject                 *</RETURNS>
1970 HTMLEngine                *e
1971 </FUNCTION>
1972 <FUNCTION>
1973 <NAME>html_engine_cursor_on_bop</NAME>
1974 <RETURNS>gboolean  </RETURNS>
1975 HTMLEngine                *e
1976 </FUNCTION>
1977 <FUNCTION>
1978 <NAME>html_engine_get_indent</NAME>
1979 <RETURNS>guint  </RETURNS>
1980 HTMLEngine                *e
1981 </FUNCTION>
1982 <FUNCTION>
1983 <NAME>html_engine_indent_pre_paragraph</NAME>
1984 <RETURNS>void  </RETURNS>
1985 HTMLEngine                *e
1986 </FUNCTION>
1987 <FUNCTION>
1988 <NAME>html_is_in_word</NAME>
1989 <RETURNS>gboolean  </RETURNS>
1990 unicode_char_t             uc
1991 </FUNCTION>
1992 <FUNCTION>
1993 <NAME>paragraph_alignment_to_html</NAME>
1994 <RETURNS>HTMLHAlignType  </RETURNS>
1995 GtkHTMLParagraphAlignment  alignment
1996 </FUNCTION>
1997 <FUNCTION>
1998 <NAME>paragraph_style_to_clueflow_style</NAME>
1999 <RETURNS>HTMLClueFlowStyle  </RETURNS>
2000 GtkHTMLParagraphStyle      style
2001 </FUNCTION>
2002 <FUNCTION>
2003 <NAME>html_alignment_to_paragraph</NAME>
2004 <RETURNS>GtkHTMLParagraphAlignment  </RETURNS>
2005 HTMLHAlignType             alignment
2006 </FUNCTION>
2007 <FUNCTION>
2008 <NAME>clueflow_style_to_paragraph_style</NAME>
2009 <RETURNS>GtkHTMLParagraphStyle  </RETURNS>
2010 HTMLClueFlowStyle          style
2011 </FUNCTION>
2012 <FUNCTION>
2013 <NAME>html_engine_print</NAME>
2014 <RETURNS>void  </RETURNS>
2015 HTMLEngine           *e,GnomePrintContext    *print_context
2016 </FUNCTION>
2017 <FUNCTION>
2018 <NAME>html_engine_print_with_header_footer</NAME>
2019 <RETURNS>void  </RETURNS>
2020 HTMLEngine           *e,GnomePrintContext    *print_context,gdouble               header_height,gdouble               footer_height,GtkHTMLPrintCallback  header_print,GtkHTMLPrintCallback  footer_print,gpointer              user_data
2021 </FUNCTION>
2022 <FUNCTION>
2023 <NAME>html_engine_print_set_min_split_index</NAME>
2024 <RETURNS>void  </RETURNS>
2025 HTMLEngine           *e,gdouble               idx
2026 </FUNCTION>
2027 <STRUCT>
2028 <NAME>HTMLEngineSaveState</NAME>
2029 struct HTMLEngineSaveState {
2030         HTMLEngine *engine;
2031         HTMLEngineSaveReceiverFn receiver;
2032         guint br_count;
2033
2034         guint error : 1;
2035
2036         guint last_level;
2037
2038         gpointer user_data;
2039 };
2040 </STRUCT>
2041 <FUNCTION>
2042 <NAME>html_engine_save_encode</NAME>
2043 <RETURNS>gboolean  </RETURNS>
2044 HTMLEngineSaveState       *state,const gchar               *buffer,guint                      length
2045 </FUNCTION>
2046 <FUNCTION>
2047 <NAME>html_engine_save_encode_string</NAME>
2048 <RETURNS>gboolean  </RETURNS>
2049 HTMLEngineSaveState       *state,const gchar               *s
2050 </FUNCTION>
2051 <FUNCTION>
2052 <NAME>html_engine_save_output_string</NAME>
2053 <RETURNS>gboolean  </RETURNS>
2054 HTMLEngineSaveState       *state,const gchar               *format,...
2055 </FUNCTION>
2056 <FUNCTION>
2057 <NAME>html_engine_save</NAME>
2058 <RETURNS>gboolean  </RETURNS>
2059 HTMLEngine          *engine,HTMLEngineSaveReceiverFn   receiver,gpointer                   user_data
2060 </FUNCTION>
2061 <FUNCTION>
2062 <NAME>html_engine_save_plain</NAME>
2063 <RETURNS>gboolean  </RETURNS>
2064 HTMLEngine          *engine,HTMLEngineSaveReceiverFn   receiver,gpointer                   user_data
2065 </FUNCTION>
2066 <FUNCTION>
2067 <NAME>html_engine_save_buffer_free</NAME>
2068 <RETURNS>void  </RETURNS>
2069 HTMLEngineSaveState       *state
2070 </FUNCTION>
2071 <FUNCTION>
2072 <NAME>html_engine_save_buffer_peek_text</NAME>
2073 <RETURNS>guchar               *</RETURNS>
2074 HTMLEngineSaveState       *state
2075 </FUNCTION>
2076 <FUNCTION>
2077 <NAME>html_engine_save_buffer_new</NAME>
2078 <RETURNS>HTMLEngineSaveState  *</RETURNS>
2079 HTMLEngine                *engine
2080 </FUNCTION>
2081 <FUNCTION>
2082 <NAME>html_engine_save_get_sample_body</NAME>
2083 <RETURNS>gchar                *</RETURNS>
2084 HTMLEngine                *e,HTMLObject                *o
2085 </FUNCTION>
2086 <FUNCTION>
2087 <NAME>html_engine_save_get_paragraph_align</NAME>
2088 <RETURNS>const gchar          *</RETURNS>
2089 GtkHTMLParagraphAlignment  align
2090 </FUNCTION>
2091 <FUNCTION>
2092 <NAME>html_engine_save_get_paragraph_style</NAME>
2093 <RETURNS>const gchar          *</RETURNS>
2094 GtkHTMLParagraphStyle      style
2095 </FUNCTION>
2096 <FUNCTION>
2097 <NAME>html_engine_search</NAME>
2098 <RETURNS>gboolean  </RETURNS>
2099 HTMLEngine *e,const gchar *text,gboolean case_sensitive,gboolean forward,gboolean regular
2100 </FUNCTION>
2101 <FUNCTION>
2102 <NAME>html_engine_search_next</NAME>
2103 <RETURNS>gboolean  </RETURNS>
2104 HTMLEngine *e
2105 </FUNCTION>
2106 <FUNCTION>
2107 <NAME>html_engine_search_incremental</NAME>
2108 <RETURNS>gboolean  </RETURNS>
2109 HTMLEngine *e,const gchar *text,gboolean forward
2110 </FUNCTION>
2111 <MACRO>
2112 <NAME>HTML_TYPE_ENGINE</NAME>
2113 #define HTML_TYPE_ENGINE                 (html_engine_get_type ())
2114 </MACRO>
2115 <MACRO>
2116 <NAME>HTML_ENGINE</NAME>
2117 #define HTML_ENGINE(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), HTML_TYPE_ENGINE, HTMLEngine))
2118 </MACRO>
2119 <MACRO>
2120 <NAME>HTML_ENGINE_CLASS</NAME>
2121 #define HTML_ENGINE_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), HTML_TYPE_ENGINE, HTMLEngineClass))
2122 </MACRO>
2123 <MACRO>
2124 <NAME>HTML_IS_ENGINE</NAME>
2125 #define HTML_IS_ENGINE(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), HTML_TYPE_ENGINE))
2126 </MACRO>
2127 <MACRO>
2128 <NAME>HTML_IS_ENGINE_CLASS</NAME>
2129 #define HTML_IS_ENGINE_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), HTML_TYPE_ENGINE))
2130 </MACRO>
2131 <MACRO>
2132 <NAME>LEFT_BORDER</NAME>
2133 #define LEFT_BORDER 10
2134 </MACRO>
2135 <MACRO>
2136 <NAME>RIGHT_BORDER</NAME>
2137 #define RIGHT_BORDER 10
2138 </MACRO>
2139 <MACRO>
2140 <NAME>TOP_BORDER</NAME>
2141 #define TOP_BORDER 10
2142 </MACRO>
2143 <MACRO>
2144 <NAME>BOTTOM_BORDER</NAME>
2145 #define BOTTOM_BORDER 10
2146 </MACRO>
2147 <STRUCT>
2148 <NAME>HTMLEngine</NAME>
2149 struct HTMLEngine {
2150         GtkObject parent;
2151         HTMLDrawQueue *draw_queue;
2152
2153         HTMLPainter *painter;
2154
2155         HTMLSettings *settings;
2156         HTMLSettings *defaultSettings;
2157
2158         HTMLUndo *undo;
2159
2160         GdkWindow *window;
2161         GdkGC *invert_gc;
2162
2163         gboolean editable;
2164
2165         HTMLObject *clipboard;
2166         guint       clipboard_len;
2167         GList      *clipboard_stack;
2168
2169         /* Freeze counter.  When greater than zero, we never trigger relayouts
2170            nor repaints.  When going from nonzero to zero, we relayout and
2171            repaint everything.  */
2172         guint freeze_count;
2173         guint thaw_idle_id;
2174
2175         gboolean parsing;
2176         HTMLTokenizer *ht;
2177         HTMLStringTokenizer *st;
2178         HTMLObject *clue;
2179
2180         HTMLObject *flow;
2181
2182         gint leftBorder;
2183         gint rightBorder;
2184         gint topBorder;
2185         gint bottomBorder;
2186
2187         /* Current indentation level.  */
2188         guint indent_level;
2189
2190         /* For the widget */
2191         gint width;
2192         gint height;
2193
2194         HTMLHAlignType divAlign;
2195
2196         /* Number of tokens parsed in the current time-slice */
2197         gint parseCount;
2198         gint granularity;
2199
2200         /* Offsets */
2201         gint x_offset, y_offset;
2202
2203         gboolean inTitle;
2204         gboolean inPre;
2205         gboolean inOption;
2206         gboolean inTextArea;
2207         gboolean eat_space;
2208
2209         gboolean newPage;
2210
2211         HTMLStack *font_style_stack; /* Font style stack, elements are GtkHTMLFontStyles.  */
2212         HTMLStack *font_face_stack;
2213         HTMLStack *color_stack; /* Color stack, elements are GdkColors.  */
2214         HTMLStack *clueflow_style_stack; /* Clueflow style stack, elements are HTMLClueFlowStyles.  */
2215
2216         gchar *url;
2217         gchar *target;
2218
2219         HTMLBlockStackElement *blockStack;
2220
2221         /* timer id to schedule paint events */
2222         guint updateTimer;
2223
2224         /* timer id for parsing routine */
2225         guint timerId;
2226
2227         /* FIXME: replace with a `gchar *'?  */
2228         GString *title;
2229
2230         gboolean writing;
2231
2232         /* The background pixmap, an HTMLImagePointer */
2233         gpointer bgPixmapPtr;
2234
2235         /* Stack of lists currently active */
2236         HTMLStack *listStack;
2237
2238         /* Stack of embedded "object"'s */
2239         HTMLStack *embeddedStack;
2240
2241         /* The associated widget.  */
2242         GtkHTML *widget;
2243
2244         gpointer image_factory;
2245
2246         HTMLStack *glossaryStack; /* HTMLGlossaryEntry */
2247
2248         /*
2249          * This list holds strings which are displayed in the view,
2250          * but are not actually contained in the HTML source.
2251          * e.g. The numbers in an ordered list.
2252          * FIXME?
2253          */
2254         GList *tempStrings;
2255
2256         HTMLForm *form;
2257         HTMLSelect *formSelect;
2258         HTMLTextArea *formTextArea;
2259         GList *formList;
2260         GString *formText;
2261         gboolean noWrap;
2262
2263         /* This is TRUE if we cannot insert a paragraph break (which is just an
2264            extra empty line).  It's set to FALSE as soon as some element is
2265            added to a flow.  The purpose is to avoid having paragraph breaks to
2266            be inserted in sequence, or after elements that have some vspace of
2267            their own.  */
2268         gboolean avoid_para;
2269
2270         /* This is TRUE if we want a paragraph break to be inserted before the
2271            next element.  */
2272         gboolean pending_para;
2273
2274         /* Alignment for the pending paragraph we are going to insert.  */
2275         HTMLHAlignType pending_para_alignment;
2276
2277         /* Whether we have the keyboard focus.  */
2278         guint have_focus : 1;
2279
2280         HTMLInterval *selection;
2281         gboolean selected_in;
2282
2283         /* --- */
2284
2285         /* Editing stuff.  -- FIXME it should be in a separate object.  */
2286
2287         /* The current position of the cursor.  */
2288         HTMLCursor *cursor;
2289
2290         /* If no region is active, this is NULL.  Otherwise, this is
2291            one extreme of the selected region.  The other extreme is
2292            always the cursor.  */
2293         HTMLCursor *mark;
2294
2295         /* Hide counter for the cursor.  When greater than zero, it
2296            means the cursor is invisible.  */
2297         gint cursor_hide_count;
2298
2299         /* Timer ID for cursor blink.  */
2300         gint blinking_timer_id;
2301
2302         /* Blinking status (visible/invisible).  */
2303         gboolean blinking_status;
2304
2305         /* Font style for insertion.  If HTML_FONT_STYLE_DEFAULT, use that of
2306            the text we are in.  */
2307         GtkHTMLFontStyle  insertion_font_style;
2308         HTMLColor        *insertion_color;
2309         gchar            *insertion_url;
2310         gchar            *insertion_target;
2311
2312         /* if we are doing shift selection - Shift + some event (arrows, mouse motion, ...) */
2313         gboolean shift_selection;
2314
2315         /* This object is used to update the keyboard selection in the
2316            idle loop.  */
2317         HTMLEngineEditSelectionUpdater *selection_updater;
2318
2319         /* keeps selection between operation, which are changing selection
2320            and need restore it after done */
2321         GList *selection_stack;
2322
2323         /* search & replace */
2324         HTMLSearch  *search_info;
2325         HTMLReplace *replace_info;
2326
2327         /* id-to-object mapping */
2328         GHashTable *id_table;
2329
2330         gdouble min_split_index;
2331
2332         gboolean need_spell_check;
2333 };
2334 </STRUCT>
2335 <FUNCTION>
2336 <NAME>html_engine_get_type</NAME>
2337 <RETURNS>guint  </RETURNS>
2338 void
2339 </FUNCTION>
2340 <FUNCTION>
2341 <NAME>html_engine_new</NAME>
2342 <RETURNS>HTMLEngine  *</RETURNS>
2343 GtkWidget *
2344 </FUNCTION>
2345 <FUNCTION>
2346 <NAME>html_engine_realize</NAME>
2347 <RETURNS>void  </RETURNS>
2348 HTMLEngine *engine,GdkWindow  *window
2349 </FUNCTION>
2350 <FUNCTION>
2351 <NAME>html_engine_unrealize</NAME>
2352 <RETURNS>void  </RETURNS>
2353 HTMLEngine *engine
2354 </FUNCTION>
2355 <FUNCTION>
2356 <NAME>html_engine_set_editable</NAME>
2357 <RETURNS>void  </RETURNS>
2358 HTMLEngine *e,gboolean    editable
2359 </FUNCTION>
2360 <FUNCTION>
2361 <NAME>html_engine_get_editable</NAME>
2362 <RETURNS>gboolean  </RETURNS>
2363 HTMLEngine *e
2364 </FUNCTION>
2365 <FUNCTION>
2366 <NAME>html_engine_set_focus</NAME>
2367 <RETURNS>void  </RETURNS>
2368 HTMLEngine *engine,gboolean    have_focus
2369 </FUNCTION>
2370 <FUNCTION>
2371 <NAME>html_engine_begin</NAME>
2372 <RETURNS>GtkHTMLStream  *</RETURNS>
2373 HTMLEngine  *p,char        *content_type
2374 </FUNCTION>
2375 <FUNCTION>
2376 <NAME>html_engine_parse</NAME>
2377 <RETURNS>void  </RETURNS>
2378 HTMLEngine  *p
2379 </FUNCTION>
2380 <FUNCTION>
2381 <NAME>html_engine_stop_parser</NAME>
2382 <RETURNS>void  </RETURNS>
2383 HTMLEngine  *e
2384 </FUNCTION>
2385 <FUNCTION>
2386 <NAME>html_engine_calc_size</NAME>
2387 <RETURNS>void  </RETURNS>
2388 HTMLEngine *p
2389 </FUNCTION>
2390 <FUNCTION>
2391 <NAME>html_engine_get_doc_height</NAME>
2392 <RETURNS>gint  </RETURNS>
2393 HTMLEngine *p
2394 </FUNCTION>
2395 <FUNCTION>
2396 <NAME>html_engine_get_doc_width</NAME>
2397 <RETURNS>gint  </RETURNS>
2398 HTMLEngine *e
2399 </FUNCTION>
2400 <FUNCTION>
2401 <NAME>html_engine_draw</NAME>
2402 <RETURNS>void  </RETURNS>
2403 HTMLEngine *e,gint        x,gint        y,gint        width,gint        height
2404 </FUNCTION>
2405 <FUNCTION>
2406 <NAME>html_engine_draw_background</NAME>
2407 <RETURNS>void  </RETURNS>
2408 HTMLEngine *e,gint        x,gint        y,gint        width,gint        height
2409 </FUNCTION>
2410 <FUNCTION>
2411 <NAME>html_engine_schedule_update</NAME>
2412 <RETURNS>void  </RETURNS>
2413 HTMLEngine  *p
2414 </FUNCTION>
2415 <FUNCTION>
2416 <NAME>html_engine_make_cursor_visible</NAME>
2417 <RETURNS>gboolean  </RETURNS>
2418 HTMLEngine  *e
2419 </FUNCTION>
2420 <FUNCTION>
2421 <NAME>html_engine_goto_anchor</NAME>
2422 <RETURNS>gboolean  </RETURNS>
2423 HTMLEngine  *e,const gchar *anchor
2424 </FUNCTION>
2425 <FUNCTION>
2426 <NAME>html_engine_flush_draw_queue</NAME>
2427 <RETURNS>void  </RETURNS>
2428 HTMLEngine *e
2429 </FUNCTION>
2430 <FUNCTION>
2431 <NAME>html_engine_queue_draw</NAME>
2432 <RETURNS>void  </RETURNS>
2433 HTMLEngine *e,HTMLObject *o
2434 </FUNCTION>
2435 <FUNCTION>
2436 <NAME>html_engine_queue_clear</NAME>
2437 <RETURNS>void  </RETURNS>
2438 HTMLEngine *e,gint        x,gint        y,guint       width,guint       height
2439 </FUNCTION>
2440 <FUNCTION>
2441 <NAME>html_engine_set_painter</NAME>
2442 <RETURNS>void  </RETURNS>
2443 HTMLEngine  *e,HTMLPainter *painter,gint max_width
2444 </FUNCTION>
2445 <FUNCTION>
2446 <NAME>html_engine_get_object_at</NAME>
2447 <RETURNS>HTMLObject   *</RETURNS>
2448 HTMLEngine *e,gint        x,gint        y,guint      *offset_return,gboolean    for_cursor
2449 </FUNCTION>
2450 <FUNCTION>
2451 <NAME>html_engine_get_point_at</NAME>
2452 <RETURNS>HTMLPoint    *</RETURNS>
2453 HTMLEngine *e,gint        x,gint        y,gboolean    for_cursor
2454 </FUNCTION>
2455 <FUNCTION>
2456 <NAME>html_engine_get_link_at</NAME>
2457 <RETURNS>const gchar  *</RETURNS>
2458 HTMLEngine *e,gint        x,gint        y
2459 </FUNCTION>
2460 <FUNCTION>
2461 <NAME>html_engine_form_submitted</NAME>
2462 <RETURNS>void  </RETURNS>
2463 HTMLEngine  *engine,const gchar *method,const gchar *action,const gchar *encoding
2464 </FUNCTION>
2465 <FUNCTION>
2466 <NAME>html_engine_canonicalize_url</NAME>
2467 <RETURNS>gchar  *</RETURNS>
2468 HTMLEngine *e,const char *in_url
2469 </FUNCTION>
2470 <FUNCTION>
2471 <NAME>html_engine_get_cursor</NAME>
2472 <RETURNS>HTMLCursor  *</RETURNS>
2473 HTMLEngine *e
2474 </FUNCTION>
2475 <FUNCTION>
2476 <NAME>html_engine_normalize_cursor</NAME>
2477 <RETURNS>void  </RETURNS>
2478 HTMLEngine *e
2479 </FUNCTION>
2480 <FUNCTION>
2481 <NAME>html_engine_frozen</NAME>
2482 <RETURNS>gboolean  </RETURNS>
2483 HTMLEngine *engine
2484 </FUNCTION>
2485 <FUNCTION>
2486 <NAME>html_engine_freeze</NAME>
2487 <RETURNS>void  </RETURNS>
2488 HTMLEngine *engine
2489 </FUNCTION>
2490 <FUNCTION>
2491 <NAME>html_engine_thaw</NAME>
2492 <RETURNS>void  </RETURNS>
2493 HTMLEngine *engine
2494 </FUNCTION>
2495 <FUNCTION>
2496 <NAME>html_engine_load_empty</NAME>
2497 <RETURNS>void  </RETURNS>
2498 HTMLEngine *engine
2499 </FUNCTION>
2500 <FUNCTION>
2501 <NAME>html_engine_replace</NAME>
2502 <RETURNS>void  </RETURNS>
2503 HTMLEngine *e,const gchar *text,const gchar *rep_text,gboolean case_sensitive,gboolean forward,gboolean regular,void (*ask)(HTMLEngine *, gpointer), gpointer ask_data
2504 </FUNCTION>
2505 <FUNCTION>
2506 <NAME>html_engine_replace_do</NAME>
2507 <RETURNS>void  </RETURNS>
2508 HTMLEngine *e, HTMLReplaceQueryAnswer answer
2509 </FUNCTION>
2510 <FUNCTION>
2511 <NAME>html_engine_replaced</NAME>
2512 <RETURNS>gint  </RETURNS>
2513 void
2514 </FUNCTION>
2515 <FUNCTION>
2516 <NAME>html_engine_init_magic_links</NAME>
2517 <RETURNS>void  </RETURNS>
2518 void
2519 </FUNCTION>
2520 <FUNCTION>
2521 <NAME>html_engine_spell_check</NAME>
2522 <RETURNS>void  </RETURNS>
2523 HTMLEngine  *e
2524 </FUNCTION>
2525 <FUNCTION>
2526 <NAME>html_engine_get_word</NAME>
2527 <RETURNS>gchar     *</RETURNS>
2528 HTMLEngine  *e
2529 </FUNCTION>
2530 <FUNCTION>
2531 <NAME>html_engine_word_is_valid</NAME>
2532 <RETURNS>gboolean  </RETURNS>
2533 HTMLEngine  *e
2534 </FUNCTION>
2535 <FUNCTION>
2536 <NAME>html_engine_replace_word_with</NAME>
2537 <RETURNS>void  </RETURNS>
2538 HTMLEngine  *e,const gchar *word
2539 </FUNCTION>
2540 <FUNCTION>
2541 <NAME>html_engine_get_view_width</NAME>
2542 <RETURNS>gint  </RETURNS>
2543 HTMLEngine *e
2544 </FUNCTION>
2545 <FUNCTION>
2546 <NAME>html_engine_get_view_height</NAME>
2547 <RETURNS>gint  </RETURNS>
2548 HTMLEngine *e
2549 </FUNCTION>
2550 <FUNCTION>
2551 <NAME>html_engine_add_object_with_id</NAME>
2552 <RETURNS>void  </RETURNS>
2553 HTMLEngine  *e,const gchar *id,HTMLObject  *obj
2554 </FUNCTION>
2555 <FUNCTION>
2556 <NAME>html_engine_get_object_by_id</NAME>
2557 <RETURNS>HTMLObject  *</RETURNS>
2558 HTMLEngine  *e,const gchar *id
2559 </FUNCTION>
2560 <FUNCTION>
2561 <NAME>html_engine_get_top_html_engine</NAME>
2562 <RETURNS>HTMLEngine  *</RETURNS>
2563 HTMLEngine *e
2564 </FUNCTION>
2565 <FUNCTION>
2566 <NAME>html_engine_thaw_idle_reset</NAME>
2567 <RETURNS>void  </RETURNS>
2568 HTMLEngine *e
2569 </FUNCTION>
2570 <MACRO>
2571 <NAME>ENTITY_NBSP</NAME>
2572 #define ENTITY_NBSP 160
2573 </MACRO>
2574 <FUNCTION>
2575 <NAME>html_entity_parse</NAME>
2576 <RETURNS>gulong  </RETURNS>
2577 const gchar *s, guint len
2578 </FUNCTION>
2579 <FUNCTION>
2580 <NAME>html_entity_prepare</NAME>
2581 <RETURNS>gchar  *</RETURNS>
2582 const gchar *s
2583 </FUNCTION>
2584 <ENUM>
2585 <NAME>HTMLButtonType</NAME>
2586 typedef enum {
2587         BUTTON_NORMAL,
2588         BUTTON_SUBMIT,
2589         BUTTON_RESET
2590 } HTMLButtonType;
2591 </ENUM>
2592 <ENUM>
2593 <NAME>HTMLChangeFlags</NAME>
2594 typedef enum {
2595         HTML_CHANGE_NONE = 0,
2596         HTML_CHANGE_MIN_WIDTH = 1 << 0,
2597         HTML_CHANGE_PREF_WIDTH = 1 << 1,
2598         HTML_CHANGE_ALL = ((HTML_CHANGE_PREF_WIDTH << 1) - 1)
2599 } HTMLChangeFlags;
2600 </ENUM>
2601 <ENUM>
2602 <NAME>HTMLClearType</NAME>
2603 typedef enum {
2604         HTML_CLEAR_NONE,
2605         HTML_CLEAR_LEFT,
2606         HTML_CLEAR_RIGHT,
2607         HTML_CLEAR_ALL
2608 } HTMLClearType;
2609 </ENUM>
2610 <ENUM>
2611 <NAME>HTMLClueFlowStyle</NAME>
2612 typedef enum {
2613         HTML_CLUEFLOW_STYLE_NORMAL,
2614         HTML_CLUEFLOW_STYLE_H1,
2615         HTML_CLUEFLOW_STYLE_H2,
2616         HTML_CLUEFLOW_STYLE_H3,
2617         HTML_CLUEFLOW_STYLE_H4,
2618         HTML_CLUEFLOW_STYLE_H5,
2619         HTML_CLUEFLOW_STYLE_H6,
2620         HTML_CLUEFLOW_STYLE_ADDRESS,
2621         HTML_CLUEFLOW_STYLE_PRE,
2622         HTML_CLUEFLOW_STYLE_ITEMDOTTED,
2623         HTML_CLUEFLOW_STYLE_ITEMROMAN,
2624         HTML_CLUEFLOW_STYLE_ITEMDIGIT,
2625         HTML_CLUEFLOW_STYLE_NOWRAP,
2626         HTML_CLUEFLOW_NUMSTYLES
2627 } HTMLClueFlowStyle;
2628 </ENUM>
2629 <ENUM>
2630 <NAME>HTMLColorId</NAME>
2631 typedef enum {
2632         HTMLBgColor = 0,
2633         HTMLTextColor,
2634         HTMLLinkColor,
2635         HTMLVLinkColor,
2636         HTMLALinkColor,
2637         HTMLHighlightColor,
2638         HTMLHighlightTextColor,
2639         HTMLSpellErrorColor,
2640
2641         HTMLColors
2642 } HTMLColorId;
2643 </ENUM>
2644 <ENUM>
2645 <NAME>HTMLEngineCursorMovement</NAME>
2646 typedef enum {
2647         HTML_ENGINE_CURSOR_UP,
2648         HTML_ENGINE_CURSOR_DOWN,
2649         HTML_ENGINE_CURSOR_RIGHT,
2650         HTML_ENGINE_CURSOR_LEFT,
2651         HTML_ENGINE_CURSOR_HOME,
2652         HTML_ENGINE_CURSOR_END,
2653         HTML_ENGINE_CURSOR_PGUP,
2654         HTML_ENGINE_CURSOR_PGDOWN
2655 } HTMLEngineCursorMovement;
2656 </ENUM>
2657 <ENUM>
2658 <NAME>HTMLEngineSetClueFlowStyleMask</NAME>
2659 typedef enum {
2660         HTML_ENGINE_SET_CLUEFLOW_NONE = 0,
2661         HTML_ENGINE_SET_CLUEFLOW_STYLE = 1 << 0,
2662         HTML_ENGINE_SET_CLUEFLOW_ALIGNMENT = 1 << 1,
2663         HTML_ENGINE_SET_CLUEFLOW_INDENTATION = 1 << 2,
2664         HTML_ENGINE_SET_CLUEFLOW_INDENTATION_DELTA = 1 << 3
2665 } HTMLEngineSetClueFlowStyleMask;
2666 </ENUM>
2667 <ENUM>
2668 <NAME>HTMLFitType</NAME>
2669 typedef enum {
2670         HTML_FIT_NONE,
2671         HTML_FIT_PARTIAL,
2672         HTML_FIT_COMPLETE
2673 } HTMLFitType;
2674 </ENUM>
2675 <ENUM>
2676 <NAME>HTMLGlossaryEntry</NAME>
2677 typedef enum {
2678         HTML_GLOSSARY_DL = 1,
2679         HTML_GLOSSARY_DD = 2
2680 } HTMLGlossaryEntry;
2681 </ENUM>
2682 <ENUM>
2683 <NAME>HTMLHAlignType</NAME>
2684 typedef enum {
2685         HTML_HALIGN_LEFT,
2686         HTML_HALIGN_CENTER,
2687         HTML_HALIGN_RIGHT,
2688         HTML_HALIGN_NONE
2689 } HTMLHAlignType;
2690 </ENUM>
2691 <ENUM>
2692 <NAME>HTMLListNumType</NAME>
2693 typedef enum {
2694         HTML_LIST_NUM_TYPE_NUMERIC,
2695         HTML_LIST_NUM_TYPE_LOWALPHA,
2696         HTML_LIST_NUM_TYPE_UPALPHA,
2697         HTML_LIST_NUM_TYPE_LOWROMAN,
2698         HTML_LIST_NUM_TYPE_UPROMAN
2699 } HTMLListNumType;
2700 </ENUM>
2701 <ENUM>
2702 <NAME>HTMLListType</NAME>
2703 typedef enum {
2704         HTML_LIST_TYPE_UNORDERED,
2705         HTML_LIST_TYPE_UNORDEREDPLAIN,
2706         HTML_LIST_TYPE_ORDERED,
2707         HTML_LIST_TYPE_MENU,
2708         HTML_LIST_TYPE_DIR
2709 } HTMLListType;
2710 </ENUM>
2711 <ENUM>
2712 <NAME>HTMLObjectFlags</NAME>
2713 typedef enum {
2714         HTML_OBJECT_FLAG_NONE = 0,
2715         HTML_OBJECT_FLAG_SEPARATOR = 1 << 0,
2716         HTML_OBJECT_FLAG_NEWLINE = 1 << 1,
2717         HTML_OBJECT_FLAG_SELECTED = 1 << 2,
2718         HTML_OBJECT_FLAG_ALLSELECTED = 1 << 3,
2719         HTML_OBJECT_FLAG_FIXEDWIDTH = 1 << 4,
2720         HTML_OBJECT_FLAG_ALIGNED = 1 << 5,
2721         HTML_OBJECT_FLAG_PRINTED = 1 << 6,
2722         HTML_OBJECT_FLAG_HIDDEN = 1 << 7
2723 } HTMLObjectFlags;
2724 </ENUM>
2725 <ENUM>
2726 <NAME>HTMLReplaceQueryAnswer</NAME>
2727 typedef enum {
2728         RQA_Replace,
2729         RQA_ReplaceAll,
2730         RQA_Next,
2731         RQA_Cancel
2732 } HTMLReplaceQueryAnswer;
2733 </ENUM>
2734 <ENUM>
2735 <NAME>HTMLType</NAME>
2736 typedef enum {
2737         HTML_TYPE_NONE,
2738         HTML_TYPE_ANCHOR,
2739         HTML_TYPE_BULLET,
2740         HTML_TYPE_BUTTON,
2741         HTML_TYPE_CHECKBOX,
2742         HTML_TYPE_CLUE,
2743         HTML_TYPE_CLUEALIGNED,
2744         HTML_TYPE_CLUEFLOW,
2745         HTML_TYPE_CLUEH,
2746         HTML_TYPE_CLUEV,
2747         HTML_TYPE_EMBEDDED,
2748         HTML_TYPE_HIDDEN,
2749         HTML_TYPE_HSPACE,
2750         HTML_TYPE_IMAGE,
2751         HTML_TYPE_IMAGEINPUT,
2752         HTML_TYPE_LINKTEXT,
2753         HTML_TYPE_OBJECT,
2754         HTML_TYPE_RADIO,
2755         HTML_TYPE_RULE,
2756         HTML_TYPE_SELECT,
2757         HTML_TYPE_TABLE,
2758         HTML_TYPE_TABLECELL,
2759         HTML_TYPE_TEXT,
2760         HTML_TYPE_TEXTAREA,
2761         HTML_TYPE_TEXTINPUT,
2762         HTML_TYPE_TEXTSLAVE,
2763         HTML_TYPE_VSPACE,
2764         HTML_TYPE_IFRAME,
2765         HTML_NUM_TYPES
2766 } HTMLType;
2767 </ENUM>
2768 <ENUM>
2769 <NAME>HTMLUndoDirection</NAME>
2770 typedef enum {
2771         HTML_UNDO_UNDO,
2772         HTML_UNDO_REDO
2773 } HTMLUndoDirection;
2774 </ENUM>
2775 <ENUM>
2776 <NAME>HTMLURLDupFlags</NAME>
2777 typedef enum {
2778         HTML_URL_DUP_ALL = 0,
2779         HTML_URL_DUP_NOPROTOCOL = 1 << 0,
2780         HTML_URL_DUP_NOUSERNAME = 1 << 1,
2781         HTML_URL_DUP_NOPASSWORD = 1 << 2,
2782         HTML_URL_DUP_NOHOSTNAME = 1 << 3,
2783         HTML_URL_DUP_NOPORT = 1 << 4,
2784         HTML_URL_DUP_NOPATH = 1 << 5,
2785         HTML_URL_DUP_NOREFERENCE = 1 << 6,
2786         HTML_URL_DUP_NOCGIARGS = 1 << 7
2787 } HTMLURLDupFlags;
2788 </ENUM>
2789 <ENUM>
2790 <NAME>HTMLVAlignType</NAME>
2791 typedef enum {
2792         HTML_VALIGN_TOP,
2793         HTML_VALIGN_CENTER,
2794         HTML_VALIGN_BOTTOM,
2795         HTML_VALIGN_NONE
2796 } HTMLVAlignType;
2797 </ENUM>
2798 <FUNCTION>
2799 <NAME>html_valign_name</NAME>
2800 <RETURNS>const gchar  *</RETURNS>
2801 HTMLVAlignType valign
2802 </FUNCTION>
2803 <FUNCTION>
2804 <NAME>html_halign_name</NAME>
2805 <RETURNS>const gchar  *</RETURNS>
2806 HTMLHAlignType halign
2807 </FUNCTION>
2808 <MACRO>
2809 <NAME>GTK_HTML_GCONF_DIR</NAME>
2810 #define GTK_HTML_GCONF_DIR "/GNOME/Documents/HTML_Editor"
2811 </MACRO>
2812 <MACRO>
2813 <NAME>GTK_HTML_GNOME_CONFIG_PREFIX</NAME>
2814 #define GTK_HTML_GNOME_CONFIG_PREFIX "/gtkhtml/Settings/"
2815 </MACRO>
2816 <MACRO>
2817 <NAME>GTK_HTML_PROPERTY</NAME>
2818 #define GTK_HTML_PROPERTY(w,p)         (GTK_HTML_CLASS (GTK_OBJECT (w)->klass)->properties-> ## p)
2819 </MACRO>
2820 <FUNCTION>
2821 <NAME>gtk_html_class_properties_new</NAME>
2822 <RETURNS>GtkHTMLClassProperties  *</RETURNS>
2823 void
2824 </FUNCTION>
2825 <FUNCTION>
2826 <NAME>gtk_html_class_properties_destroy</NAME>
2827 <RETURNS>void  </RETURNS>
2828 GtkHTMLClassProperties *p
2829 </FUNCTION>
2830 <FUNCTION>
2831 <NAME>gtk_html_class_properties_copy</NAME>
2832 <RETURNS>void  </RETURNS>
2833 GtkHTMLClassProperties *p1,GtkHTMLClassProperties *p2
2834 </FUNCTION>
2835 <FUNCTION>
2836 <NAME>gtk_html_class_properties_load</NAME>
2837 <RETURNS>void  </RETURNS>
2838 GtkHTMLClassProperties *p
2839 </FUNCTION>
2840 <FUNCTION>
2841 <NAME>gtk_html_class_properties_save</NAME>
2842 <RETURNS>void  </RETURNS>
2843 GtkHTMLClassProperties *p
2844 </FUNCTION>
2845 <MACRO>
2846 <NAME>GTK_TYPE_HTML_CURSOR_SKIP</NAME>
2847 #define GTK_TYPE_HTML_CURSOR_SKIP     (gtk_html_cursor_skip_get_type ())
2848 </MACRO>
2849 <MACRO>
2850 <NAME>GTK_TYPE_HTML_COMMAND</NAME>
2851 #define GTK_TYPE_HTML_COMMAND         (gtk_html_command_get_type ())
2852 </MACRO>
2853 <FUNCTION>
2854 <NAME>gtk_html_cursor_skip_get_type</NAME>
2855 <RETURNS>GtkType  </RETURNS>
2856 void
2857 </FUNCTION>
2858 <FUNCTION>
2859 <NAME>gtk_html_command_get_type</NAME>
2860 <RETURNS>GtkType  </RETURNS>
2861 void
2862 </FUNCTION>
2863 <MACRO>
2864 <NAME>HTML_FONT_MANAGER</NAME>
2865 #define HTML_FONT_MANAGER(x) ((HTMLFontManager *)x)
2866 </MACRO>
2867 <STRUCT>
2868 <NAME>HTMLFont</NAME>
2869 struct HTMLFont {
2870         gpointer data;
2871         guint    space_width;
2872         gint     ref_count;
2873 };
2874 </STRUCT>
2875 <STRUCT>
2876 <NAME>HTMLFontSet</NAME>
2877 struct HTMLFontSet {
2878         HTMLFont *font [GTK_HTML_FONT_STYLE_MAX_FONT];
2879         gint      ref_count;
2880         gchar    *face;
2881 };
2882 </STRUCT>
2883 <STRUCT>
2884 <NAME>HTMLFontManager</NAME>
2885 struct HTMLFontManager {
2886         HTMLPainter *painter;
2887
2888         GHashTable *font_sets;
2889         HTMLFontSet variable;
2890         HTMLFontSet fixed;
2891
2892         gint var_size;
2893         gint fix_size;
2894 };
2895 </STRUCT>
2896 <FUNCTION>
2897 <NAME>html_font_manager_init</NAME>
2898 <RETURNS>void  </RETURNS>
2899 HTMLFontManager *manager,HTMLPainter *painter
2900 </FUNCTION>
2901 <FUNCTION>
2902 <NAME>html_font_manager_finalize</NAME>
2903 <RETURNS>void  </RETURNS>
2904 HTMLFontManager *manager
2905 </FUNCTION>
2906 <FUNCTION>
2907 <NAME>html_font_manager_set_default</NAME>
2908 <RETURNS>void  </RETURNS>
2909 HTMLFontManager *manager,gchar *variable,gchar *fixed,gint var_size,gint fix_size
2910 </FUNCTION>
2911 <FUNCTION>
2912 <NAME>html_font_manager_get_font</NAME>
2913 <RETURNS>HTMLFont            *</RETURNS>
2914 HTMLFontManager *manager,gchar *face,GtkHTMLFontStyle style
2915 </FUNCTION>
2916 <FUNCTION>
2917 <NAME>html_font_new</NAME>
2918 <RETURNS>HTMLFont  *</RETURNS>
2919 gpointer     data,guint        space_width
2920 </FUNCTION>
2921 <FUNCTION>
2922 <NAME>html_font_destroy</NAME>
2923 <RETURNS>void  </RETURNS>
2924 HTMLFont    *font
2925 </FUNCTION>
2926 <FUNCTION>
2927 <NAME>html_font_ref</NAME>
2928 <RETURNS>void  </RETURNS>
2929 HTMLFont    *font,HTMLPainter *painter
2930 </FUNCTION>
2931 <FUNCTION>
2932 <NAME>html_font_unref</NAME>
2933 <RETURNS>void  </RETURNS>
2934 HTMLFont    *font,HTMLPainter *painter
2935 </FUNCTION>
2936 <MACRO>
2937 <NAME>HTML_FORM</NAME>
2938 #define HTML_FORM(x) ((HTMLForm *) (x))
2939 </MACRO>
2940 <STRUCT>
2941 <NAME>HTMLForm</NAME>
2942 struct HTMLForm {
2943
2944         gchar *action;
2945         gchar *method;
2946         GList *elements;
2947         GList *hidden;
2948
2949         /* Used by radio buttons */
2950         GSList *radio_group;
2951
2952         HTMLEngine *engine;
2953 };
2954 </STRUCT>
2955 <FUNCTION>
2956 <NAME>html_form_new</NAME>
2957 <RETURNS>HTMLForm  *</RETURNS>
2958 HTMLEngine *engine, gchar *_action, gchar *_method
2959 </FUNCTION>
2960 <FUNCTION>
2961 <NAME>html_form_add_element</NAME>
2962 <RETURNS>void  </RETURNS>
2963 HTMLForm *form, HTMLEmbedded *e
2964 </FUNCTION>
2965 <FUNCTION>
2966 <NAME>html_form_add_hidden</NAME>
2967 <RETURNS>void  </RETURNS>
2968 HTMLForm *form, HTMLHidden *h
2969 </FUNCTION>
2970 <FUNCTION>
2971 <NAME>html_form_remove_element</NAME>
2972 <RETURNS>void  </RETURNS>
2973 HTMLForm *form, HTMLEmbedded *e
2974 </FUNCTION>
2975 <FUNCTION>
2976 <NAME>html_form_submit</NAME>
2977 <RETURNS>void  </RETURNS>
2978 HTMLForm *form
2979 </FUNCTION>
2980 <FUNCTION>
2981 <NAME>html_form_reset</NAME>
2982 <RETURNS>void  </RETURNS>
2983 HTMLForm *form
2984 </FUNCTION>
2985 <FUNCTION>
2986 <NAME>html_form_destroy</NAME>
2987 <RETURNS>void  </RETURNS>
2988 HTMLForm *form
2989 </FUNCTION>
2990 <MACRO>
2991 <NAME>HTML_TYPE_GDK_PAINTER</NAME>
2992 #define HTML_TYPE_GDK_PAINTER                 (html_gdk_painter_get_type ())
2993 </MACRO>
2994 <MACRO>
2995 <NAME>HTML_GDK_PAINTER</NAME>
2996 #define HTML_GDK_PAINTER(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), HTML_TYPE_GDK_PAINTER, HTMLGdkPainter))
2997 </MACRO>
2998 <MACRO>
2999 <NAME>HTML_GDK_PAINTER_CLASS</NAME>
3000 #define HTML_GDK_PAINTER_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), HTML_TYPE_GDK_PAINTER, HTMLGdkPainterClass))
3001 </MACRO>
3002 <MACRO>
3003 <NAME>HTML_IS_GDK_PAINTER</NAME>
3004 #define HTML_IS_GDK_PAINTER(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), HTML_TYPE_GDK_PAINTER))
3005 </MACRO>
3006 <MACRO>
3007 <NAME>HTML_IS_GDK_PAINTER_CLASS</NAME>
3008 #define HTML_IS_GDK_PAINTER_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), HTML_TYPE_GDK_PAINTER))
3009 </MACRO>
3010 <STRUCT>
3011 <NAME>HTMLGdkPainter</NAME>
3012 struct HTMLGdkPainter {
3013         HTMLPainter base;
3014
3015         /* GdkWindow to draw on */
3016         GdkWindow *window;
3017
3018         /* The current GC used.  */
3019         GdkGC *gc;
3020
3021         /* For the double-buffering system.  */
3022         gboolean double_buffer;
3023         GdkPixmap *pixmap;
3024         gint x1, y1, x2, y2;
3025         GdkColor background;
3026         gboolean set_background;
3027         gboolean do_clear;
3028         gboolean alpha;
3029
3030         /* Colors used for shading.  */
3031         GdkColor dark;
3032         GdkColor light;
3033         GdkColor black;
3034 };
3035 </STRUCT>
3036 <FUNCTION>
3037 <NAME>html_gdk_painter_get_type</NAME>
3038 <RETURNS>GtkType  </RETURNS>
3039 void
3040 </FUNCTION>
3041 <FUNCTION>
3042 <NAME>html_gdk_painter_new</NAME>
3043 <RETURNS>HTMLPainter  *</RETURNS>
3044 gboolean        double_buffer
3045 </FUNCTION>
3046 <FUNCTION>
3047 <NAME>html_gdk_painter_realize</NAME>
3048 <RETURNS>void  </RETURNS>
3049 HTMLGdkPainter *painter,GdkWindow      *window
3050 </FUNCTION>
3051 <FUNCTION>
3052 <NAME>html_gdk_painter_unrealize</NAME>
3053 <RETURNS>void  </RETURNS>
3054 HTMLGdkPainter *painter
3055 </FUNCTION>
3056 <FUNCTION>
3057 <NAME>html_gdk_painter_realized</NAME>
3058 <RETURNS>gboolean  </RETURNS>
3059 HTMLGdkPainter *painter
3060 </FUNCTION>
3061 <MACRO>
3062 <NAME>HTML_HIDDEN</NAME>
3063 #define HTML_HIDDEN(x) ((HTMLHidden *) (x))
3064 </MACRO>
3065 <MACRO>
3066 <NAME>HTML_HIDDEN_CLASS</NAME>
3067 #define HTML_HIDDEN_CLASS(x) ((HTMLHiddenClass *) (x))
3068 </MACRO>
3069 <STRUCT>
3070 <NAME>HTMLHidden</NAME>
3071 struct HTMLHidden {
3072         HTMLEmbedded element;
3073 };
3074 </STRUCT>
3075 <VARIABLE>
3076 <NAME>html_hidden_class</NAME>
3077 extern HTMLHiddenClass html_hidden_class;
3078 </VARIABLE>
3079 <FUNCTION>
3080 <NAME>html_hidden_type_init</NAME>
3081 <RETURNS>void  </RETURNS>
3082 void
3083 </FUNCTION>
3084 <FUNCTION>
3085 <NAME>html_hidden_class_init</NAME>
3086 <RETURNS>void  </RETURNS>
3087 HTMLHiddenClass *klass,HTMLType         type,guint            object_size
3088 </FUNCTION>
3089 <FUNCTION>
3090 <NAME>html_hidden_init</NAME>
3091 <RETURNS>void  </RETURNS>
3092 HTMLHidden      *hidden,HTMLHiddenClass *klass,gchar           *name,gchar           *value
3093 </FUNCTION>
3094 <FUNCTION>
3095 <NAME>html_hidden_new</NAME>
3096 <RETURNS>HTMLObject  *</RETURNS>
3097 gchar           *name,gchar           *value
3098 </FUNCTION>
3099 <MACRO>
3100 <NAME>HTML_HSPACE</NAME>
3101 #define HTML_HSPACE(x) ((HTMLHSpace *)(x))
3102 </MACRO>
3103 <MACRO>
3104 <NAME>HTML_HSPACE_CLASS</NAME>
3105 #define HTML_HSPACE_CLASS(x) ((HTMLHSpaceClass *)(x))
3106 </MACRO>
3107 <STRUCT>
3108 <NAME>HTMLHSpace</NAME>
3109 struct HTMLHSpace {
3110         HTMLObject object;
3111
3112         /* FIXME!!!  WHY!?!?!?  Shouldn't we use the one from HTMLObject???  */
3113         HTMLFont *font;
3114 };
3115 </STRUCT>
3116 <VARIABLE>
3117 <NAME>html_hspace_class</NAME>
3118 extern HTMLHSpaceClass html_hspace_class;
3119 </VARIABLE>
3120 <FUNCTION>
3121 <NAME>html_hspace_type_init</NAME>
3122 <RETURNS>void  </RETURNS>
3123 void
3124 </FUNCTION>
3125 <FUNCTION>
3126 <NAME>html_hspace_class_init</NAME>
3127 <RETURNS>void  </RETURNS>
3128 HTMLHSpaceClass *klass,HTMLType         type,guint            object_size
3129 </FUNCTION>
3130 <FUNCTION>
3131 <NAME>html_hspace_init</NAME>
3132 <RETURNS>void  </RETURNS>
3133 HTMLHSpace      *hspace,HTMLHSpaceClass *klass,HTMLFont        *font,gboolean         hidden
3134 </FUNCTION>
3135 <FUNCTION>
3136 <NAME>html_hspace_new</NAME>
3137 <RETURNS>HTMLObject  *</RETURNS>
3138 HTMLFont        *font,gboolean         hidden
3139 </FUNCTION>
3140 <MACRO>
3141 <NAME>HTML_IFRAME</NAME>
3142 #define HTML_IFRAME(x) ((HTMLIFrame *)(x))
3143 </MACRO>
3144 <MACRO>
3145 <NAME>HTML_IFRAME_CLASS</NAME>
3146 #define HTML_IFRAME_CLASS(x) ((HTMLIFrameClass *)(x))
3147 </MACRO>
3148 <STRUCT>
3149 <NAME>HTMLIFrame</NAME>
3150 struct HTMLIFrame {
3151         HTMLEmbedded embedded;
3152
3153         char *url;
3154         GtkWidget *scroll;
3155         GtkWidget *html;
3156         HTMLPainter *gdk_painter;
3157         gint width;
3158         gint height;
3159         gboolean frameborder;
3160 };
3161 </STRUCT>
3162 <FUNCTION>
3163 <NAME>html_iframe_type_init</NAME>
3164 <RETURNS>void  </RETURNS>
3165 void
3166 </FUNCTION>
3167 <FUNCTION>
3168 <NAME>html_iframe_class_init</NAME>
3169 <RETURNS>void  </RETURNS>
3170 HTMLIFrameClass *klass,HTMLType           type,guint              object_size
3171 </FUNCTION>
3172 <FUNCTION>
3173 <NAME>html_iframe_init</NAME>
3174 <RETURNS>void  </RETURNS>
3175 HTMLIFrame        *iframe,HTMLIFrameClass   *klass,GtkWidget         *parent,char              *url,gint               width,gint               height,gboolean           border
3176 </FUNCTION>
3177 <FUNCTION>
3178 <NAME>html_iframe_new</NAME>
3179 <RETURNS>HTMLObject  *</RETURNS>
3180 GtkWidget *parent,char *src,gint width,gint height,gboolean border
3181 </FUNCTION>
3182 <STRUCT>
3183 <NAME>HTMLImagePointer</NAME>
3184 struct HTMLImagePointer {
3185         gint refcount;
3186         gchar *url;
3187         GdkPixbufLoader *loader;
3188         GdkPixbuf *pixbuf;
3189         GdkPixbufAnimation *animation;
3190         GSList *interests; /* A list of HTMLImage's, or a NULL pointer for the background pixmap */
3191         HTMLImageFactory *factory;
3192         gint stall;
3193         guint stall_timeout;
3194 };
3195 </STRUCT>
3196 <STRUCT>
3197 <NAME>HTMLImageAnimation</NAME>
3198 struct HTMLImageAnimation {
3199         /* stuff for animated image */
3200         /* draw coordination */
3201         gint x;
3202         gint y;
3203
3204         /* remember engine offset */
3205         gint ex, ey;
3206
3207         /* current frame */
3208         GList *cur_frame;
3209         gint cur_n;
3210
3211         /* animation timeout function */
3212         gint timeout;
3213
3214         /* helper buffer */
3215         GdkPixbuf *pixbuf;
3216
3217         /* active draw flag */
3218         gint active;
3219 };
3220 </STRUCT>
3221 <MACRO>
3222 <NAME>HTML_IMAGE</NAME>
3223 #define HTML_IMAGE(x) ((HTMLImage *)(x))
3224 </MACRO>
3225 <MACRO>
3226 <NAME>HTML_IMAGE_POINTER</NAME>
3227 #define HTML_IMAGE_POINTER(x) ((HTMLImagePointer *)(x))
3228 </MACRO>
3229 <STRUCT>
3230 <NAME>HTMLImage</NAME>
3231 struct HTMLImage {
3232         HTMLObject object;
3233         HTMLImagePointer *image_ptr;
3234         HTMLImageAnimation *animation;
3235
3236         HTMLColor *color;
3237
3238         guint have_color: 1;
3239
3240         gint8 border;
3241
3242         gint16 specified_width;
3243         gint16 specified_height;
3244         gboolean percent_width;
3245         gboolean percent_height;
3246
3247         gint8 hspace;
3248         gint8 vspace;
3249
3250         HTMLVAlignType valign;
3251
3252         gchar *url;
3253         gchar *target;
3254         gchar *alt;
3255 };
3256 </STRUCT>
3257 <VARIABLE>
3258 <NAME>image_class</NAME>
3259 extern HTMLImageClass image_class;
3260 </VARIABLE>
3261 <FUNCTION>
3262 <NAME>html_image_type_init</NAME>
3263 <RETURNS>void  </RETURNS>
3264 void
3265 </FUNCTION>
3266 <FUNCTION>
3267 <NAME>html_image_class_init</NAME>
3268 <RETURNS>void  </RETURNS>
3269 HTMLImageClass   *klass,HTMLType          type,guint             object_size
3270 </FUNCTION>
3271 <FUNCTION>
3272 <NAME>html_image_init</NAME>
3273 <RETURNS>void  </RETURNS>
3274 HTMLImage        *image,HTMLImageClass   *klass,HTMLImageFactory *imf,const gchar      *filename,const gchar      *url,const gchar      *target,gint16            width,gint16            height,gboolean          percent_width,gboolean          percent_height,gint8             border,HTMLColor        *border_color,HTMLVAlignType    valign
3275 </FUNCTION>
3276 <FUNCTION>
3277 <NAME>html_image_new</NAME>
3278 <RETURNS>HTMLObject  *</RETURNS>
3279 HTMLImageFactory *imf,const gchar      *filename,const gchar      *url,const gchar      *target,gint16            width,gint16            height,gboolean          percent_width,gboolean          percent_height,gint8             border,HTMLColor        *border_color,HTMLVAlignType    valign
3280 </FUNCTION>
3281 <FUNCTION>
3282 <NAME>html_image_set_size</NAME>
3283 <RETURNS>void  </RETURNS>
3284 HTMLImage        *image,gint              w,gint              h,gboolean          pw,gboolean          ph
3285 </FUNCTION>
3286 <FUNCTION>
3287 <NAME>html_image_set_spacing</NAME>
3288 <RETURNS>void  </RETURNS>
3289 HTMLImage        *image,gint              hspace,gint              vspace
3290 </FUNCTION>
3291 <FUNCTION>
3292 <NAME>html_image_set_url</NAME>
3293 <RETURNS>void  </RETURNS>
3294 HTMLImage        *image,const gchar      *url
3295 </FUNCTION>
3296 <FUNCTION>
3297 <NAME>html_image_set_valign</NAME>
3298 <RETURNS>void  </RETURNS>
3299 HTMLImage        *image,HTMLVAlignType    valign
3300 </FUNCTION>
3301 <FUNCTION>
3302 <NAME>html_image_set_border</NAME>
3303 <RETURNS>void  </RETURNS>
3304 HTMLImage        *image,gint              border
3305 </FUNCTION>
3306 <FUNCTION>
3307 <NAME>html_image_set_alt</NAME>
3308 <RETURNS>void  </RETURNS>
3309 HTMLImage        *image,gchar            *alt
3310 </FUNCTION>
3311 <FUNCTION>
3312 <NAME>html_image_resolve_image_url</NAME>
3313 <RETURNS>gchar       *</RETURNS>
3314 GtkHTML          *html,gchar            *image_url
3315 </FUNCTION>
3316 <FUNCTION>
3317 <NAME>html_image_factory_new</NAME>
3318 <RETURNS>HTMLImageFactory  *</RETURNS>
3319 HTMLEngine       *e
3320 </FUNCTION>
3321 <FUNCTION>
3322 <NAME>html_image_factory_free</NAME>
3323 <RETURNS>void  </RETURNS>
3324 HTMLImageFactory *factory
3325 </FUNCTION>
3326 <FUNCTION>
3327 <NAME>html_image_factory_cleanup</NAME>
3328 <RETURNS>void  </RETURNS>
3329 HTMLImageFactory *factory
3330 </FUNCTION>
3331 <FUNCTION>
3332 <NAME>html_image_factory_stop_animations</NAME>
3333 <RETURNS>void  </RETURNS>
3334 HTMLImageFactory *factory
3335 </FUNCTION>
3336 <FUNCTION>
3337 <NAME>html_image_factory_deactivate_animations</NAME>
3338 <RETURNS>void  </RETURNS>
3339 HTMLImageFactory *factory
3340 </FUNCTION>
3341 <FUNCTION>
3342 <NAME>html_image_factory_register</NAME>
3343 <RETURNS>HTMLImagePointer  *</RETURNS>
3344 HTMLImageFactory *factory,HTMLImage        *i,const char       *filename
3345 </FUNCTION>
3346 <FUNCTION>
3347 <NAME>html_image_factory_unregister</NAME>
3348 <RETURNS>void  </RETURNS>
3349 HTMLImageFactory *factory,HTMLImagePointer *pointer,HTMLImage        *i
3350 </FUNCTION>
3351 <MACRO>
3352 <NAME>HTML_IMAGEINPUT</NAME>
3353 #define HTML_IMAGEINPUT(x) ((HTMLImageInput *) (x))
3354 </MACRO>
3355 <MACRO>
3356 <NAME>HTML_IMAGEINPUT_CLASS</NAME>
3357 #define HTML_IMAGEINPUT_CLASS(x) ((HTMLImageInputClass *) (x))
3358 </MACRO>
3359 <STRUCT>
3360 <NAME>HTMLImageInput</NAME>
3361 struct HTMLImageInput {
3362         HTMLEmbedded element;
3363
3364         HTMLImage *image;
3365         gint m_x, m_y;
3366 };
3367 </STRUCT>
3368 <VARIABLE>
3369 <NAME>html_imageinput_class</NAME>
3370 extern HTMLImageInputClass html_imageinput_class;
3371 </VARIABLE>
3372 <FUNCTION>
3373 <NAME>html_imageinput_type_init</NAME>
3374 <RETURNS>void  </RETURNS>
3375 void
3376 </FUNCTION>
3377 <FUNCTION>
3378 <NAME>html_imageinput_class_init</NAME>
3379 <RETURNS>void  </RETURNS>
3380 HTMLImageInputClass *klass,HTMLType             type,guint                object_size
3381 </FUNCTION>
3382 <FUNCTION>
3383 <NAME>html_imageinput_init</NAME>
3384 <RETURNS>void  </RETURNS>
3385 HTMLImageInput      *img,HTMLImageInputClass *klass,HTMLImageFactory    *imf,gchar               *name,gchar               *url
3386 </FUNCTION>
3387 <FUNCTION>
3388 <NAME>html_imageinput_new</NAME>
3389 <RETURNS>HTMLObject  *</RETURNS>
3390 HTMLImageFactory    *imf,gchar               *name,gchar               *url
3391 </FUNCTION>
3392 <STRUCT>
3393 <NAME>HTMLPoint</NAME>
3394 struct HTMLPoint {
3395         HTMLObject *object;
3396         guint       offset;
3397 };
3398 </STRUCT>
3399 <FUNCTION>
3400 <NAME>html_point_new</NAME>
3401 <RETURNS>HTMLPoint  *</RETURNS>
3402 HTMLObject      *o,guint            off
3403 </FUNCTION>
3404 <FUNCTION>
3405 <NAME>html_point_construct</NAME>
3406 <RETURNS>void  </RETURNS>
3407 HTMLPoint       *p,HTMLObject      *o,guint            off
3408 </FUNCTION>
3409 <FUNCTION>
3410 <NAME>html_point_destroy</NAME>
3411 <RETURNS>void  </RETURNS>
3412 HTMLPoint       *p
3413 </FUNCTION>
3414 <FUNCTION>
3415 <NAME>html_point_max</NAME>
3416 <RETURNS>HTMLPoint  *</RETURNS>
3417 HTMLPoint       *a,HTMLPoint       *b
3418 </FUNCTION>
3419 <FUNCTION>
3420 <NAME>html_point_min</NAME>
3421 <RETURNS>HTMLPoint  *</RETURNS>
3422 HTMLPoint       *a,HTMLPoint       *b
3423 </FUNCTION>
3424 <FUNCTION>
3425 <NAME>html_point_eq</NAME>
3426 <RETURNS>gboolean  </RETURNS>
3427 const HTMLPoint *a,const HTMLPoint *b
3428 </FUNCTION>
3429 <STRUCT>
3430 <NAME>HTMLInterval</NAME>
3431 struct HTMLInterval {
3432         HTMLPoint from;
3433         HTMLPoint to;
3434 };
3435 </STRUCT>
3436 <FUNCTION>
3437 <NAME>html_interval_new</NAME>
3438 <RETURNS>HTMLInterval  *</RETURNS>
3439 HTMLObject            *from,HTMLObject            *to,guint                  from_offset,guint                  to_offset
3440 </FUNCTION>
3441 <FUNCTION>
3442 <NAME>html_interval_new_from_cursor</NAME>
3443 <RETURNS>HTMLInterval  *</RETURNS>
3444 HTMLCursor            *a,HTMLCursor            *b
3445 </FUNCTION>
3446 <FUNCTION>
3447 <NAME>html_interval_new_from_points</NAME>
3448 <RETURNS>HTMLInterval  *</RETURNS>
3449 HTMLPoint             *from,HTMLPoint             *to
3450 </FUNCTION>
3451 <FUNCTION>
3452 <NAME>html_interval_validate</NAME>
3453 <RETURNS>void  </RETURNS>
3454 HTMLInterval          *i
3455 </FUNCTION>
3456 <FUNCTION>
3457 <NAME>html_interval_destroy</NAME>
3458 <RETURNS>void  </RETURNS>
3459 HTMLInterval          *i
3460 </FUNCTION>
3461 <FUNCTION>
3462 <NAME>html_interval_get_length</NAME>
3463 <RETURNS>guint  </RETURNS>
3464 HTMLInterval          *i,HTMLObject            *obj
3465 </FUNCTION>
3466 <FUNCTION>
3467 <NAME>html_interval_get_bytes</NAME>
3468 <RETURNS>guint  </RETURNS>
3469 HTMLInterval          *i,HTMLObject            *obj
3470 </FUNCTION>
3471 <FUNCTION>
3472 <NAME>html_interval_get_start</NAME>
3473 <RETURNS>guint  </RETURNS>
3474 HTMLInterval          *i,HTMLObject            *obj
3475 </FUNCTION>
3476 <FUNCTION>
3477 <NAME>html_interval_get_start_index</NAME>
3478 <RETURNS>guint  </RETURNS>
3479 HTMLInterval          *i,HTMLObject            *obj
3480 </FUNCTION>
3481 <FUNCTION>
3482 <NAME>html_interval_get_head</NAME>
3483 <RETURNS>HTMLObject  *</RETURNS>
3484 HTMLInterval          *i,HTMLObject            *o
3485 </FUNCTION>
3486 <FUNCTION>
3487 <NAME>html_interval_select</NAME>
3488 <RETURNS>void  </RETURNS>
3489 HTMLInterval          *i,HTMLEngine            *e
3490 </FUNCTION>
3491 <FUNCTION>
3492 <NAME>html_interval_unselect</NAME>
3493 <RETURNS>void  </RETURNS>
3494 HTMLInterval          *i,HTMLEngine            *e
3495 </FUNCTION>
3496 <FUNCTION>
3497 <NAME>html_interval_get_from_index</NAME>
3498 <RETURNS>gint  </RETURNS>
3499 HTMLInterval          *i
3500 </FUNCTION>
3501 <FUNCTION>
3502 <NAME>html_interval_get_to_index</NAME>
3503 <RETURNS>gint  </RETURNS>
3504 HTMLInterval          *i
3505 </FUNCTION>
3506 <FUNCTION>
3507 <NAME>html_interval_forall</NAME>
3508 <RETURNS>void  </RETURNS>
3509 HTMLInterval          *i,HTMLEngine            *e,HTMLObjectForallFunc   f,gpointer               data
3510 </FUNCTION>
3511 <FUNCTION>
3512 <NAME>html_interval_eq</NAME>
3513 <RETURNS>gboolean  </RETURNS>
3514 const HTMLInterval    *a,const HTMLInterval    *b
3515 </FUNCTION>
3516 <FUNCTION>
3517 <NAME>html_interval_intersection</NAME>
3518 <RETURNS>HTMLInterval  *</RETURNS>
3519 HTMLInterval          *a,HTMLInterval          *b
3520 </FUNCTION>
3521 <FUNCTION>
3522 <NAME>html_interval_substract</NAME>
3523 <RETURNS>void          *</RETURNS>
3524 HTMLInterval          *a,HTMLInterval          *b,HTMLInterval         **s1,HTMLInterval         **s2
3525 </FUNCTION>
3526 <MACRO>
3527 <NAME>HTML_LINK_TEXT</NAME>
3528 #define HTML_LINK_TEXT(x) ((HTMLLinkText *)(x))
3529 </MACRO>
3530 <MACRO>
3531 <NAME>HTML_LINK_TEXT_CLASS</NAME>
3532 #define HTML_LINK_TEXT_CLASS(x) ((HTMLLinkTextClass *)(x))
3533 </MACRO>
3534 <STRUCT>
3535 <NAME>HTMLLinkText</NAME>
3536 struct HTMLLinkText {
3537         HTMLText text;
3538
3539         gchar *url;
3540         gchar *target;
3541 };
3542 </STRUCT>
3543 <VARIABLE>
3544 <NAME>html_link_text_class</NAME>
3545 extern HTMLLinkTextClass html_link_text_class;
3546 </VARIABLE>
3547 <FUNCTION>
3548 <NAME>html_link_text_type_init</NAME>
3549 <RETURNS>void  </RETURNS>
3550 void
3551 </FUNCTION>
3552 <FUNCTION>
3553 <NAME>html_link_text_class_init</NAME>
3554 <RETURNS>void  </RETURNS>
3555 HTMLLinkTextClass *klass,HTMLType           type,guint              object_size
3556 </FUNCTION>
3557 <FUNCTION>
3558 <NAME>html_link_text_init</NAME>
3559 <RETURNS>void  </RETURNS>
3560 HTMLLinkText      *link_text_,HTMLLinkTextClass *klass,const gchar       *text,gint               len,GtkHTMLFontStyle   font_style,HTMLColor         *color,const gchar       *url,const gchar       *target
3561 </FUNCTION>
3562 <FUNCTION>
3563 <NAME>html_link_text_new</NAME>
3564 <RETURNS>HTMLObject  *</RETURNS>
3565 const gchar       *text,GtkHTMLFontStyle   font_style,HTMLColor         *color,const gchar       *url,const gchar       *target
3566 </FUNCTION>
3567 <FUNCTION>
3568 <NAME>html_link_text_new_with_len</NAME>
3569 <RETURNS>HTMLObject  *</RETURNS>
3570 const gchar       *text,gint               len,GtkHTMLFontStyle   font_style,HTMLColor         *color,const gchar       *url,const gchar       *target
3571 </FUNCTION>
3572 <FUNCTION>
3573 <NAME>html_link_text_set_url</NAME>
3574 <RETURNS>void  </RETURNS>
3575 HTMLLinkText      *link,const gchar       *url
3576 </FUNCTION>
3577 <FUNCTION>
3578 <NAME>html_link_text_to_text</NAME>
3579 <RETURNS>void  </RETURNS>
3580 HTMLLinkText      *link,HTMLEngine        *e
3581 </FUNCTION>
3582 <STRUCT>
3583 <NAME>HTMLList</NAME>
3584 struct HTMLList {
3585         HTMLListType type;
3586         HTMLListNumType numType;
3587         gint itemNumber;
3588 };
3589 </STRUCT>
3590 <FUNCTION>
3591 <NAME>html_list_new</NAME>
3592 <RETURNS>HTMLList  *</RETURNS>
3593 HTMLListType t, HTMLListNumType nt
3594 </FUNCTION>
3595 <FUNCTION>
3596 <NAME>html_list_destroy</NAME>
3597 <RETURNS>void  </RETURNS>
3598 HTMLList *list
3599 </FUNCTION>
3600 <MACRO>
3601 <NAME>HTML_OBJECT</NAME>
3602 #define HTML_OBJECT(x)          ((HTMLObject *) (x))
3603 </MACRO>
3604 <MACRO>
3605 <NAME>HTML_OBJECT_CLASS</NAME>
3606 #define HTML_OBJECT_CLASS(x)    ((HTMLObjectClass *) (x))
3607 </MACRO>
3608 <MACRO>
3609 <NAME>HTML_OBJECT_TYPE</NAME>
3610 #define HTML_OBJECT_TYPE(x)     (HTML_OBJECT (x)->klass->type)
3611 </MACRO>
3612 <STRUCT>
3613 <NAME>HTMLObject</NAME>
3614 struct HTMLObject {
3615         HTMLObjectClass *klass;
3616
3617         /* Pointer to the parent object.  */
3618         HTMLObject *parent;
3619
3620         HTMLObject *prev;
3621         HTMLObject *next;
3622
3623         HTMLChangeFlags change;
3624
3625         gint x, y;
3626
3627         gint ascent, descent;
3628
3629         gint min_width;
3630         gint width;
3631         gint pref_width;
3632         gint max_width;
3633
3634         gint percent;
3635
3636         guchar flags;
3637
3638         /* FIXME maybe unify with `flags'?  */
3639         guint redraw_pending : 1;
3640         guint selected : 1;
3641
3642         /* If an object has a redraw pending and is being destroyed, this flag
3643            is set to TRUE instead of g_free()ing the object.  When the draw
3644            queue is flushed, the g_free() is performed.  */
3645         guint free_pending : 1;
3646
3647         GData *object_data;
3648 };
3649 </STRUCT>
3650 <VARIABLE>
3651 <NAME>html_object_class</NAME>
3652 extern HTMLObjectClass html_object_class;
3653 </VARIABLE>
3654 <FUNCTION>
3655 <NAME>html_object_type_init</NAME>
3656 <RETURNS>void  </RETURNS>
3657 void
3658 </FUNCTION>
3659 <FUNCTION>
3660 <NAME>html_object_init</NAME>
3661 <RETURNS>void  </RETURNS>
3662 HTMLObject            *self,HTMLObjectClass       *klass
3663 </FUNCTION>
3664 <FUNCTION>
3665 <NAME>html_object_class_init</NAME>
3666 <RETURNS>void  </RETURNS>
3667 HTMLObjectClass       *klass,HTMLType               type,guint                  object_size
3668 </FUNCTION>
3669 <FUNCTION>
3670 <NAME>html_object_new</NAME>
3671 <RETURNS>HTMLObject      *</RETURNS>
3672 HTMLObject            *parent
3673 </FUNCTION>
3674 <FUNCTION>
3675 <NAME>html_object_destroy</NAME>
3676 <RETURNS>void  </RETURNS>
3677 HTMLObject            *self
3678 </FUNCTION>
3679 <FUNCTION>
3680 <NAME>html_object_copy</NAME>
3681 <RETURNS>void  </RETURNS>
3682 HTMLObject            *self,HTMLObject            *dest
3683 </FUNCTION>
3684 <FUNCTION>
3685 <NAME>html_object_dup</NAME>
3686 <RETURNS>HTMLObject      *</RETURNS>
3687 HTMLObject            *self
3688 </FUNCTION>
3689 <FUNCTION>
3690 <NAME>html_object_op_copy</NAME>
3691 <RETURNS>HTMLObject      *</RETURNS>
3692 HTMLObject            *self,HTMLEngine            *e,GList                 *from,GList                 *to,guint                 *len
3693 </FUNCTION>
3694 <FUNCTION>
3695 <NAME>html_object_op_cut</NAME>
3696 <RETURNS>HTMLObject      *</RETURNS>
3697 HTMLObject            *self,HTMLEngine            *e,GList                 *from,GList                 *to,GList                 *left,GList                 *right,guint                 *len
3698 </FUNCTION>
3699 <FUNCTION>
3700 <NAME>html_object_merge</NAME>
3701 <RETURNS>gboolean  </RETURNS>
3702 HTMLObject            *self,HTMLObject            *with,HTMLEngine            *e
3703 </FUNCTION>
3704 <FUNCTION>
3705 <NAME>html_object_remove_child</NAME>
3706 <RETURNS>void  </RETURNS>
3707 HTMLObject            *self,HTMLObject            *child
3708 </FUNCTION>
3709 <FUNCTION>
3710 <NAME>html_object_split</NAME>
3711 <RETURNS>void  </RETURNS>
3712 HTMLObject            *self,HTMLEngine            *e,HTMLObject            *child,gint                   offset,gint                   level,GList                **left,GList                **right
3713 </FUNCTION>
3714 <FUNCTION>
3715 <NAME>html_object_set_parent</NAME>
3716 <RETURNS>void  </RETURNS>
3717 HTMLObject            *self,HTMLObject            *parent
3718 </FUNCTION>
3719 <FUNCTION>
3720 <NAME>html_object_get_left_margin</NAME>
3721 <RETURNS>gint  </RETURNS>
3722 HTMLObject            *self,gint                   y
3723 </FUNCTION>
3724 <FUNCTION>
3725 <NAME>html_object_get_right_margin</NAME>
3726 <RETURNS>gint  </RETURNS>
3727 HTMLObject            *self,gint                   y
3728 </FUNCTION>
3729 <FUNCTION>
3730 <NAME>html_object_set_painter</NAME>
3731 <RETURNS>void  </RETURNS>
3732 HTMLObject            *o,HTMLPainter           *p,gint                   max_width
3733 </FUNCTION>
3734 <FUNCTION>
3735 <NAME>html_object_clear_word_width</NAME>
3736 <RETURNS>void  </RETURNS>
3737 HTMLObject            *o
3738 </FUNCTION>
3739 <FUNCTION>
3740 <NAME>html_object_reset</NAME>
3741 <RETURNS>void  </RETURNS>
3742 HTMLObject            *o
3743 </FUNCTION>
3744 <FUNCTION>
3745 <NAME>html_object_is_text</NAME>
3746 <RETURNS>gboolean  </RETURNS>
3747 HTMLObject            *object
3748 </FUNCTION>
3749 <FUNCTION>
3750 <NAME>html_object_get_engine</NAME>
3751 <RETURNS>HTMLEngine      *</RETURNS>
3752 HTMLObject            *self,HTMLEngine            *e
3753 </FUNCTION>
3754 <FUNCTION>
3755 <NAME>html_object_forall</NAME>
3756 <RETURNS>void  </RETURNS>
3757 HTMLObject            *self,HTMLEngine            *e,HTMLObjectForallFunc   func,gpointer               data
3758 </FUNCTION>
3759 <FUNCTION>
3760 <NAME>html_object_is_container</NAME>
3761 <RETURNS>gboolean  </RETURNS>
3762 HTMLObject            *self
3763 </FUNCTION>
3764 <FUNCTION>
3765 <NAME>html_object_next_not_type</NAME>
3766 <RETURNS>HTMLObject      *</RETURNS>
3767 HTMLObject            *self,HTMLType               t
3768 </FUNCTION>
3769 <FUNCTION>
3770 <NAME>html_object_prev_not_type</NAME>
3771 <RETURNS>HTMLObject      *</RETURNS>
3772 HTMLObject            *self,HTMLType               t
3773 </FUNCTION>
3774 <FUNCTION>
3775 <NAME>html_object_next_not_slave</NAME>
3776 <RETURNS>HTMLObject      *</RETURNS>
3777 HTMLObject            *self
3778 </FUNCTION>
3779 <FUNCTION>
3780 <NAME>html_object_prev_not_slave</NAME>
3781 <RETURNS>HTMLObject      *</RETURNS>
3782 HTMLObject            *self
3783 </FUNCTION>
3784 <FUNCTION>
3785 <NAME>html_object_next_by_type</NAME>
3786 <RETURNS>HTMLObject      *</RETURNS>
3787 HTMLObject            *self,HTMLType               t
3788 </FUNCTION>
3789 <FUNCTION>
3790 <NAME>html_object_prev_by_type</NAME>
3791 <RETURNS>HTMLObject      *</RETURNS>
3792 HTMLObject            *self,HTMLType               t
3793 </FUNCTION>
3794 <FUNCTION>
3795 <NAME>html_object_search</NAME>
3796 <RETURNS>gboolean  </RETURNS>
3797 HTMLObject            *self,HTMLSearch            *info
3798 </FUNCTION>
3799 <FUNCTION>
3800 <NAME>html_object_search_next</NAME>
3801 <RETURNS>gboolean  </RETURNS>
3802 HTMLObject            *self,HTMLSearch            *info
3803 </FUNCTION>
3804 <FUNCTION>
3805 <NAME>html_object_draw</NAME>
3806 <RETURNS>void  </RETURNS>
3807 HTMLObject            *o,HTMLPainter           *p,gint                   x,gint                   y,gint                   width,gint                   height,gint                   tx,gint                   ty
3808 </FUNCTION>
3809 <FUNCTION>
3810 <NAME>html_object_draw_background</NAME>
3811 <RETURNS>void  </RETURNS>
3812 HTMLObject            *o,HTMLPainter           *p,gint                   x,gint                   y,gint                   width,gint                   height,gint                   tx,gint                   ty
3813 </FUNCTION>
3814 <FUNCTION>
3815 <NAME>html_object_set_bg_color</NAME>
3816 <RETURNS>void  </RETURNS>
3817 HTMLObject            *o,GdkColor              *color
3818 </FUNCTION>
3819 <FUNCTION>
3820 <NAME>html_object_get_bg_color</NAME>
3821 <RETURNS>GdkColor        *</RETURNS>
3822 HTMLObject            *o,HTMLPainter           *p
3823 </FUNCTION>
3824 <FUNCTION>
3825 <NAME>html_object_is_transparent</NAME>
3826 <RETURNS>gboolean  </RETURNS>
3827 HTMLObject            *self
3828 </FUNCTION>
3829 <FUNCTION>
3830 <NAME>html_object_fit_line</NAME>
3831 <RETURNS>HTMLFitType  </RETURNS>
3832 HTMLObject            *o,HTMLPainter           *painter,gboolean               start_of_line,gboolean               first_run,gint                   width_left
3833 </FUNCTION>
3834 <FUNCTION>
3835 <NAME>html_object_calc_size</NAME>
3836 <RETURNS>gboolean  </RETURNS>
3837 HTMLObject            *o,HTMLPainter           *painter
3838 </FUNCTION>
3839 <FUNCTION>
3840 <NAME>html_object_set_max_ascent</NAME>
3841 <RETURNS>void  </RETURNS>
3842 HTMLObject            *o,HTMLPainter           *painter,gint                   a
3843 </FUNCTION>
3844 <FUNCTION>
3845 <NAME>html_object_set_max_descent</NAME>
3846 <RETURNS>void  </RETURNS>
3847 HTMLObject            *o,HTMLPainter           *painter,gint                   d
3848 </FUNCTION>
3849 <FUNCTION>
3850 <NAME>html_object_set_max_width</NAME>
3851 <RETURNS>void  </RETURNS>
3852 HTMLObject            *o,HTMLPainter           *painter,gint                   max_width
3853 </FUNCTION>
3854 <FUNCTION>
3855 <NAME>html_object_calc_min_width</NAME>
3856 <RETURNS>gint  </RETURNS>
3857 HTMLObject            *o,HTMLPainter           *painter
3858 </FUNCTION>
3859 <FUNCTION>
3860 <NAME>html_object_calc_preferred_width</NAME>
3861 <RETURNS>gint  </RETURNS>
3862 HTMLObject            *o,HTMLPainter           *painter
3863 </FUNCTION>
3864 <FUNCTION>
3865 <NAME>html_object_calc_abs_position</NAME>
3866 <RETURNS>void  </RETURNS>
3867 HTMLObject            *o,gint                  *x_return,gint                  *y_return
3868 </FUNCTION>
3869 <FUNCTION>
3870 <NAME>html_object_calc_intersection</NAME>
3871 <RETURNS>void  </RETURNS>
3872 HTMLObject            *o,ArtIRect              *intersection,gint                   x,gint                   y,gint                   width,gint                   height
3873 </FUNCTION>
3874 <FUNCTION>
3875 <NAME>html_object_relayout</NAME>
3876 <RETURNS>gboolean  </RETURNS>
3877 HTMLObject            *obj,HTMLEngine            *engine,HTMLObject            *child
3878 </FUNCTION>
3879 <FUNCTION>
3880 <NAME>html_object_get_valign</NAME>
3881 <RETURNS>HTMLVAlignType  </RETURNS>
3882 HTMLObject            *self
3883 </FUNCTION>
3884 <FUNCTION>
3885 <NAME>html_object_get_url</NAME>
3886 <RETURNS>const gchar     *</RETURNS>
3887 HTMLObject            *o
3888 </FUNCTION>
3889 <FUNCTION>
3890 <NAME>html_object_get_target</NAME>
3891 <RETURNS>const gchar     *</RETURNS>
3892 HTMLObject            *o
3893 </FUNCTION>
3894 <FUNCTION>
3895 <NAME>html_object_find_anchor</NAME>
3896 <RETURNS>HTMLAnchor      *</RETURNS>
3897 HTMLObject            *o,const gchar           *name,gint                  *x,gint                  *y
3898 </FUNCTION>
3899 <FUNCTION>
3900 <NAME>html_object_set_link</NAME>
3901 <RETURNS>HTMLObject      *</RETURNS>
3902 HTMLObject            *self,HTMLColor             *color,const gchar           *url,const gchar           *target
3903 </FUNCTION>
3904 <FUNCTION>
3905 <NAME>html_object_remove_link</NAME>
3906 <RETURNS>HTMLObject      *</RETURNS>
3907 HTMLObject            *self,HTMLColor             *color
3908 </FUNCTION>
3909 <FUNCTION>
3910 <NAME>html_object_accepts_cursor</NAME>
3911 <RETURNS>gboolean  </RETURNS>
3912 HTMLObject            *obj
3913 </FUNCTION>
3914 <FUNCTION>
3915 <NAME>html_object_get_cursor</NAME>
3916 <RETURNS>void  </RETURNS>
3917 HTMLObject            *obj,HTMLPainter           *painter,guint                  offset,gint                  *x1,gint                  *y1,gint                  *x2,gint                  *y2
3918 </FUNCTION>
3919 <FUNCTION>
3920 <NAME>html_object_get_cursor_base</NAME>
3921 <RETURNS>void  </RETURNS>
3922 HTMLObject            *obj,HTMLPainter           *painter,guint                  offset,gint                  *x,gint                  *y
3923 </FUNCTION>
3924 <FUNCTION>
3925 <NAME>html_object_get_length</NAME>
3926 <RETURNS>guint  </RETURNS>
3927 HTMLObject            *self
3928 </FUNCTION>
3929 <FUNCTION>
3930 <NAME>html_object_get_bytes</NAME>
3931 <RETURNS>guint  </RETURNS>
3932 HTMLObject            *self
3933 </FUNCTION>
3934 <FUNCTION>
3935 <NAME>html_object_get_index</NAME>
3936 <RETURNS>guint  </RETURNS>
3937 HTMLObject            *self,guint                  offset
3938 </FUNCTION>
3939 <FUNCTION>
3940 <NAME>html_object_check_point</NAME>
3941 <RETURNS>HTMLObject      *</RETURNS>
3942 HTMLObject            *clue,HTMLPainter           *painter,gint                   x,gint                   y,guint                 *offset_return,gboolean               for_cursor
3943 </FUNCTION>
3944 <FUNCTION>
3945 <NAME>html_object_cursor_forward</NAME>
3946 <RETURNS>gboolean  </RETURNS>
3947 HTMLObject            *self,HTMLCursor            *cursor
3948 </FUNCTION>
3949 <FUNCTION>
3950 <NAME>html_object_cursor_backward</NAME>
3951 <RETURNS>gboolean  </RETURNS>
3952 HTMLObject            *self,HTMLCursor            *cursor
3953 </FUNCTION>
3954 <FUNCTION>
3955 <NAME>html_object_next</NAME>
3956 <RETURNS>HTMLObject      *</RETURNS>
3957 HTMLObject            *self,HTMLObject            *child
3958 </FUNCTION>
3959 <FUNCTION>
3960 <NAME>html_object_prev</NAME>
3961 <RETURNS>HTMLObject      *</RETURNS>
3962 HTMLObject            *self,HTMLObject            *child
3963 </FUNCTION>
3964 <FUNCTION>
3965 <NAME>html_object_head</NAME>
3966 <RETURNS>HTMLObject      *</RETURNS>
3967 HTMLObject            *self
3968 </FUNCTION>
3969 <FUNCTION>
3970 <NAME>html_object_tail</NAME>
3971 <RETURNS>HTMLObject      *</RETURNS>
3972 HTMLObject            *self
3973 </FUNCTION>
3974 <FUNCTION>
3975 <NAME>html_object_tail_not_slave</NAME>
3976 <RETURNS>HTMLObject      *</RETURNS>
3977 HTMLObject            *self
3978 </FUNCTION>
3979 <FUNCTION>
3980 <NAME>html_object_next_leaf</NAME>
3981 <RETURNS>HTMLObject      *</RETURNS>
3982 HTMLObject            *self
3983 </FUNCTION>
3984 <FUNCTION>
3985 <NAME>html_object_prev_leaf</NAME>
3986 <RETURNS>HTMLObject      *</RETURNS>
3987 HTMLObject            *self
3988 </FUNCTION>
3989 <FUNCTION>
3990 <NAME>html_object_next_leaf_not_type</NAME>
3991 <RETURNS>HTMLObject      *</RETURNS>
3992 HTMLObject            *self,HTMLType               t
3993 </FUNCTION>
3994 <FUNCTION>
3995 <NAME>html_object_prev_leaf_not_type</NAME>
3996 <RETURNS>HTMLObject      *</RETURNS>
3997 HTMLObject            *self,HTMLType               t
3998 </FUNCTION>
3999 <FUNCTION>
4000 <NAME>html_object_get_head_leaf</NAME>
4001 <RETURNS>HTMLObject      *</RETURNS>
4002 HTMLObject            *o
4003 </FUNCTION>
4004 <FUNCTION>
4005 <NAME>html_object_get_tail_leaf</NAME>
4006 <RETURNS>HTMLObject      *</RETURNS>
4007 HTMLObject            *o
4008 </FUNCTION>
4009 <FUNCTION>
4010 <NAME>html_object_check_page_split</NAME>
4011 <RETURNS>gint  </RETURNS>
4012 HTMLObject *self,gint        y
4013 </FUNCTION>
4014 <FUNCTION>
4015 <NAME>html_object_select_range</NAME>
4016 <RETURNS>gboolean  </RETURNS>
4017 HTMLObject *self,HTMLEngine *engine,guint       start,gint        length,gboolean    queue_draw
4018 </FUNCTION>
4019 <FUNCTION>
4020 <NAME>html_object_append_selection_string</NAME>
4021 <RETURNS>void  </RETURNS>
4022 HTMLObject *self,GString    *buffer
4023 </FUNCTION>
4024 <FUNCTION>
4025 <NAME>html_object_get_selection_string</NAME>
4026 <RETURNS>gchar       *</RETURNS>
4027 HTMLObject *o
4028 </FUNCTION>
4029 <FUNCTION>
4030 <NAME>html_object_save</NAME>
4031 <RETURNS>gboolean  </RETURNS>
4032 HTMLObject          *self,HTMLEngineSaveState *state
4033 </FUNCTION>
4034 <FUNCTION>
4035 <NAME>html_object_save_plain</NAME>
4036 <RETURNS>gboolean  </RETURNS>
4037 HTMLObject          *self,HTMLEngineSaveState *state,gint requested_width
4038 </FUNCTION>
4039 <FUNCTION>
4040 <NAME>html_object_change_set</NAME>
4041 <RETURNS>void  </RETURNS>
4042 HTMLObject      *self,HTMLChangeFlags  f
4043 </FUNCTION>
4044 <FUNCTION>
4045 <NAME>html_object_change_set_down</NAME>
4046 <RETURNS>void  </RETURNS>
4047 HTMLObject      *self,HTMLChangeFlags  f
4048 </FUNCTION>
4049 <FUNCTION>
4050 <NAME>html_object_set_data</NAME>
4051 <RETURNS>void  </RETURNS>
4052 HTMLObject  *object,const gchar *key,gpointer     data
4053 </FUNCTION>
4054 <FUNCTION>
4055 <NAME>html_object_get_data</NAME>
4056 <RETURNS>gpointer  </RETURNS>
4057 HTMLObject  *object,const gchar *key
4058 </FUNCTION>
4059 <FUNCTION>
4060 <NAME>html_object_copy_data_from_object</NAME>
4061 <RETURNS>void  </RETURNS>
4062 HTMLObject  *dst,HTMLObject  *src
4063 </FUNCTION>
4064 <FUNCTION>
4065 <NAME>html_object_get_bound_list</NAME>
4066 <RETURNS>GList     *</RETURNS>
4067 HTMLObject *obj,GList      *list
4068 </FUNCTION>
4069 <FUNCTION>
4070 <NAME>html_object_move_cursor_before_remove</NAME>
4071 <RETURNS>void  </RETURNS>
4072 HTMLObject *o,HTMLEngine *e
4073 </FUNCTION>
4074 <FUNCTION>
4075 <NAME>html_object_could_remove_whole</NAME>
4076 <RETURNS>gboolean  </RETURNS>
4077 HTMLObject *o,GList      *from,GList      *to,GList      *left,GList      *right
4078 </FUNCTION>
4079 <FUNCTION>
4080 <NAME>html_object_check_cut_lists</NAME>
4081 <RETURNS>void  </RETURNS>
4082 HTMLObject *self,HTMLObject *replacement,GList      *left,GList      *right
4083 </FUNCTION>
4084 <MACRO>
4085 <NAME>HTML_TYPE_PAINTER</NAME>
4086 #define HTML_TYPE_PAINTER                 (html_painter_get_type ())
4087 </MACRO>
4088 <MACRO>
4089 <NAME>HTML_PAINTER</NAME>
4090 #define HTML_PAINTER(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), HTML_TYPE_PAINTER, HTMLPainter))
4091 </MACRO>
4092 <MACRO>
4093 <NAME>HTML_PAINTER_CLASS</NAME>
4094 #define HTML_PAINTER_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), HTML_TYPE_PAINTER, HTMLPainterClass))
4095 </MACRO>
4096 <MACRO>
4097 <NAME>HTML_IS_PAINTER</NAME>
4098 #define HTML_IS_PAINTER(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), HTML_TYPE_PAINTER))
4099 </MACRO>
4100 <MACRO>
4101 <NAME>HTML_IS_PAINTER_CLASS</NAME>
4102 #define HTML_IS_PAINTER_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), HTML_TYPE_PAINTER))
4103 </MACRO>
4104 <STRUCT>
4105 <NAME>HTMLPainter</NAME>
4106 struct HTMLPainter {
4107         GtkObject base;
4108
4109         HTMLFontManager     font_manager;
4110         HTMLColorSet       *color_set;
4111         HTMLFontFace       *font_face;
4112         GtkHTMLFontStyle    font_style;
4113 };
4114 </STRUCT>
4115 <FUNCTION>
4116 <NAME>html_painter_get_type</NAME>
4117 <RETURNS>GtkType  </RETURNS>
4118 void
4119 </FUNCTION>
4120 <FUNCTION>
4121 <NAME>html_painter_new</NAME>
4122 <RETURNS>HTMLPainter       *</RETURNS>
4123 void
4124 </FUNCTION>
4125 <FUNCTION>
4126 <NAME>html_painter_begin</NAME>
4127 <RETURNS>void  </RETURNS>
4128 HTMLPainter       *painter,int                x1,int                y1,int                x2,int                y2
4129 </FUNCTION>
4130 <FUNCTION>
4131 <NAME>html_painter_end</NAME>
4132 <RETURNS>void  </RETURNS>
4133 HTMLPainter       *painter
4134 </FUNCTION>
4135 <FUNCTION>
4136 <NAME>html_painter_alloc_color</NAME>
4137 <RETURNS>void  </RETURNS>
4138 HTMLPainter       *painter,GdkColor          *color
4139 </FUNCTION>
4140 <FUNCTION>
4141 <NAME>html_painter_free_color</NAME>
4142 <RETURNS>void  </RETURNS>
4143 HTMLPainter       *painter,GdkColor          *color
4144 </FUNCTION>
4145 <FUNCTION>
4146 <NAME>html_painter_set_color_set</NAME>
4147 <RETURNS>void  </RETURNS>
4148 HTMLPainter       *painter,HTMLColorSet      *color_set
4149 </FUNCTION>
4150 <FUNCTION>
4151 <NAME>html_painter_get_default_background_color</NAME>
4152 <RETURNS>const GdkColor    *</RETURNS>
4153 HTMLPainter       *painter
4154 </FUNCTION>
4155 <FUNCTION>
4156 <NAME>html_painter_get_default_foreground_color</NAME>
4157 <RETURNS>const GdkColor    *</RETURNS>
4158 HTMLPainter       *painter
4159 </FUNCTION>
4160 <FUNCTION>
4161 <NAME>html_painter_get_default_link_color</NAME>
4162 <RETURNS>const GdkColor    *</RETURNS>
4163 HTMLPainter       *painter
4164 </FUNCTION>
4165 <FUNCTION>
4166 <NAME>html_painter_get_default_highlight_color</NAME>
4167 <RETURNS>const GdkColor    *</RETURNS>
4168 HTMLPainter       *painter
4169 </FUNCTION>
4170 <FUNCTION>
4171 <NAME>html_painter_get_default_highlight_foreground_color</NAME>
4172 <RETURNS>const GdkColor    *</RETURNS>
4173 HTMLPainter       *painter
4174 </FUNCTION>
4175 <FUNCTION>
4176 <NAME>html_painter_get_black</NAME>
4177 <RETURNS>const GdkColor    *</RETURNS>
4178 const HTMLPainter *painter
4179 </FUNCTION>
4180 <FUNCTION>
4181 <NAME>html_painter_find_font_face</NAME>
4182 <RETURNS>HTMLFontFace      *</RETURNS>
4183 HTMLPainter       *p,const gchar       *families
4184 </FUNCTION>
4185 <FUNCTION>
4186 <NAME>html_painter_set_font_style</NAME>
4187 <RETURNS>void  </RETURNS>
4188 HTMLPainter       *p,GtkHTMLFontStyle   f
4189 </FUNCTION>
4190 <FUNCTION>
4191 <NAME>html_painter_get_font_style</NAME>
4192 <RETURNS>GtkHTMLFontStyle  </RETURNS>
4193 HTMLPainter       *p
4194 </FUNCTION>
4195 <FUNCTION>
4196 <NAME>html_painter_set_font_face</NAME>
4197 <RETURNS>void  </RETURNS>
4198 HTMLPainter       *p,HTMLFontFace      *f
4199 </FUNCTION>
4200 <FUNCTION>
4201 <NAME>html_painter_get_font</NAME>
4202 <RETURNS>gpointer  </RETURNS>
4203 HTMLPainter       *painter,HTMLFontFace      *face,GtkHTMLFontStyle   style
4204 </FUNCTION>
4205 <FUNCTION>
4206 <NAME>html_painter_calc_ascent</NAME>
4207 <RETURNS>guint  </RETURNS>
4208 HTMLPainter       *p,GtkHTMLFontStyle   f,HTMLFontFace      *face
4209 </FUNCTION>
4210 <FUNCTION>
4211 <NAME>html_painter_calc_descent</NAME>
4212 <RETURNS>guint  </RETURNS>
4213 HTMLPainter       *p,GtkHTMLFontStyle   f,HTMLFontFace      *face
4214 </FUNCTION>
4215 <FUNCTION>
4216 <NAME>html_painter_calc_text_width</NAME>
4217 <RETURNS>guint  </RETURNS>
4218 HTMLPainter       *p,const gchar       *text,guint              len,GtkHTMLFontStyle   font_style,HTMLFontFace      *face
4219 </FUNCTION>
4220 <FUNCTION>
4221 <NAME>html_painter_set_pen</NAME>
4222 <RETURNS>void  </RETURNS>
4223 HTMLPainter       *painter,const GdkColor    *color
4224 </FUNCTION>
4225 <FUNCTION>
4226 <NAME>html_painter_draw_line</NAME>
4227 <RETURNS>void  </RETURNS>
4228 HTMLPainter       *painter,gint               x1,gint               y1,gint               x2,gint               y2
4229 </FUNCTION>
4230 <FUNCTION>
4231 <NAME>html_painter_draw_rect</NAME>
4232 <RETURNS>void  </RETURNS>
4233 HTMLPainter       *painter,gint               x,gint               y,gint               width,gint               height
4234 </FUNCTION>
4235 <FUNCTION>
4236 <NAME>html_painter_draw_text</NAME>
4237 <RETURNS>void  </RETURNS>
4238 HTMLPainter       *painter,gint               x,gint               y,const gchar       *text,gint               len
4239 </FUNCTION>
4240 <FUNCTION>
4241 <NAME>html_painter_fill_rect</NAME>
4242 <RETURNS>void  </RETURNS>
4243 HTMLPainter       *painter,gint               x,gint               y,gint               width,gint               height
4244 </FUNCTION>
4245 <FUNCTION>
4246 <NAME>html_painter_draw_pixmap</NAME>
4247 <RETURNS>void  </RETURNS>
4248 HTMLPainter       *painter,GdkPixbuf         *pixbuf,gint               x,gint               y,gint               scale_width,gint               scale_height,const GdkColor    *color
4249 </FUNCTION>
4250 <FUNCTION>
4251 <NAME>html_painter_draw_ellipse</NAME>
4252 <RETURNS>void  </RETURNS>
4253 HTMLPainter       *painter,gint               x,gint               y,gint               width,gint               height
4254 </FUNCTION>
4255 <FUNCTION>
4256 <NAME>html_painter_clear</NAME>
4257 <RETURNS>void  </RETURNS>
4258 HTMLPainter       *painter
4259 </FUNCTION>
4260 <FUNCTION>
4261 <NAME>html_painter_set_background_color</NAME>
4262 <RETURNS>void  </RETURNS>
4263 HTMLPainter       *painter,const GdkColor    *color
4264 </FUNCTION>
4265 <FUNCTION>
4266 <NAME>html_painter_draw_shade_line</NAME>
4267 <RETURNS>void  </RETURNS>
4268 HTMLPainter       *p,gint               x,gint               y,gint               width
4269 </FUNCTION>
4270 <FUNCTION>
4271 <NAME>html_painter_draw_panel</NAME>
4272 <RETURNS>void  </RETURNS>
4273 HTMLPainter       *painter,GdkColor          *bg,gint               x,gint               y,gint               width,gint               height,GtkHTMLEtchStyle   inset,gint               bordersize
4274 </FUNCTION>
4275 <FUNCTION>
4276 <NAME>html_painter_set_clip_rectangle</NAME>
4277 <RETURNS>void  </RETURNS>
4278 HTMLPainter       *painter,gint               x,gint               y,gint               width,gint               height
4279 </FUNCTION>
4280 <FUNCTION>
4281 <NAME>html_painter_draw_background</NAME>
4282 <RETURNS>void  </RETURNS>
4283 HTMLPainter       *painter,GdkColor          *color,GdkPixbuf         *pixbuf,gint               x,gint               y,gint               width,gint               height,gint               tile_x,gint               tile_y
4284 </FUNCTION>
4285 <FUNCTION>
4286 <NAME>html_painter_get_pixel_size</NAME>
4287 <RETURNS>guint  </RETURNS>
4288 HTMLPainter       *painter
4289 </FUNCTION>
4290 <FUNCTION>
4291 <NAME>html_painter_draw_spell_error</NAME>
4292 <RETURNS>void  </RETURNS>
4293 HTMLPainter       *painter,gint               x,gint               y,const gchar       *text,guint              off,gint               len
4294 </FUNCTION>
4295 <FUNCTION>
4296 <NAME>html_painter_alloc_font</NAME>
4297 <RETURNS>HTMLFont          *</RETURNS>
4298 HTMLPainter       *painter,gchar             *face_name,gdouble            size,GtkHTMLFontStyle   style
4299 </FUNCTION>
4300 <FUNCTION>
4301 <NAME>html_painter_ref_font</NAME>
4302 <RETURNS>void  </RETURNS>
4303 HTMLPainter       *painter,HTMLFont          *font
4304 </FUNCTION>
4305 <FUNCTION>
4306 <NAME>html_painter_unref_font</NAME>
4307 <RETURNS>void  </RETURNS>
4308 HTMLPainter       *painter,HTMLFont          *font
4309 </FUNCTION>
4310 <FUNCTION>
4311 <NAME>html_painter_get_space_width</NAME>
4312 <RETURNS>guint  </RETURNS>
4313 HTMLPainter       *painter,GtkHTMLFontStyle   font_style,HTMLFontFace      *face
4314 </FUNCTION>
4315 <MACRO>
4316 <NAME>HTML_TYPE_PRINTER</NAME>
4317 #define HTML_TYPE_PRINTER                 (html_printer_get_type ())
4318 </MACRO>
4319 <MACRO>
4320 <NAME>HTML_PRINTER</NAME>
4321 #define HTML_PRINTER(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), HTML_TYPE_PRINTER, HTMLPrinter))
4322 </MACRO>
4323 <MACRO>
4324 <NAME>HTML_PRINTER_CLASS</NAME>
4325 #define HTML_PRINTER_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), HTML_TYPE_PRINTER, HTMLPrinterClass))
4326 </MACRO>
4327 <MACRO>
4328 <NAME>HTML_IS_PRINTER</NAME>
4329 #define HTML_IS_PRINTER(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), HTML_TYPE_PRINTER))
4330 </MACRO>
4331 <MACRO>
4332 <NAME>HTML_IS_PRINTER_CLASS</NAME>
4333 #define HTML_IS_PRINTER_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), HTML_TYPE_PRINTER))
4334 </MACRO>
4335 <STRUCT>
4336 <NAME>HTMLPrinter</NAME>
4337 struct HTMLPrinter {
4338         HTMLPainter base;
4339
4340         GnomePrintContext *print_context;
4341 };
4342 </STRUCT>
4343 <FUNCTION>
4344 <NAME>html_printer_get_type</NAME>
4345 <RETURNS>GtkType  </RETURNS>
4346 void
4347 </FUNCTION>
4348 <FUNCTION>
4349 <NAME>html_printer_new</NAME>
4350 <RETURNS>HTMLPainter  *</RETURNS>
4351 GnomePrintContext *print_context
4352 </FUNCTION>
4353 <FUNCTION>
4354 <NAME>html_printer_get_page_width</NAME>
4355 <RETURNS>guint  </RETURNS>
4356 HTMLPrinter       *printer
4357 </FUNCTION>
4358 <FUNCTION>
4359 <NAME>html_printer_get_page_height</NAME>
4360 <RETURNS>guint  </RETURNS>
4361 HTMLPrinter       *printer
4362 </FUNCTION>
4363 <FUNCTION>
4364 <NAME>html_printer_scale_to_gnome_print</NAME>
4365 <RETURNS>gdouble  </RETURNS>
4366 gint               x
4367 </FUNCTION>
4368 <FUNCTION>
4369 <NAME>html_printer_coordinates_to_gnome_print</NAME>
4370 <RETURNS>void  </RETURNS>
4371 HTMLPrinter       *printer,gint               engine_x,gint               engine_y,gdouble           *print_x_return,gdouble           *print_y_return
4372 </FUNCTION>
4373 <MACRO>
4374 <NAME>HTML_RADIO</NAME>
4375 #define HTML_RADIO(x) ((HTMLRadio *) (x))
4376 </MACRO>
4377 <MACRO>
4378 <NAME>HTML_RADIO_CLASS</NAME>
4379 #define HTML_RADIO_CLASS(x) ((HTMLRadioClass *) (x))
4380 </MACRO>
4381 <STRUCT>
4382 <NAME>HTMLRadio</NAME>
4383 struct HTMLRadio {
4384         HTMLEmbedded element;
4385         gint default_checked;
4386 };
4387 </STRUCT>
4388 <VARIABLE>
4389 <NAME>html_radio_class</NAME>
4390 extern HTMLRadioClass html_radio_class;
4391 </VARIABLE>
4392 <FUNCTION>
4393 <NAME>html_radio_type_init</NAME>
4394 <RETURNS>void  </RETURNS>
4395 void
4396 </FUNCTION>
4397 <FUNCTION>
4398 <NAME>html_radio_class_init</NAME>
4399 <RETURNS>void  </RETURNS>
4400 HTMLRadioClass *klass,HTMLType        type,guint           object_size
4401 </FUNCTION>
4402 <FUNCTION>
4403 <NAME>html_radio_init</NAME>
4404 <RETURNS>void  </RETURNS>
4405 HTMLRadio      *radio,HTMLRadioClass *klass,GtkWidget      *parent,gchar          *name,gchar          *value,gboolean        checked,GSList        **radio_group
4406 </FUNCTION>
4407 <FUNCTION>
4408 <NAME>html_radio_new</NAME>
4409 <RETURNS>HTMLObject  *</RETURNS>
4410 GtkWidget      *parent,gchar          *name,gchar          *value,gboolean        checked,GSList        **radio_group
4411 </FUNCTION>
4412 <STRUCT>
4413 <NAME>HTMLReplace</NAME>
4414 struct HTMLReplace {
4415         gchar *text;
4416         gint   replaced;
4417         void (*ask) (HTMLEngine *, gpointer);
4418         gpointer ask_data;
4419 };
4420 </STRUCT>
4421 <FUNCTION>
4422 <NAME>html_replace_new</NAME>
4423 <RETURNS>HTMLReplace      *</RETURNS>
4424 const gchar *text, void (*ask) (HTMLEngine *, gpointer), gpointer ask_data
4425 </FUNCTION>
4426 <FUNCTION>
4427 <NAME>html_replace_destroy</NAME>
4428 <RETURNS>void  </RETURNS>
4429 HTMLReplace *replace
4430 </FUNCTION>
4431 <MACRO>
4432 <NAME>HTML_RULE</NAME>
4433 #define HTML_RULE(x) ((HTMLRule *) (x))
4434 </MACRO>
4435 <MACRO>
4436 <NAME>HTML_RULE_CLASS</NAME>
4437 #define HTML_RULE_CLASS(x) ((HTMLRuleClass *) (x))
4438 </MACRO>
4439 <STRUCT>
4440 <NAME>HTMLRule</NAME>
4441 struct HTMLRule {
4442         HTMLObject object;
4443
4444         guint length;
4445         gchar size;
4446         gboolean shade;
4447         HTMLHAlignType halign;
4448 };
4449 </STRUCT>
4450 <VARIABLE>
4451 <NAME>html_rule_class</NAME>
4452 extern HTMLRuleClass html_rule_class;
4453 </VARIABLE>
4454 <FUNCTION>
4455 <NAME>html_rule_type_init</NAME>
4456 <RETURNS>void  </RETURNS>
4457 void
4458 </FUNCTION>
4459 <FUNCTION>
4460 <NAME>html_rule_class_init</NAME>
4461 <RETURNS>void  </RETURNS>
4462 HTMLRuleClass  *klass,HTMLType        type,guint           object_size
4463 </FUNCTION>
4464 <FUNCTION>
4465 <NAME>html_rule_init</NAME>
4466 <RETURNS>void  </RETURNS>
4467 HTMLRule       *rule,HTMLRuleClass  *klass,gint            length,gint            percent,gint            size,gboolean        shade,HTMLHAlignType  halign
4468 </FUNCTION>
4469 <FUNCTION>
4470 <NAME>html_rule_new</NAME>
4471 <RETURNS>HTMLObject  *</RETURNS>
4472 gint            length,gint            percent,gint            size,gboolean        shade,HTMLHAlignType  halign
4473 </FUNCTION>
4474 <STRUCT>
4475 <NAME>HTMLSearch</NAME>
4476 struct HTMLSearch {
4477         HTMLEngine *engine;
4478         gchar *trans;
4479         gchar *text;
4480         guint  text_len;
4481         guint  found_len;
4482
4483         gboolean case_sensitive;
4484         gboolean forward;
4485         gboolean regular;
4486
4487         GSList      *stack;
4488         GList       *found;
4489         HTMLObject *last;
4490
4491         guint start_pos;
4492         guint stop_pos;
4493
4494         regex_t *reb;        /* regex buffer */
4495 };
4496 </STRUCT>
4497 <FUNCTION>
4498 <NAME>html_search_new</NAME>
4499 <RETURNS>HTMLSearch       *</RETURNS>
4500 HTMLEngine *e,const gchar *text,gboolean case_sensitive,gboolean forward,gboolean regular
4501 </FUNCTION>
4502 <FUNCTION>
4503 <NAME>html_search_destroy</NAME>
4504 <RETURNS>void  </RETURNS>
4505 HTMLSearch *search
4506 </FUNCTION>
4507 <FUNCTION>
4508 <NAME>html_search_push</NAME>
4509 <RETURNS>void  </RETURNS>
4510 HTMLSearch *search, HTMLObject *obj
4511 </FUNCTION>
4512 <FUNCTION>
4513 <NAME>html_search_pop</NAME>
4514 <RETURNS>HTMLObject       *</RETURNS>
4515 HTMLSearch *search
4516 </FUNCTION>
4517 <FUNCTION>
4518 <NAME>html_search_child_on_stack</NAME>
4519 <RETURNS>gboolean  </RETURNS>
4520 HTMLSearch *search, HTMLObject *obj
4521 </FUNCTION>
4522 <FUNCTION>
4523 <NAME>html_search_next_parent</NAME>
4524 <RETURNS>gboolean  </RETURNS>
4525 HTMLSearch *search
4526 </FUNCTION>
4527 <FUNCTION>
4528 <NAME>html_search_set_text</NAME>
4529 <RETURNS>void  </RETURNS>
4530 HTMLSearch *search,const gchar *text
4531 </FUNCTION>
4532 <FUNCTION>
4533 <NAME>html_search_set_forward</NAME>
4534 <RETURNS>void  </RETURNS>
4535 HTMLSearch *search,gboolean    forward
4536 </FUNCTION>
4537 <MACRO>
4538 <NAME>HTML_SELECT</NAME>
4539 #define HTML_SELECT(x) ((HTMLSelect *) (x))
4540 </MACRO>
4541 <MACRO>
4542 <NAME>HTML_SELECT_CLASS</NAME>
4543 #define HTML_SELECT_CLASS(x) ((HTMLSelectClass *) (x))
4544 </MACRO>
4545 <STRUCT>
4546 <NAME>HTMLSelect</NAME>
4547 struct HTMLSelect {
4548         HTMLEmbedded element;
4549         gint size;
4550         gboolean multi;
4551
4552         gint default_selected;
4553
4554         GList *values;
4555         GList *strings;
4556         GList *default_selection;
4557
4558         GtkWidget *clist;
4559 };
4560 </STRUCT>
4561 <VARIABLE>
4562 <NAME>html_select_class</NAME>
4563 extern HTMLSelectClass html_select_class;
4564 </VARIABLE>
4565 <FUNCTION>
4566 <NAME>html_select_type_init</NAME>
4567 <RETURNS>void  </RETURNS>
4568 void
4569 </FUNCTION>
4570 <FUNCTION>
4571 <NAME>html_select_class_init</NAME>
4572 <RETURNS>void  </RETURNS>
4573 HTMLSelectClass *klass,HTMLType         type,guint            object_size
4574 </FUNCTION>
4575 <FUNCTION>
4576 <NAME>html_select_init</NAME>
4577 <RETURNS>void  </RETURNS>
4578 HTMLSelect      *ti,HTMLSelectClass *klass,GtkWidget       *parent,gchar           *name,gint             size,gboolean         multi
4579 </FUNCTION>
4580 <FUNCTION>
4581 <NAME>html_select_new</NAME>
4582 <RETURNS>HTMLObject  *</RETURNS>
4583 GtkWidget       *parent,gchar           *name,gint             size,gboolean         multi
4584 </FUNCTION>
4585 <FUNCTION>
4586 <NAME>html_select_add_option</NAME>
4587 <RETURNS>void  </RETURNS>
4588 HTMLSelect      *select,gchar           *value,gboolean         selected
4589 </FUNCTION>
4590 <FUNCTION>
4591 <NAME>html_select_set_text</NAME>
4592 <RETURNS>void  </RETURNS>
4593 HTMLSelect      *select,gchar           *text
4594 </FUNCTION>
4595 <FUNCTION>
4596 <NAME>html_engine_select_interval</NAME>
4597 <RETURNS>void  </RETURNS>
4598 HTMLEngine *e,HTMLInterval *i
4599 </FUNCTION>
4600 <FUNCTION>
4601 <NAME>html_engine_select_region</NAME>
4602 <RETURNS>void  </RETURNS>
4603 HTMLEngine *e,gint        x1,gint        y1,gint        x2,gint        y2
4604 </FUNCTION>
4605 <FUNCTION>
4606 <NAME>html_engine_select_word</NAME>
4607 <RETURNS>void  </RETURNS>
4608 HTMLEngine *e
4609 </FUNCTION>
4610 <FUNCTION>
4611 <NAME>html_engine_select_line</NAME>
4612 <RETURNS>void  </RETURNS>
4613 HTMLEngine *e
4614 </FUNCTION>
4615 <FUNCTION>
4616 <NAME>html_engine_unselect_all</NAME>
4617 <RETURNS>void  </RETURNS>
4618 HTMLEngine *e
4619 </FUNCTION>
4620 <FUNCTION>
4621 <NAME>html_engine_clear_selection</NAME>
4622 <RETURNS>void  </RETURNS>
4623 HTMLEngine *e
4624 </FUNCTION>
4625 <FUNCTION>
4626 <NAME>html_engine_deactivate_selection</NAME>
4627 <RETURNS>void  </RETURNS>
4628 HTMLEngine *e
4629 </FUNCTION>
4630 <FUNCTION>
4631 <NAME>html_engine_disable_selection</NAME>
4632 <RETURNS>void  </RETURNS>
4633 HTMLEngine *e
4634 </FUNCTION>
4635 <FUNCTION>
4636 <NAME>html_engine_get_selection_string</NAME>
4637 <RETURNS>gchar     *</RETURNS>
4638 HTMLEngine *e
4639 </FUNCTION>
4640 <FUNCTION>
4641 <NAME>html_engine_is_selection_active</NAME>
4642 <RETURNS>gboolean  </RETURNS>
4643 HTMLEngine *e
4644 </FUNCTION>
4645 <FUNCTION>
4646 <NAME>html_engine_activate_selection</NAME>
4647 <RETURNS>void  </RETURNS>
4648 HTMLEngine *e,guint32     time
4649 </FUNCTION>
4650 <MACRO>
4651 <NAME>HTML_NUM_FONT_SIZES</NAME>
4652 #define HTML_NUM_FONT_SIZES 7
4653 </MACRO>
4654 <STRUCT>
4655 <NAME>HTMLSettings</NAME>
4656 struct HTMLSettings {
4657         gint fontSizes [HTML_NUM_FONT_SIZES];
4658         gint fontBaseSize;
4659
4660         gchar *fontBaseFace;
4661         gchar *fixedFontFace;
4662
4663         guint underlineLinks : 1;
4664         guint forceDefault : 1;
4665
4666         HTMLColorSet *color_set;
4667 };
4668 </STRUCT>
4669 <FUNCTION>
4670 <NAME>html_settings_new</NAME>
4671 <RETURNS>HTMLSettings  *</RETURNS>
4672 GtkWidget *w
4673 </FUNCTION>
4674 <FUNCTION>
4675 <NAME>html_settings_reset</NAME>
4676 <RETURNS>void  </RETURNS>
4677 HTMLSettings *settings,HTMLSettings *orig,HTMLPainter  *painter
4678 </FUNCTION>
4679 <FUNCTION>
4680 <NAME>html_settings_destroy</NAME>
4681 <RETURNS>void  </RETURNS>
4682 HTMLSettings *settings
4683 </FUNCTION>
4684 <FUNCTION>
4685 <NAME>html_settings_set_font_sizes</NAME>
4686 <RETURNS>void  </RETURNS>
4687 HTMLSettings *settings,const gint *newFontSizes
4688 </FUNCTION>
4689 <FUNCTION>
4690 <NAME>html_settings_get_font_sizes</NAME>
4691 <RETURNS>void  </RETURNS>
4692 HTMLSettings *settings,gint *fontSizes
4693 </FUNCTION>
4694 <FUNCTION>
4695 <NAME>html_settings_reset_font_sizes</NAME>
4696 <RETURNS>void  </RETURNS>
4697 HTMLSettings *settings
4698 </FUNCTION>
4699 <FUNCTION>
4700 <NAME>html_settings_copy</NAME>
4701 <RETURNS>void  </RETURNS>
4702 HTMLSettings *dest, HTMLSettings *src
4703 </FUNCTION>
4704 <FUNCTION>
4705 <NAME>html_settings_set_font_base_face</NAME>
4706 <RETURNS>void  </RETURNS>
4707 HTMLSettings *settings, const gchar *face
4708 </FUNCTION>
4709 <FUNCTION>
4710 <NAME>html_settings_set_fixed_font_face</NAME>
4711 <RETURNS>void  </RETURNS>
4712 HTMLSettings *settings, const gchar *face
4713 </FUNCTION>
4714 <STRUCT>
4715 <NAME>HTMLStack</NAME>
4716 struct HTMLStack {
4717         HTMLStackFreeFunc free_func;
4718
4719         GList *list;
4720 };
4721 </STRUCT>
4722 <FUNCTION>
4723 <NAME>html_stack_new</NAME>
4724 <RETURNS>HTMLStack  *</RETURNS>
4725 HTMLStackFreeFunc free_func
4726 </FUNCTION>
4727 <FUNCTION>
4728 <NAME>html_stack_clear</NAME>
4729 <RETURNS>void  </RETURNS>
4730 HTMLStack *stack
4731 </FUNCTION>
4732 <FUNCTION>
4733 <NAME>html_stack_destroy</NAME>
4734 <RETURNS>void  </RETURNS>
4735 HTMLStack *stack
4736 </FUNCTION>
4737 <FUNCTION>
4738 <NAME>html_stack_pop</NAME>
4739 <RETURNS>gpointer  </RETURNS>
4740 HTMLStack *stack
4741 </FUNCTION>
4742 <FUNCTION>
4743 <NAME>html_stack_top</NAME>
4744 <RETURNS>gpointer  </RETURNS>
4745 HTMLStack *stack
4746 </FUNCTION>
4747 <FUNCTION>
4748 <NAME>html_stack_push</NAME>
4749 <RETURNS>void  </RETURNS>
4750 HTMLStack *stack, gpointer data
4751 </FUNCTION>
4752 <FUNCTION>
4753 <NAME>html_stack_is_empty</NAME>
4754 <RETURNS>gboolean  </RETURNS>
4755 HTMLStack *stack
4756 </FUNCTION>
4757 <FUNCTION>
4758 <NAME>html_stack_count</NAME>
4759 <RETURNS>guint  </RETURNS>
4760 HTMLStack *stack
4761 </FUNCTION>
4762 <STRUCT>
4763 <NAME>HTMLStringTokenizer</NAME>
4764 struct HTMLStringTokenizer {
4765         gchar *buffer;
4766         gint buffer_length;
4767
4768         gchar *pos;
4769         gchar *end;
4770 };
4771 </STRUCT>
4772 <FUNCTION>
4773 <NAME>html_string_tokenizer_new</NAME>
4774 <RETURNS>HTMLStringTokenizer  *</RETURNS>
4775 void
4776 </FUNCTION>
4777 <FUNCTION>
4778 <NAME>html_string_tokenizer_destroy</NAME>
4779 <RETURNS>void  </RETURNS>
4780 HTMLStringTokenizer *st
4781 </FUNCTION>
4782 <FUNCTION>
4783 <NAME>html_string_tokenizer_tokenize</NAME>
4784 <RETURNS>void  </RETURNS>
4785 HTMLStringTokenizer *t,const gchar         *str,gchar               *separators
4786 </FUNCTION>
4787 <FUNCTION>
4788 <NAME>html_string_tokenizer_has_more_tokens</NAME>
4789 <RETURNS>gboolean  </RETURNS>
4790 HTMLStringTokenizer *t
4791 </FUNCTION>
4792 <FUNCTION>
4793 <NAME>html_string_tokenizer_next_token</NAME>
4794 <RETURNS>gchar                *</RETURNS>
4795 HTMLStringTokenizer *t
4796 </FUNCTION>
4797 <MACRO>
4798 <NAME>HTML_TABLE</NAME>
4799 #define HTML_TABLE(x) ((HTMLTable *)(x))
4800 </MACRO>
4801 <MACRO>
4802 <NAME>HTML_TABLE_CLASS</NAME>
4803 #define HTML_TABLE_CLASS(x) ((HTMLTableClass *)(x))
4804 </MACRO>
4805 <STRUCT>
4806 <NAME>HTMLTable</NAME>
4807 struct HTMLTable {
4808         HTMLObject object;
4809
4810         gint specified_width;
4811
4812         HTMLTableCell ***cells;
4813         gint col, totalCols;
4814         gint row, totalRows, allocRows;
4815         gint spacing;
4816         gint padding;
4817         gint border;
4818         HTMLClueV *caption;
4819         HTMLVAlignType capAlign;
4820
4821         GArray *columnMin;
4822         GArray *columnPref;
4823         GArray *columnFixed;
4824         GArray *columnOpt;
4825         GArray *rowHeights;
4826
4827         GdkColor *bgColor;
4828         HTMLImagePointer *bgPixmap;
4829 };
4830 </STRUCT>
4831 <FUNCTION>
4832 <NAME>html_table_type_init</NAME>
4833 <RETURNS>void  </RETURNS>
4834 void
4835 </FUNCTION>
4836 <FUNCTION>
4837 <NAME>html_table_class_init</NAME>
4838 <RETURNS>void  </RETURNS>
4839 HTMLTableClass *klass,HTMLType        type,guint           object_size
4840 </FUNCTION>
4841 <FUNCTION>
4842 <NAME>html_table_init</NAME>
4843 <RETURNS>void  </RETURNS>
4844 HTMLTable      *table,HTMLTableClass *klass,gint            width,gint            percent,gint            padding,gint            spacing,gint            border
4845 </FUNCTION>
4846 <FUNCTION>
4847 <NAME>html_table_new</NAME>
4848 <RETURNS>HTMLObject  *</RETURNS>
4849 gint            width,gint            percent,gint            padding,gint            spacing,gint            border
4850 </FUNCTION>
4851 <FUNCTION>
4852 <NAME>html_table_end_row</NAME>
4853 <RETURNS>void  </RETURNS>
4854 HTMLTable     *table
4855 </FUNCTION>
4856 <FUNCTION>
4857 <NAME>html_table_start_row</NAME>
4858 <RETURNS>void  </RETURNS>
4859 HTMLTable     *table
4860 </FUNCTION>
4861 <FUNCTION>
4862 <NAME>html_table_add_cell</NAME>
4863 <RETURNS>void  </RETURNS>
4864 HTMLTable     *table,HTMLTableCell *cell
4865 </FUNCTION>
4866 <FUNCTION>
4867 <NAME>html_table_end_table</NAME>
4868 <RETURNS>void  </RETURNS>
4869 HTMLTable     *table
4870 </FUNCTION>
4871 <MACRO>
4872 <NAME>HTML_TABLE_CELL</NAME>
4873 #define HTML_TABLE_CELL(x) ((HTMLTableCell *)(x))
4874 </MACRO>
4875 <MACRO>
4876 <NAME>HTML_TABLE_CELL_CLASS</NAME>
4877 #define HTML_TABLE_CELL_CLASS(x) ((HTMLTableCellClass *)(x))
4878 </MACRO>
4879 <STRUCT>
4880 <NAME>HTMLTableCell</NAME>
4881 struct HTMLTableCell {
4882         HTMLClueV cluev;
4883
4884         gint fixed_width;
4885         gint fixed_height;
4886
4887         gint rspan;
4888         gint cspan;
4889         gint padding;
4890         gint refcount;
4891         gint row;
4892         gint col;
4893
4894         GdkColor bg;
4895         guint have_bg : 1;
4896         guint bg_allocated : 1;
4897
4898         HTMLImagePointer *bgPixmap;
4899         gboolean have_bgPixmap;
4900 };
4901 </STRUCT>
4902 <VARIABLE>
4903 <NAME>html_table_cell_class</NAME>
4904 extern HTMLTableCellClass html_table_cell_class;
4905 </VARIABLE>
4906 <FUNCTION>
4907 <NAME>html_table_cell_type_init</NAME>
4908 <RETURNS>void  </RETURNS>
4909 void
4910 </FUNCTION>
4911 <FUNCTION>
4912 <NAME>html_table_cell_class_init</NAME>
4913 <RETURNS>void  </RETURNS>
4914 HTMLTableCellClass *klass,HTMLType            type,guint               object_size
4915 </FUNCTION>
4916 <FUNCTION>
4917 <NAME>html_table_cell_init</NAME>
4918 <RETURNS>void  </RETURNS>
4919 HTMLTableCell      *cell,HTMLTableCellClass *klass,gint                percent,gint                rs,gint                cs,gint                pad
4920 </FUNCTION>
4921 <FUNCTION>
4922 <NAME>html_table_cell_new</NAME>
4923 <RETURNS>HTMLObject  *</RETURNS>
4924 gint                percent,gint                rs,gint                cs,gint                pad
4925 </FUNCTION>
4926 <FUNCTION>
4927 <NAME>html_table_cell_link</NAME>
4928 <RETURNS>void  </RETURNS>
4929 HTMLTableCell      *cell
4930 </FUNCTION>
4931 <FUNCTION>
4932 <NAME>html_table_cell_unlink</NAME>
4933 <RETURNS>void  </RETURNS>
4934 HTMLTableCell      *cell
4935 </FUNCTION>
4936 <FUNCTION>
4937 <NAME>html_table_cell_set_fixed_width</NAME>
4938 <RETURNS>void  </RETURNS>
4939 HTMLTableCell      *cell,gint                width
4940 </FUNCTION>
4941 <FUNCTION>
4942 <NAME>html_table_cell_set_fixed_height</NAME>
4943 <RETURNS>void  </RETURNS>
4944 HTMLTableCell      *cell,gint                height
4945 </FUNCTION>
4946 <FUNCTION>
4947 <NAME>html_table_cell_set_bg_pixmap</NAME>
4948 <RETURNS>void  </RETURNS>
4949 HTMLTableCell      *cell,HTMLImagePointer   *imagePtr
4950 </FUNCTION>
4951 <FUNCTION>
4952 <NAME>html_table_cell_set_position</NAME>
4953 <RETURNS>void  </RETURNS>
4954 HTMLTableCell      *cell,gint                row,gint                col
4955 </FUNCTION>
4956 <FUNCTION>
4957 <NAME>html_table_cell_get_fixed_width</NAME>
4958 <RETURNS>gint  </RETURNS>
4959 HTMLTableCell      *cell,HTMLPainter        *painter
4960 </FUNCTION>
4961 <MACRO>
4962 <NAME>HTML_TEXT</NAME>
4963 #define HTML_TEXT(x) ((HTMLText *)(x))
4964 </MACRO>
4965 <MACRO>
4966 <NAME>HTML_TEXT_CLASS</NAME>
4967 #define HTML_TEXT_CLASS(x) ((HTMLTextClass *)(x))
4968 </MACRO>
4969 <STRUCT>
4970 <NAME>SpellError</NAME>
4971 struct SpellError {
4972         guint off;
4973         guint len;
4974 };
4975 </STRUCT>
4976 <STRUCT>
4977 <NAME>HTMLText</NAME>
4978 struct HTMLText {
4979         HTMLObject object;
4980
4981         gchar   *text;
4982         guint    text_len;
4983         guint   *word_width;
4984         guint    words;
4985
4986         GtkHTMLFontStyle  font_style;
4987         HTMLFontFace     *face;
4988         HTMLColor        *color;
4989
4990         guint select_start;
4991         guint select_length;
4992
4993         GList *spell_errors;
4994 };
4995 </STRUCT>
4996 <VARIABLE>
4997 <NAME>html_text_class</NAME>
4998 extern HTMLTextClass html_text_class;
4999 </VARIABLE>
5000 <FUNCTION>
5001 <NAME>html_text_type_init</NAME>
5002 <RETURNS>void  </RETURNS>
5003 void
5004 </FUNCTION>
5005 <FUNCTION>
5006 <NAME>html_text_class_init</NAME>
5007 <RETURNS>void  </RETURNS>
5008 HTMLTextClass      *klass,HTMLType            type,guint               object_size
5009 </FUNCTION>
5010 <FUNCTION>
5011 <NAME>html_text_init</NAME>
5012 <RETURNS>void  </RETURNS>
5013 HTMLText           *text_object,HTMLTextClass      *klass,const gchar        *text,gint                len,GtkHTMLFontStyle    font_style,HTMLColor          *color
5014 </FUNCTION>
5015 <FUNCTION>
5016 <NAME>html_text_new</NAME>
5017 <RETURNS>HTMLObject        *</RETURNS>
5018 const gchar        *text,GtkHTMLFontStyle    font_style,HTMLColor          *color
5019 </FUNCTION>
5020 <FUNCTION>
5021 <NAME>html_text_new_with_len</NAME>
5022 <RETURNS>HTMLObject        *</RETURNS>
5023 const gchar        *text,gint                len,GtkHTMLFontStyle    font_style,HTMLColor          *color
5024 </FUNCTION>
5025 <FUNCTION>
5026 <NAME>html_text_queue_draw</NAME>
5027 <RETURNS>void  </RETURNS>
5028 HTMLText           *text,HTMLEngine         *engine,guint               offset,guint               len
5029 </FUNCTION>
5030 <FUNCTION>
5031 <NAME>html_text_get_font_style</NAME>
5032 <RETURNS>GtkHTMLFontStyle  </RETURNS>
5033 const HTMLText     *text
5034 </FUNCTION>
5035 <FUNCTION>
5036 <NAME>html_text_get_color</NAME>
5037 <RETURNS>HTMLColor         *</RETURNS>
5038 HTMLText           *text,HTMLPainter        *painter
5039 </FUNCTION>
5040 <FUNCTION>
5041 <NAME>html_text_set_font_style</NAME>
5042 <RETURNS>void  </RETURNS>
5043 HTMLText           *text,HTMLEngine         *engine,GtkHTMLFontStyle    style
5044 </FUNCTION>
5045 <FUNCTION>
5046 <NAME>html_text_set_color</NAME>
5047 <RETURNS>void  </RETURNS>
5048 HTMLText           *text,HTMLEngine         *engine,HTMLColor          *color
5049 </FUNCTION>
5050 <FUNCTION>
5051 <NAME>html_text_append</NAME>
5052 <RETURNS>void  </RETURNS>
5053 HTMLText           *text,const gchar        *str,gint                len
5054 </FUNCTION>
5055 <FUNCTION>
5056 <NAME>html_text_set_text</NAME>
5057 <RETURNS>void  </RETURNS>
5058 HTMLText           *text,const gchar        *new_text
5059 </FUNCTION>
5060 <FUNCTION>
5061 <NAME>html_text_set_font_face</NAME>
5062 <RETURNS>void  </RETURNS>
5063 HTMLText           *text,HTMLFontFace       *face
5064 </FUNCTION>
5065 <FUNCTION>
5066 <NAME>html_text_get_nb_width</NAME>
5067 <RETURNS>gint  </RETURNS>
5068 HTMLText           *text,HTMLPainter        *painter,gboolean            begin
5069 </FUNCTION>
5070 <FUNCTION>
5071 <NAME>html_text_get_bytes</NAME>
5072 <RETURNS>guint  </RETURNS>
5073 HTMLText           *text
5074 </FUNCTION>
5075 <FUNCTION>
5076 <NAME>html_text_get_index</NAME>
5077 <RETURNS>guint  </RETURNS>
5078 HTMLText           *text,guint               offset
5079 </FUNCTION>
5080 <FUNCTION>
5081 <NAME>html_text_get_char</NAME>
5082 <RETURNS>unicode_char_t  </RETURNS>
5083 HTMLText           *text,guint               offset
5084 </FUNCTION>
5085 <FUNCTION>
5086 <NAME>html_text_get_text</NAME>
5087 <RETURNS>gchar             *</RETURNS>
5088 HTMLText           *text,guint               offset
5089 </FUNCTION>
5090 <FUNCTION>
5091 <NAME>html_text_spell_errors_clear</NAME>
5092 <RETURNS>void  </RETURNS>
5093 HTMLText           *text
5094 </FUNCTION>
5095 <FUNCTION>
5096 <NAME>html_text_spell_errors_clear_interval</NAME>
5097 <RETURNS>void  </RETURNS>
5098 HTMLText           *text,HTMLInterval       *i
5099 </FUNCTION>
5100 <FUNCTION>
5101 <NAME>html_text_spell_errors_add</NAME>
5102 <RETURNS>void  </RETURNS>
5103 HTMLText           *text,guint               off,guint               len
5104 </FUNCTION>
5105 <FUNCTION>
5106 <NAME>html_text_magic_link</NAME>
5107 <RETURNS>gboolean  </RETURNS>
5108 HTMLText           *text,HTMLEngine         *engine,guint               offset
5109 </FUNCTION>
5110 <FUNCTION>
5111 <NAME>html_text_trail_space_width</NAME>
5112 <RETURNS>gint  </RETURNS>
5113 HTMLText           *text,HTMLPainter        *painter
5114 </FUNCTION>
5115 <FUNCTION>
5116 <NAME>html_text_request_word_width</NAME>
5117 <RETURNS>void  </RETURNS>
5118 HTMLText           *text,HTMLPainter        *painter
5119 </FUNCTION>
5120 <FUNCTION>
5121 <NAME>html_text_convert_nbsp</NAME>
5122 <RETURNS>gboolean  </RETURNS>
5123 HTMLText           *text,gboolean           free_text
5124 </FUNCTION>
5125 <USER_FUNCTION>
5126 <NAME>HTMLTextHelperFunc</NAME>
5127 <RETURNS>HTMLObject *</RETURNS>
5128 HTMLText *, gint begin, gint end
5129 </USER_FUNCTION>
5130 <FUNCTION>
5131 <NAME>html_text_op_copy_helper</NAME>
5132 <RETURNS>HTMLObject        *</RETURNS>
5133 HTMLText           *text,GList              *from,GList              *to,guint              *len,HTMLTextHelperFunc  f
5134 </FUNCTION>
5135 <FUNCTION>
5136 <NAME>html_text_op_cut_helper</NAME>
5137 <RETURNS>HTMLObject        *</RETURNS>
5138 HTMLText           *text,HTMLEngine         *e,GList              *from,GList              *to,GList              *left,GList              *right,guint              *len,HTMLTextHelperFunc  f
5139 </FUNCTION>
5140 <FUNCTION>
5141 <NAME>html_text_clear_word_width</NAME>
5142 <RETURNS>void  </RETURNS>
5143 HTMLText           *text
5144 </FUNCTION>
5145 <MACRO>
5146 <NAME>HTML_TEXTAREA</NAME>
5147 #define HTML_TEXTAREA(x) ((HTMLTextArea *) (x))
5148 </MACRO>
5149 <MACRO>
5150 <NAME>HTML_TEXTAREA_CLASS</NAME>
5151 #define HTML_TEXTAREA_CLASS(x) ((HTMLTextAreaClass *) (x))
5152 </MACRO>
5153 <STRUCT>
5154 <NAME>HTMLTextArea</NAME>
5155 struct HTMLTextArea {
5156         HTMLEmbedded element;
5157
5158         GtkWidget *text;
5159
5160         gchar *default_text;
5161 };
5162 </STRUCT>
5163 <VARIABLE>
5164 <NAME>html_textarea_class</NAME>
5165 extern HTMLTextAreaClass html_textarea_class;
5166 </VARIABLE>
5167 <FUNCTION>
5168 <NAME>html_textarea_type_init</NAME>
5169 <RETURNS>void  </RETURNS>
5170 void
5171 </FUNCTION>
5172 <FUNCTION>
5173 <NAME>html_textarea_class_init</NAME>
5174 <RETURNS>void  </RETURNS>
5175 HTMLTextAreaClass *klass,HTMLType           type,guint              object_size
5176 </FUNCTION>
5177 <FUNCTION>
5178 <NAME>html_textarea_init</NAME>
5179 <RETURNS>void  </RETURNS>
5180 HTMLTextArea      *ti,HTMLTextAreaClass *klass,GtkWidget         *parent,gchar             *name,gint               r,gint               c
5181 </FUNCTION>
5182 <FUNCTION>
5183 <NAME>html_textarea_new</NAME>
5184 <RETURNS>HTMLObject  *</RETURNS>
5185 GtkWidget         *parent,gchar             *name,gint               r,gint               c
5186 </FUNCTION>
5187 <FUNCTION>
5188 <NAME>html_textarea_set_text</NAME>
5189 <RETURNS>void  </RETURNS>
5190 HTMLTextArea      *textarea,gchar             *text
5191 </FUNCTION>
5192 <MACRO>
5193 <NAME>HTML_TEXTINPUT</NAME>
5194 #define HTML_TEXTINPUT(x) ((HTMLTextInput *) (x))
5195 </MACRO>
5196 <MACRO>
5197 <NAME>HTML_TEXTINPUT_CLASS</NAME>
5198 #define HTML_TEXTINPUT_CLASS(x) ((HTMLTextInputClass *) (x))
5199 </MACRO>
5200 <STRUCT>
5201 <NAME>HTMLTextInput</NAME>
5202 struct HTMLTextInput {
5203         HTMLEmbedded element;
5204         gint size, maxlen;
5205         gboolean password;
5206
5207         gchar *default_text;
5208 };
5209 </STRUCT>
5210 <VARIABLE>
5211 <NAME>html_text_input_class</NAME>
5212 extern HTMLTextInputClass html_text_input_class;
5213 </VARIABLE>
5214 <FUNCTION>
5215 <NAME>html_text_input_type_init</NAME>
5216 <RETURNS>void  </RETURNS>
5217 void
5218 </FUNCTION>
5219 <FUNCTION>
5220 <NAME>html_text_input_class_init</NAME>
5221 <RETURNS>void  </RETURNS>
5222 HTMLTextInputClass *klass,HTMLType            type,guint               object_size
5223 </FUNCTION>
5224 <FUNCTION>
5225 <NAME>html_text_input_init</NAME>
5226 <RETURNS>void  </RETURNS>
5227 HTMLTextInput      *ti,HTMLTextInputClass *klass,GtkWidget          *parent,gchar              *name,gchar              *value,gint                size,gint                maxlen,gboolean            password
5228 </FUNCTION>
5229 <FUNCTION>
5230 <NAME>html_text_input_new</NAME>
5231 <RETURNS>HTMLObject  *</RETURNS>
5232 GtkWidget          *parent,gchar              *name,gchar              *value,gint                size,gint                maxlen,gboolean            password
5233 </FUNCTION>
5234 <MACRO>
5235 <NAME>HTML_TEXT_SLAVE</NAME>
5236 #define HTML_TEXT_SLAVE(x) ((HTMLTextSlave *) (x))
5237 </MACRO>
5238 <MACRO>
5239 <NAME>HTML_TEXT_SLAVE_CLASS</NAME>
5240 #define HTML_TEXT_SLAVE_CLASS(x) ((HTMLTextSlaveClass *) (x))
5241 </MACRO>
5242 <STRUCT>
5243 <NAME>HTMLTextSlave</NAME>
5244 struct HTMLTextSlave {
5245         HTMLObject object;
5246
5247         HTMLText *owner;
5248         guint posStart;
5249         guint posLen;
5250         guint start_word;
5251 };
5252 </STRUCT>
5253 <FUNCTION>
5254 <NAME>html_text_slave_type_init</NAME>
5255 <RETURNS>void  </RETURNS>
5256 void
5257 </FUNCTION>
5258 <FUNCTION>
5259 <NAME>html_text_slave_class_init</NAME>
5260 <RETURNS>void  </RETURNS>
5261 HTMLTextSlaveClass *klass,HTMLType            type,guint               object_size
5262 </FUNCTION>
5263 <FUNCTION>
5264 <NAME>html_text_slave_init</NAME>
5265 <RETURNS>void  </RETURNS>
5266 HTMLTextSlave      *slave,HTMLTextSlaveClass *klass,HTMLText           *owner,guint               posStart,guint               posLen,guint               start_word
5267 </FUNCTION>
5268 <FUNCTION>
5269 <NAME>html_text_slave_new</NAME>
5270 <RETURNS>HTMLObject  *</RETURNS>
5271 HTMLText           *owner,guint               posStart,guint               posLen,guint               start_word
5272 </FUNCTION>
5273 <MACRO>
5274 <NAME>TAG_ESCAPE</NAME>
5275 #define TAG_ESCAPE 13
5276 </MACRO>
5277 <MACRO>
5278 <NAME>TAB_SIZE</NAME>
5279 #define TAB_SIZE 8
5280 </MACRO>
5281 <FUNCTION>
5282 <NAME>html_tokenizer_new</NAME>
5283 <RETURNS>HTMLTokenizer  *</RETURNS>
5284 void
5285 </FUNCTION>
5286 <FUNCTION>
5287 <NAME>html_tokenizer_destroy</NAME>
5288 <RETURNS>void  </RETURNS>
5289 HTMLTokenizer *tokenizer
5290 </FUNCTION>
5291 <FUNCTION>
5292 <NAME>html_tokenizer_begin</NAME>
5293 <RETURNS>void  </RETURNS>
5294 HTMLTokenizer *t,gchar *content_type
5295 </FUNCTION>
5296 <FUNCTION>
5297 <NAME>html_tokenizer_write</NAME>
5298 <RETURNS>void  </RETURNS>
5299 HTMLTokenizer *t,const gchar *string,size_t size
5300 </FUNCTION>
5301 <FUNCTION>
5302 <NAME>html_tokenizer_end</NAME>
5303 <RETURNS>void  </RETURNS>
5304 HTMLTokenizer *t
5305 </FUNCTION>
5306 <FUNCTION>
5307 <NAME>html_tokenizer_peek_token</NAME>
5308 <RETURNS>gchar  *</RETURNS>
5309 HTMLTokenizer *t
5310 </FUNCTION>
5311 <FUNCTION>
5312 <NAME>html_tokenizer_next_token</NAME>
5313 <RETURNS>gchar  *</RETURNS>
5314 HTMLTokenizer *t
5315 </FUNCTION>
5316 <FUNCTION>
5317 <NAME>html_tokenizer_has_more_tokens</NAME>
5318 <RETURNS>gboolean  </RETURNS>
5319 HTMLTokenizer *t
5320 </FUNCTION>
5321 <FUNCTION>
5322 <NAME>g_unichar_to_utf8</NAME>
5323 <RETURNS>gint  </RETURNS>
5324 gint c, gchar *outbuf
5325 </FUNCTION>
5326 <FUNCTION>
5327 <NAME>html_types_init</NAME>
5328 <RETURNS>void  </RETURNS>
5329 void
5330 </FUNCTION>
5331 <FUNCTION>
5332 <NAME>html_type_name</NAME>
5333 <RETURNS>const gchar  *</RETURNS>
5334 HTMLType     type
5335 </FUNCTION>
5336 <FUNCTION>
5337 <NAME>html_type_from_name</NAME>
5338 <RETURNS>HTMLType  </RETURNS>
5339 const gchar *name
5340 </FUNCTION>
5341 <STRUCT>
5342 <NAME>HTMLObject</NAME>
5343 </STRUCT>
5344 <STRUCT>
5345 <NAME>HTMLObjectClass</NAME>
5346 </STRUCT>
5347 <STRUCT>
5348 <NAME>HTMLAnchor</NAME>
5349 </STRUCT>
5350 <STRUCT>
5351 <NAME>HTMLAnchorClass</NAME>
5352 </STRUCT>
5353 <STRUCT>
5354 <NAME>HTMLBlockStackElement</NAME>
5355 </STRUCT>
5356 <STRUCT>
5357 <NAME>HTMLButton</NAME>
5358 </STRUCT>
5359 <STRUCT>
5360 <NAME>HTMLButtonClass</NAME>
5361 </STRUCT>
5362 <STRUCT>
5363 <NAME>HTMLCheckBox</NAME>
5364 </STRUCT>
5365 <STRUCT>
5366 <NAME>HTMLCheckBoxClass</NAME>
5367 </STRUCT>
5368 <STRUCT>
5369 <NAME>HTMLClue</NAME>
5370 </STRUCT>
5371 <STRUCT>
5372 <NAME>HTMLClueAligned</NAME>
5373 </STRUCT>
5374 <STRUCT>
5375 <NAME>HTMLClueAlignedClass</NAME>
5376 </STRUCT>
5377 <STRUCT>
5378 <NAME>HTMLClueClass</NAME>
5379 </STRUCT>
5380 <STRUCT>
5381 <NAME>HTMLClueFlow</NAME>
5382 </STRUCT>
5383 <STRUCT>
5384 <NAME>HTMLClueFlowClass</NAME>
5385 </STRUCT>
5386 <STRUCT>
5387 <NAME>HTMLClueH</NAME>
5388 </STRUCT>
5389 <STRUCT>
5390 <NAME>HTMLClueHClass</NAME>
5391 </STRUCT>
5392 <STRUCT>
5393 <NAME>HTMLClueV</NAME>
5394 </STRUCT>
5395 <STRUCT>
5396 <NAME>HTMLClueVClass</NAME>
5397 </STRUCT>
5398 <STRUCT>
5399 <NAME>HTMLColor</NAME>
5400 </STRUCT>
5401 <STRUCT>
5402 <NAME>HTMLColorSet</NAME>
5403 </STRUCT>
5404 <STRUCT>
5405 <NAME>HTMLCursor</NAME>
5406 </STRUCT>
5407 <STRUCT>
5408 <NAME>HTMLDrawQueue</NAME>
5409 </STRUCT>
5410 <STRUCT>
5411 <NAME>HTMLDrawQueueClearElement</NAME>
5412 </STRUCT>
5413 <STRUCT>
5414 <NAME>HTMLEmbedded</NAME>
5415 </STRUCT>
5416 <STRUCT>
5417 <NAME>HTMLEmbeddedClass</NAME>
5418 </STRUCT>
5419 <STRUCT>
5420 <NAME>HTMLEngine</NAME>
5421 </STRUCT>
5422 <STRUCT>
5423 <NAME>HTMLEngineClass</NAME>
5424 </STRUCT>
5425 <STRUCT>
5426 <NAME>HTMLEngineEditSelectionUpdater</NAME>
5427 </STRUCT>
5428 <STRUCT>
5429 <NAME>HTMLEngineSaveState</NAME>
5430 </STRUCT>
5431 <TYPEDEF>
5432 <NAME>HTMLFontFace</NAME>
5433 typedef gchar HTMLFontFace;
5434 </TYPEDEF>
5435 <STRUCT>
5436 <NAME>HTMLFont</NAME>
5437 </STRUCT>
5438 <STRUCT>
5439 <NAME>HTMLFontManager</NAME>
5440 </STRUCT>
5441 <STRUCT>
5442 <NAME>HTMLFontSet</NAME>
5443 </STRUCT>
5444 <STRUCT>
5445 <NAME>HTMLForm</NAME>
5446 </STRUCT>
5447 <STRUCT>
5448 <NAME>HTMLGdkPainter</NAME>
5449 </STRUCT>
5450 <STRUCT>
5451 <NAME>HTMLGdkPainterClass</NAME>
5452 </STRUCT>
5453 <STRUCT>
5454 <NAME>HTMLHidden</NAME>
5455 </STRUCT>
5456 <STRUCT>
5457 <NAME>HTMLHiddenClass</NAME>
5458 </STRUCT>
5459 <STRUCT>
5460 <NAME>HTMLHSpace</NAME>
5461 </STRUCT>
5462 <STRUCT>
5463 <NAME>HTMLHSpaceClass</NAME>
5464 </STRUCT>
5465 <STRUCT>
5466 <NAME>HTMLIFrame</NAME>
5467 </STRUCT>
5468 <STRUCT>
5469 <NAME>HTMLIFrameClass</NAME>
5470 </STRUCT>
5471 <STRUCT>
5472 <NAME>HTMLImage</NAME>
5473 </STRUCT>
5474 <STRUCT>
5475 <NAME>HTMLImageAnimation</NAME>
5476 </STRUCT>
5477 <STRUCT>
5478 <NAME>HTMLImageClass</NAME>
5479 </STRUCT>
5480 <STRUCT>
5481 <NAME>HTMLImageFactory</NAME>
5482 </STRUCT>
5483 <STRUCT>
5484 <NAME>HTMLImageInput</NAME>
5485 </STRUCT>
5486 <STRUCT>
5487 <NAME>HTMLImageInputClass</NAME>
5488 </STRUCT>
5489 <STRUCT>
5490 <NAME>HTMLImagePointer</NAME>
5491 </STRUCT>
5492 <STRUCT>
5493 <NAME>HTMLInterval</NAME>
5494 </STRUCT>
5495 <STRUCT>
5496 <NAME>HTMLLinkText</NAME>
5497 </STRUCT>
5498 <STRUCT>
5499 <NAME>HTMLLinkTextClass</NAME>
5500 </STRUCT>
5501 <STRUCT>
5502 <NAME>HTMLList</NAME>
5503 </STRUCT>
5504 <STRUCT>
5505 <NAME>HTMLPainter</NAME>
5506 </STRUCT>
5507 <STRUCT>
5508 <NAME>HTMLPainterClass</NAME>
5509 </STRUCT>
5510 <STRUCT>
5511 <NAME>HTMLPoint</NAME>
5512 </STRUCT>
5513 <STRUCT>
5514 <NAME>HTMLPrinter</NAME>
5515 </STRUCT>
5516 <STRUCT>
5517 <NAME>HTMLPrinterClass</NAME>
5518 </STRUCT>
5519 <STRUCT>
5520 <NAME>HTMLRadio</NAME>
5521 </STRUCT>
5522 <STRUCT>
5523 <NAME>HTMLRadioClass</NAME>
5524 </STRUCT>
5525 <STRUCT>
5526 <NAME>HTMLReplace</NAME>
5527 </STRUCT>
5528 <STRUCT>
5529 <NAME>HTMLRule</NAME>
5530 </STRUCT>
5531 <STRUCT>
5532 <NAME>HTMLRuleClass</NAME>
5533 </STRUCT>
5534 <STRUCT>
5535 <NAME>HTMLSelect</NAME>
5536 </STRUCT>
5537 <STRUCT>
5538 <NAME>HTMLSelectClass</NAME>
5539 </STRUCT>
5540 <STRUCT>
5541 <NAME>HTMLSearch</NAME>
5542 </STRUCT>
5543 <STRUCT>
5544 <NAME>HTMLSettings</NAME>
5545 </STRUCT>
5546 <STRUCT>
5547 <NAME>HTMLStack</NAME>
5548 </STRUCT>
5549 <STRUCT>
5550 <NAME>HTMLStringTokenizer</NAME>
5551 </STRUCT>
5552 <STRUCT>
5553 <NAME>HTMLTable</NAME>
5554 </STRUCT>
5555 <STRUCT>
5556 <NAME>HTMLTableCell</NAME>
5557 </STRUCT>
5558 <STRUCT>
5559 <NAME>HTMLTableCellClass</NAME>
5560 </STRUCT>
5561 <STRUCT>
5562 <NAME>HTMLTableClass</NAME>
5563 </STRUCT>
5564 <STRUCT>
5565 <NAME>HTMLText</NAME>
5566 </STRUCT>
5567 <STRUCT>
5568 <NAME>HTMLTextArea</NAME>
5569 </STRUCT>
5570 <STRUCT>
5571 <NAME>HTMLTextAreaClass</NAME>
5572 </STRUCT>
5573 <STRUCT>
5574 <NAME>HTMLTextClass</NAME>
5575 </STRUCT>
5576 <STRUCT>
5577 <NAME>HTMLTextInput</NAME>
5578 </STRUCT>
5579 <STRUCT>
5580 <NAME>HTMLTextInputClass</NAME>
5581 </STRUCT>
5582 <STRUCT>
5583 <NAME>HTMLTextSlave</NAME>
5584 </STRUCT>
5585 <STRUCT>
5586 <NAME>HTMLTextSlaveClass</NAME>
5587 </STRUCT>
5588 <STRUCT>
5589 <NAME>HTMLTokenizer</NAME>
5590 </STRUCT>
5591 <STRUCT>
5592 <NAME>HTMLUndo</NAME>
5593 </STRUCT>
5594 <STRUCT>
5595 <NAME>HTMLUndoData</NAME>
5596 </STRUCT>
5597 <STRUCT>
5598 <NAME>HTMLUndoAction</NAME>
5599 </STRUCT>
5600 <STRUCT>
5601 <NAME>HTMLVSpace</NAME>
5602 </STRUCT>
5603 <STRUCT>
5604 <NAME>HTMLVSpaceClass</NAME>
5605 </STRUCT>
5606 <STRUCT>
5607 <NAME>SpellError</NAME>
5608 </STRUCT>
5609 <USER_FUNCTION>
5610 <NAME>HTMLObjectForallFunc</NAME>
5611 <RETURNS>void </RETURNS>
5612 HTMLObject        *self,
5613                                                  HTMLEngine        *e,
5614                                                  gpointer          data
5615 </USER_FUNCTION>
5616 <USER_FUNCTION>
5617 <NAME>HTMLFontManagerAllocFont</NAME>
5618 <RETURNS>gpointer </RETURNS>
5619 gchar            *face_name,
5620                                                  gdouble           size,
5621                                                  GtkHTMLFontStyle  style
5622 </USER_FUNCTION>
5623 <USER_FUNCTION>
5624 <NAME>HTMLFontManagerRefFont</NAME>
5625 <RETURNS>void </RETURNS>
5626 gpointer          font
5627 </USER_FUNCTION>
5628 <USER_FUNCTION>
5629 <NAME>HTMLFontManagerUnrefFont</NAME>
5630 <RETURNS>void </RETURNS>
5631 gpointer          font
5632 </USER_FUNCTION>
5633 <USER_FUNCTION>
5634 <NAME>HTMLStackFreeFunc</NAME>
5635 <RETURNS>void </RETURNS>
5636 gpointer          data
5637 </USER_FUNCTION>
5638 <USER_FUNCTION>
5639 <NAME>HTMLUndoFunc</NAME>
5640 <RETURNS>void </RETURNS>
5641 HTMLEngine        *engine,
5642                                                  HTMLUndoData      *data,
5643                                                  HTMLUndoDirection  dir
5644 </USER_FUNCTION>
5645 <USER_FUNCTION>
5646 <NAME>HTMLUndoDataDestroyFunc</NAME>
5647 <RETURNS>void </RETURNS>
5648 HTMLUndoData      *data
5649 </USER_FUNCTION>
5650 <TYPEDEF>
5651 <NAME>HTMLEngineSaveReceiverFn</NAME>
5652 typedef GtkHTMLSaveReceiverFn HTMLEngineSaveReceiverFn;
5653 </TYPEDEF>
5654 <MACRO>
5655 <NAME>HTML_UNDO_ACTION</NAME>
5656 #define HTML_UNDO_ACTION(x) ((HTMLUndoAction *) x)
5657 </MACRO>
5658 <STRUCT>
5659 <NAME>HTMLUndoAction</NAME>
5660 struct HTMLUndoAction {
5661
5662         gchar *description;             /* A text description of the action, to be displayed in the menus.  */
5663         HTMLUndoFunc function;          /* Function to call when the action is performed.  */
5664         HTMLUndoData *data;             /* Data to pass to the action function when it's called.  */
5665         guint position;                 /* Cursor position, to be set when the action is executed.  */
5666 };
5667 </STRUCT>
5668 <FUNCTION>
5669 <NAME>html_undo_action_new</NAME>
5670 <RETURNS>HTMLUndoAction  *</RETURNS>
5671 const gchar            *description,HTMLUndoFunc            function,HTMLUndoData           *data,guint                   position
5672 </FUNCTION>
5673 <FUNCTION>
5674 <NAME>html_undo_action_destroy</NAME>
5675 <RETURNS>void  </RETURNS>
5676 HTMLUndoAction         *action
5677 </FUNCTION>
5678 <MACRO>
5679 <NAME>HTML_UNDO_LIMIT</NAME>
5680 #define HTML_UNDO_LIMIT 1024
5681 </MACRO>
5682 <STRUCT>
5683 <NAME>HTMLUndo</NAME>
5684 struct HTMLUndo {
5685         /* List of undo actions (HTMLUndoAction).  */
5686         GList *undo_stack;
5687         guint undo_stack_size;
5688
5689         /* List of redo actions (HTMLUndoAction).  */
5690         GList *redo_stack;
5691         guint redo_stack_size;
5692
5693         /* these lists are stacks containing other
5694            levels undo/redo after calling html_undo_level_start */
5695         GSList *undo_levels;
5696         GSList *redo_levels;
5697         guint   undo_levels_size;
5698 };
5699 </STRUCT>
5700 <MACRO>
5701 <NAME>HTML_UNDO_DATA</NAME>
5702 #define HTML_UNDO_DATA(x) ((HTMLUndoData *) x)
5703 </MACRO>
5704 <STRUCT>
5705 <NAME>HTMLUndoData</NAME>
5706 struct HTMLUndoData {
5707         HTMLUndoDataDestroyFunc destroy;
5708         gint ref_count;
5709 };
5710 </STRUCT>
5711 <FUNCTION>
5712 <NAME>html_undo_new</NAME>
5713 <RETURNS>HTMLUndo           *</RETURNS>
5714 void
5715 </FUNCTION>
5716 <FUNCTION>
5717 <NAME>html_undo_destroy</NAME>
5718 <RETURNS>void  </RETURNS>
5719 HTMLUndo          *undo
5720 </FUNCTION>
5721 <FUNCTION>
5722 <NAME>html_undo_do_undo</NAME>
5723 <RETURNS>void  </RETURNS>
5724 HTMLUndo          *undo,HTMLEngine        *engine
5725 </FUNCTION>
5726 <FUNCTION>
5727 <NAME>html_undo_do_redo</NAME>
5728 <RETURNS>void  </RETURNS>
5729 HTMLUndo          *undo,HTMLEngine        *engine
5730 </FUNCTION>
5731 <FUNCTION>
5732 <NAME>html_undo_discard_redo</NAME>
5733 <RETURNS>void  </RETURNS>
5734 HTMLUndo          *undo
5735 </FUNCTION>
5736 <FUNCTION>
5737 <NAME>html_undo_add_undo_action</NAME>
5738 <RETURNS>void  </RETURNS>
5739 HTMLUndo          *undo,HTMLUndoAction    *action
5740 </FUNCTION>
5741 <FUNCTION>
5742 <NAME>html_undo_add_redo_action</NAME>
5743 <RETURNS>void  </RETURNS>
5744 HTMLUndo          *undo,HTMLUndoAction    *action
5745 </FUNCTION>
5746 <FUNCTION>
5747 <NAME>html_undo_add_action</NAME>
5748 <RETURNS>void  </RETURNS>
5749 HTMLUndo          *undo,HTMLUndoAction    *action,HTMLUndoDirection  dir
5750 </FUNCTION>
5751 <FUNCTION>
5752 <NAME>html_undo_level_begin</NAME>
5753 <RETURNS>void  </RETURNS>
5754 HTMLUndo          *undo,const gchar       *description
5755 </FUNCTION>
5756 <FUNCTION>
5757 <NAME>html_undo_level_end</NAME>
5758 <RETURNS>void  </RETURNS>
5759 HTMLUndo          *undo
5760 </FUNCTION>
5761 <FUNCTION>
5762 <NAME>html_undo_data_init</NAME>
5763 <RETURNS>void  </RETURNS>
5764 HTMLUndoData      *data
5765 </FUNCTION>
5766 <FUNCTION>
5767 <NAME>html_undo_data_ref</NAME>
5768 <RETURNS>void  </RETURNS>
5769 HTMLUndoData      *data
5770 </FUNCTION>
5771 <FUNCTION>
5772 <NAME>html_undo_data_unref</NAME>
5773 <RETURNS>void  </RETURNS>
5774 HTMLUndoData      *data
5775 </FUNCTION>
5776 <FUNCTION>
5777 <NAME>html_undo_direction_reverse</NAME>
5778 <RETURNS>HTMLUndoDirection  </RETURNS>
5779 HTMLUndoDirection  dir
5780 </FUNCTION>
5781 <STRUCT>
5782 <NAME>HTMLURL</NAME>
5783 struct HTMLURL {
5784         gchar *protocol;
5785         gchar *username;
5786         gchar *password;
5787         gchar *hostname;
5788         guint16 port;
5789         gchar *path;
5790         gchar *reference;
5791 };
5792 </STRUCT>
5793 <STRUCT>
5794 <NAME>HTMLURL</NAME>
5795 </STRUCT>
5796 <FUNCTION>
5797 <NAME>html_url_new</NAME>
5798 <RETURNS>HTMLURL  *</RETURNS>
5799 const gchar *s
5800 </FUNCTION>
5801 <FUNCTION>
5802 <NAME>html_url_destroy</NAME>
5803 <RETURNS>void  </RETURNS>
5804 HTMLURL *url
5805 </FUNCTION>
5806 <FUNCTION>
5807 <NAME>html_url_dup</NAME>
5808 <RETURNS>HTMLURL  *</RETURNS>
5809 const HTMLURL *url, HTMLURLDupFlags flags
5810 </FUNCTION>
5811 <FUNCTION>
5812 <NAME>html_url_set_protocol</NAME>
5813 <RETURNS>void  </RETURNS>
5814 HTMLURL *url, const gchar *protocol
5815 </FUNCTION>
5816 <FUNCTION>
5817 <NAME>html_url_set_username</NAME>
5818 <RETURNS>void  </RETURNS>
5819 HTMLURL *url, const gchar *username
5820 </FUNCTION>
5821 <FUNCTION>
5822 <NAME>html_url_set_password</NAME>
5823 <RETURNS>void  </RETURNS>
5824 HTMLURL *url, const gchar *password
5825 </FUNCTION>
5826 <FUNCTION>
5827 <NAME>html_url_set_hostname</NAME>
5828 <RETURNS>void  </RETURNS>
5829 HTMLURL *url, const gchar *password
5830 </FUNCTION>
5831 <FUNCTION>
5832 <NAME>html_url_set_port</NAME>
5833 <RETURNS>void  </RETURNS>
5834 HTMLURL *url, gushort port
5835 </FUNCTION>
5836 <FUNCTION>
5837 <NAME>html_url_set_path</NAME>
5838 <RETURNS>void  </RETURNS>
5839 HTMLURL *url, const gchar *path
5840 </FUNCTION>
5841 <FUNCTION>
5842 <NAME>html_url_set_reference</NAME>
5843 <RETURNS>void  </RETURNS>
5844 HTMLURL *url, const gchar *reference
5845 </FUNCTION>
5846 <FUNCTION>
5847 <NAME>html_url_get_protocol</NAME>
5848 <RETURNS>const gchar  *</RETURNS>
5849 const HTMLURL *url
5850 </FUNCTION>
5851 <FUNCTION>
5852 <NAME>html_url_get_username</NAME>
5853 <RETURNS>const gchar  *</RETURNS>
5854 const HTMLURL *url
5855 </FUNCTION>
5856 <FUNCTION>
5857 <NAME>html_url_get_password</NAME>
5858 <RETURNS>const gchar  *</RETURNS>
5859 const HTMLURL *url
5860 </FUNCTION>
5861 <FUNCTION>
5862 <NAME>html_url_get_hostname</NAME>
5863 <RETURNS>const gchar  *</RETURNS>
5864 const HTMLURL *url
5865 </FUNCTION>
5866 <FUNCTION>
5867 <NAME>html_url_get_port</NAME>
5868 <RETURNS>gushort  </RETURNS>
5869 const HTMLURL *url
5870 </FUNCTION>
5871 <FUNCTION>
5872 <NAME>html_url_get_path</NAME>
5873 <RETURNS>const gchar  *</RETURNS>
5874 const HTMLURL *url
5875 </FUNCTION>
5876 <FUNCTION>
5877 <NAME>html_url_get_reference</NAME>
5878 <RETURNS>const gchar  *</RETURNS>
5879 const HTMLURL *url
5880 </FUNCTION>
5881 <FUNCTION>
5882 <NAME>html_url_to_string</NAME>
5883 <RETURNS>gchar  *</RETURNS>
5884 const HTMLURL *url
5885 </FUNCTION>
5886 <FUNCTION>
5887 <NAME>html_url_append_path</NAME>
5888 <RETURNS>HTMLURL  *</RETURNS>
5889 const HTMLURL *url, const gchar *path
5890 </FUNCTION>
5891 <MACRO>
5892 <NAME>HTML_VSPACE</NAME>
5893 #define HTML_VSPACE(x) ((HTMLVSpace *)(x))
5894 </MACRO>
5895 <STRUCT>
5896 <NAME>HTMLVSpace</NAME>
5897 struct HTMLVSpace {
5898         HTMLObject object;
5899         HTMLClearType clear;
5900 };
5901 </STRUCT>
5902 <VARIABLE>
5903 <NAME>html_vspace_class</NAME>
5904 extern HTMLVSpaceClass html_vspace_class;
5905 </VARIABLE>
5906 <FUNCTION>
5907 <NAME>html_vspace_type_init</NAME>
5908 <RETURNS>void  </RETURNS>
5909 void
5910 </FUNCTION>
5911 <FUNCTION>
5912 <NAME>html_vspace_class_init</NAME>
5913 <RETURNS>void  </RETURNS>
5914 HTMLVSpaceClass *klass,HTMLType         type,guint            object_size
5915 </FUNCTION>
5916 <FUNCTION>
5917 <NAME>html_vspace_init</NAME>
5918 <RETURNS>void  </RETURNS>
5919 HTMLVSpace      *vspace,HTMLVSpaceClass *klass,HTMLClearType    clear
5920 </FUNCTION>
5921 <FUNCTION>
5922 <NAME>html_vspace_new</NAME>
5923 <RETURNS>HTMLObject  *</RETURNS>
5924 HTMLClearType    clear
5925 </FUNCTION>
5926 <MACRO>
5927 <NAME>LEFT_BORDER</NAME>
5928 #define LEFT_BORDER 10
5929 </MACRO>
5930 <MACRO>
5931 <NAME>RIGHT_BORDER</NAME>
5932 #define RIGHT_BORDER 10
5933 </MACRO>
5934 <MACRO>
5935 <NAME>TOP_BORDER</NAME>
5936 #define TOP_BORDER 10
5937 </MACRO>
5938 <MACRO>
5939 <NAME>BOTTOM_BORDER</NAME>
5940 #define BOTTOM_BORDER 10
5941 </MACRO>
5942 <STRUCT>
5943 <NAME>HTMLParser</NAME>
5944 struct HTMLParser {
5945
5946         HTMLEngine *engine;
5947
5948         gboolean parsing;
5949         HTMLTokenizer *ht;
5950         HTMLStringTokenizer *st;
5951
5952         HTMLObject *clue;
5953         HTMLObject *flow;
5954
5955         gint leftBorder;
5956         gint rightBorder;
5957         gint topBorder;
5958         gint bottomBorder;
5959
5960         /* Current indentation level.  */
5961         guint indent_level;
5962
5963         /* For the widget */
5964         gint width;
5965         gint height;
5966
5967         HTMLHAlignType divAlign;
5968
5969         /* Number of tokens parsed in the current time-slice */
5970         gint parseCount;
5971         gint granularity;
5972
5973         gboolean inTitle;
5974         gboolean inPre;
5975         gboolean inOption;
5976         gboolean inTextArea;
5977         gboolean eat_space;
5978
5979         gboolean newPage;
5980
5981         HTMLStack *font_style_stack; /* Font style stack, elements are GtkHTMLFontStyles.  */
5982         HTMLStack *font_face_stack;
5983         HTMLStack *color_stack; /* Color stack, elements are GdkColors.  */
5984         HTMLStack *clueflow_style_stack; /* Clueflow style stack, elements are HTMLClueFlowStyles.  */
5985
5986         gchar *url;
5987         gchar *target;
5988
5989         HTMLBlockStackElement *blockStack;
5990
5991         /* timer id to schedule paint events */
5992         guint updateTimer;
5993
5994         /* timer id for parsing routine */
5995         guint timerId;
5996
5997         /* FIXME: replace with a `gchar *'?  */
5998         GString *title;
5999
6000         gboolean writing;
6001
6002         /* The background pixmap, an HTMLImagePointer */
6003         gpointer bgPixmapPtr;
6004
6005         HTMLStack *listStack;     /* Stack of lists currently active */
6006         HTMLStack *embeddedStack; /* Stack of embedded "object"'s */
6007         HTMLStack *glossaryStack; /* HTMLGlossaryEntry */
6008
6009         /*
6010          * This list holds strings which are displayed in the view,
6011          * but are not actually contained in the HTML source.
6012          * e.g. The numbers in an ordered list.
6013          * FIXME?
6014          */
6015         GList *tempStrings;
6016
6017         HTMLForm *form;
6018         HTMLSelect *formSelect;
6019         HTMLTextArea *formTextArea;
6020         GList *formList;
6021         GString *formText;
6022         gboolean noWrap;
6023
6024         /* This is TRUE if we cannot insert a paragraph break (which is just an
6025            extra empty line).  It's set to FALSE as soon as some element is
6026            added to a flow.  The purpose is to avoid having paragraph breaks to
6027            be inserted in sequence, or after elements that have some vspace of
6028            their own.  */
6029         gboolean avoid_para;
6030
6031         /* This is TRUE if we want a paragraph break to be inserted before the
6032            next element.  */
6033         gboolean pending_para;
6034
6035         /* Alignment for the pending paragraph we are going to insert.  */
6036         HTMLHAlignType pending_para_alignment;
6037 };
6038 </STRUCT>
6039 <FUNCTION>
6040 <NAME>html_parser_new</NAME>
6041 <RETURNS>HTMLParser     *</RETURNS>
6042 HTMLEngine  *e
6043 </FUNCTION>
6044 <FUNCTION>
6045 <NAME>html_parser_destroy</NAME>
6046 <RETURNS>void  </RETURNS>
6047 HTMLParser  *p
6048 </FUNCTION>
6049 <FUNCTION>
6050 <NAME>html_parser_begin</NAME>
6051 <RETURNS>GtkHTMLStream  *</RETURNS>
6052 HTMLParser  *p,char        *content_type
6053 </FUNCTION>
6054 <FUNCTION>
6055 <NAME>html_parser_run</NAME>
6056 <RETURNS>void  </RETURNS>
6057 HTMLParser  *p
6058 </FUNCTION>
6059 <FUNCTION>
6060 <NAME>html_parser_stop</NAME>
6061 <RETURNS>void  </RETURNS>
6062 HTMLParser  *p
6063 </FUNCTION>
6064 <FUNCTION>
6065 <NAME>html_engine_copy</NAME>
6066 <RETURNS>void  </RETURNS>
6067 HTMLEngine  *e
6068 </FUNCTION>
6069 <FUNCTION>
6070 <NAME>html_engine_cut</NAME>
6071 <RETURNS>void  </RETURNS>
6072 HTMLEngine  *e
6073 </FUNCTION>
6074 <FUNCTION>
6075 <NAME>html_engine_cut_line</NAME>
6076 <RETURNS>void  </RETURNS>
6077 HTMLEngine  *e
6078 </FUNCTION>
6079 <FUNCTION>
6080 <NAME>html_engine_delete</NAME>
6081 <RETURNS>void  </RETURNS>
6082 HTMLEngine  *e
6083 </FUNCTION>
6084 <FUNCTION>
6085 <NAME>html_engine_paste</NAME>
6086 <RETURNS>void  </RETURNS>
6087 HTMLEngine  *e
6088 </FUNCTION>
6089 <FUNCTION>
6090 <NAME>html_engine_paste_object</NAME>
6091 <RETURNS>void  </RETURNS>
6092 HTMLEngine  *e,HTMLObject  *o,guint        len
6093 </FUNCTION>
6094 <FUNCTION>
6095 <NAME>html_engine_paste_text</NAME>
6096 <RETURNS>void  </RETURNS>
6097 HTMLEngine  *e,const gchar *text,guint        len
6098 </FUNCTION>
6099 <FUNCTION>
6100 <NAME>html_engine_insert_text</NAME>
6101 <RETURNS>void  </RETURNS>
6102 HTMLEngine  *e,const gchar *text,guint        len
6103 </FUNCTION>
6104 <FUNCTION>
6105 <NAME>html_engine_insert_object</NAME>
6106 <RETURNS>void  </RETURNS>
6107 HTMLEngine  *e,HTMLObject  *o,guint        len
6108 </FUNCTION>
6109 <FUNCTION>
6110 <NAME>html_engine_insert_link</NAME>
6111 <RETURNS>void  </RETURNS>
6112 HTMLEngine  *e,const gchar *url,const gchar *target
6113 </FUNCTION>
6114 <FUNCTION>
6115 <NAME>html_engine_insert_empty_paragraph</NAME>
6116 <RETURNS>void  </RETURNS>
6117 HTMLEngine  *e
6118 </FUNCTION>
6119 <FUNCTION>
6120 <NAME>html_engine_delete_n</NAME>
6121 <RETURNS>void  </RETURNS>
6122 HTMLEngine  *e,guint        len,gboolean     forward
6123 </FUNCTION>