Mercurial > pidgin.yaz

comparison src/gtkimhtml.c @ 1428:00b3d02a2168

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[gaim-migrate @ 1438] gtkhtml has gotten replaced by gtkimhtml. committer: Tailor Script <tailor@pidgin.im>
author Eric Warmenhoven <eric@warmenhoven.org>
date Fri, 26 Jan 2001 02:02:36 +0000
parents
children 5df631739769
comparison
equal deleted inserted replaced
1427:28278bd61403 1428:00b3d02a2168
1 /*
2 * GtkIMHtml
3 *
4 * Copyright (C) 2000, Eric Warmenhoven <warmenhoven@yahoo.com>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 *
20 */
21
22 #include "gtkimhtml.h"
23 #include <gtk/gtk.h>
24 #include <string.h>
25 #include <ctype.h>
26 #include <stdio.h>
27 #include <math.h>
28
29 #include "pixmaps/angel.xpm"
30 #include "pixmaps/bigsmile.xpm"
31 #include "pixmaps/burp.xpm"
32 #include "pixmaps/crossedlips.xpm"
33 #include "pixmaps/cry.xpm"
34 #include "pixmaps/embarrassed.xpm"
35 #include "pixmaps/kiss.xpm"
36 #include "pixmaps/moneymouth.xpm"
37 #include "pixmaps/sad.xpm"
38 #include "pixmaps/scream.xpm"
39 #include "pixmaps/smile.xpm"
40 #include "pixmaps/smile8.xpm"
41 #include "pixmaps/think.xpm"
42 #include "pixmaps/tongue.xpm"
43 #include "pixmaps/wink.xpm"
44 #include "pixmaps/yell.xpm"
45
46 #define DEFAULT_FONT_NAME "helvetica"
47 #define MAX_SIZE 7
48
49 gint font_sizes [] = { 80, 100, 120, 140, 200, 300, 400 };
50
51 #define BORDER_SIZE 3
52 #define MIN_HEIGHT 20
53 #define HR_HEIGHT 2
54
55 #define TYPE_TEXT 0
56 #define TYPE_SMILEY 1
57 #define TYPE_IMG 2
58 #define TYPE_SEP 3
59 #define TYPE_BR 4
60 #define TYPE_COMMENT 5
61
62 typedef struct _GtkIMHtmlBit GtkIMHtmlBit;
63 typedef struct _FontDetail FontDetail;
64
65 struct _GtkIMHtmlBit {
66 gint type;
67
68 gchar *text;
69 GdkPixmap *pm;
70 GdkBitmap *bm;
71
72 GdkFont *font;
73 GdkColor *fore;
74 GdkColor *back;
75 GdkColor *bg;
76 gboolean underline;
77 gboolean strike;
78 gchar *url;
79
80 GList *chunks;
81 };
82
83 struct _FontDetail {
84 gushort size;
85 gchar *face;
86 GdkColor *fore;
87 GdkColor *back;
88 };
89
90 struct line_info {
91 gint x;
92 gint y;
93 gint width;
94 gint height;
95 gint ascent;
96
97 gboolean selected;
98 gchar *sel_start;
99 gchar *sel_end;
100
101 gchar *text;
102 GtkIMHtmlBit *bit;
103 };
104
105 struct url_widget {
106 gint x;
107 gint y;
108 gint width;
109 gint height;
110 gchar *url;
111 };
112
113 static GtkLayoutClass *parent_class = NULL;
114
115 enum {
116 TARGET_STRING,
117 TARGET_TEXT,
118 TARGET_COMPOUND_TEXT
119 };
120
121 enum {
122 URL_CLICKED,
123 LAST_SIGNAL
124 };
125 static guint signals [LAST_SIGNAL] = { 0 };
126
127 static void gtk_imhtml_draw_bit (GtkIMHtml *, GtkIMHtmlBit *);
128 static GdkColor *gtk_imhtml_get_color (const gchar *);
129 static gint gtk_imhtml_motion_notify_event (GtkWidget *, GdkEventMotion *);
130
131 static void
132 gtk_imhtml_destroy (GtkObject *object)
133 {
134 GtkIMHtml *imhtml;
135
136 imhtml = GTK_IMHTML (object);
137
138 while (imhtml->bits) {
139 GtkIMHtmlBit *bit = imhtml->bits->data;
140 imhtml->bits = g_list_remove (imhtml->bits, bit);
141 if (bit->text)
142 g_free (bit->text);
143 if (bit->font)
144 gdk_font_unref (bit->font);
145 if (bit->fore)
146 gdk_color_free (bit->fore);
147 if (bit->back)
148 gdk_color_free (bit->back);
149 if (bit->bg)
150 gdk_color_free (bit->bg);
151 if (bit->url)
152 g_free (bit->url);
153 if (bit->pm)
154 gdk_pixmap_unref (bit->pm);
155 if (bit->bm)
156 gdk_bitmap_unref (bit->bm);
157 while (bit->chunks) {
158 GtkObject *obj = bit->chunks->data;
159 struct line_info *li = gtk_object_get_user_data (obj);
160 if (li->text)
161 g_free (li->text);
162 g_free (li);
163 bit->chunks = g_list_remove (bit->chunks, obj);
164 }
165 g_free (bit);
166 }
167
168 while (imhtml->urls) {
169 g_free (imhtml->urls->data);
170 imhtml->urls = g_list_remove (imhtml->urls, imhtml->urls->data);
171 }
172
173 if (imhtml->selected_text)
174 g_string_free (imhtml->selected_text, TRUE);
175
176 gdk_font_unref (imhtml->default_font);
177 gdk_color_free (imhtml->default_fg_color);
178
179 gdk_cursor_destroy (imhtml->hand_cursor);
180 gdk_cursor_destroy (imhtml->arrow_cursor);
181
182 g_hash_table_destroy (imhtml->smiley_hash);
183
184 if (GTK_OBJECT_CLASS (parent_class)->destroy != NULL)
185 (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
186 }
187
188 static void
189 gtk_imhtml_realize (GtkWidget *widget)
190 {
191 GtkIMHtml *imhtml;
192
193 g_return_if_fail (widget != NULL);
194 g_return_if_fail (GTK_IS_IMHTML (widget));
195
196 imhtml = GTK_IMHTML (widget);
197
198 if (GTK_WIDGET_CLASS (parent_class)->realize)
199 (* GTK_WIDGET_CLASS (parent_class)->realize) (widget);
200
201 widget->style = gtk_style_attach (widget->style, widget->window);
202 gdk_window_set_events (imhtml->layout.bin_window,
203 (gdk_window_get_events (imhtml->layout.bin_window)
204 | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK
205 | GDK_POINTER_MOTION_MASK | GDK_EXPOSURE_MASK));
206
207 gdk_window_set_cursor (widget->window, imhtml->arrow_cursor);
208
209 gdk_window_set_background (GTK_LAYOUT (imhtml)->bin_window, &GTK_WIDGET (imhtml)->style->white);
210 }
211
212 static void
213 gtk_imhtml_unrealize (GtkWidget *widget)
214 {
215 if (GTK_WIDGET_CLASS (parent_class)->unrealize)
216 (* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
217 }
218
219 static void
220 gtk_imhtml_draw (GtkWidget *widget,
221 GdkRectangle *area)
222 {
223 if (GTK_WIDGET_CLASS (parent_class)->draw)
224 (* GTK_WIDGET_CLASS (parent_class)->draw) (widget, area);
225 }
226
227 static void
228 gtk_imhtml_style_set (GtkWidget *widget,
229 GtkStyle *style)
230 {
231 GtkIMHtml *imhtml;
232
233 g_return_if_fail (widget != NULL);
234 g_return_if_fail (GTK_IS_IMHTML (widget));
235 if (!GTK_WIDGET_REALIZED (widget))
236 return;
237
238 imhtml = GTK_IMHTML (widget);
239
240 gdk_window_set_background (GTK_LAYOUT (imhtml)->bin_window, &GTK_WIDGET (imhtml)->style->white);
241 }
242
243 static gint
244 gtk_imhtml_expose (GtkWidget *widget,
245 GdkEventExpose *event)
246 {
247 if (GTK_WIDGET_CLASS (parent_class)->expose_event)
248 (* GTK_WIDGET_CLASS (parent_class)->expose_event) (widget, event);
249
250 return TRUE;
251 }
252
253 static void
254 gtk_imhtml_redraw_all (GtkIMHtml *imhtml)
255 {
256 GList *b;
257 GtkIMHtmlBit *bit;
258 GtkAdjustment *vadj;
259 gfloat oldvalue;
260
261 vadj = GTK_LAYOUT (imhtml)->vadjustment;
262 oldvalue = vadj->value / vadj->upper;
263
264 b = imhtml->bits;
265 while (b) {
266 bit = b->data;
267 b = g_list_next (b);
268 while (bit->chunks) {
269 GtkObject *obj = bit->chunks->data;
270 struct line_info *li = gtk_object_get_user_data (obj);
271 if (li->text)
272 g_free (li->text);
273 g_free (li);
274 bit->chunks = g_list_remove (bit->chunks, obj);
275 }
276 }
277
278 g_list_free (imhtml->line);
279 imhtml->line = NULL;
280
281 while (imhtml->urls) {
282 g_free (imhtml->urls->data);
283 imhtml->urls = g_list_remove (imhtml->urls, imhtml->urls->data);
284 }
285
286 while (GTK_LAYOUT (imhtml)->children)
287 gtk_container_remove (GTK_CONTAINER (imhtml),
288 *(GtkWidget **)GTK_LAYOUT (imhtml)->children->data);
289
290 imhtml->x = BORDER_SIZE;
291 imhtml->y = BORDER_SIZE + 10;
292 imhtml->llheight = 0;
293 imhtml->llascent = 0;
294
295 b = imhtml->bits;
296 while (b) {
297 gtk_imhtml_draw_bit (imhtml, b->data);
298 b = g_list_next (b);
299 }
300
301 gtk_adjustment_set_value (vadj, vadj->upper * oldvalue);
302 }
303
304 static void
305 gtk_imhtml_size_allocate (GtkWidget *widget,
306 GtkAllocation *allocation)
307 {
308 GtkIMHtml *imhtml;
309
310 g_return_if_fail (widget != NULL);
311 g_return_if_fail (GTK_IS_IMHTML (widget));
312 g_return_if_fail (allocation != NULL);
313
314 imhtml = GTK_IMHTML (widget);
315
316 if (GTK_WIDGET_CLASS (parent_class)->size_allocate)
317 ( *GTK_WIDGET_CLASS (parent_class)->size_allocate) (widget, allocation);
318
319 if (allocation->width == imhtml->xsize)
320 return;
321
322 imhtml->x = BORDER_SIZE;
323 imhtml->y = BORDER_SIZE + 10;
324 imhtml->llheight = 0;
325 imhtml->llascent = 0;
326
327 imhtml->xsize = allocation->width;
328
329 gtk_imhtml_redraw_all (imhtml);
330 }
331
332 static void
333 gtk_imhtml_select_none (GtkIMHtml *imhtml)
334 {
335 GList *bits;
336 GList *chunks;
337 GtkIMHtmlBit *bit;
338 struct line_info *chunk;
339 GtkWidget *darea;
340
341 g_return_if_fail (GTK_IS_IMHTML (imhtml));
342
343 bits = imhtml->bits;
344 while (bits) {
345 bit = bits->data;
346 chunks = bit->chunks;
347
348 while (chunks) {
349 darea = chunks->data;
350 chunk = gtk_object_get_user_data (GTK_OBJECT (darea));
351
352 if (chunk->selected)
353 gtk_widget_queue_draw (darea);
354 chunk->selected = FALSE;
355 chunk->sel_start = chunk->sel_end = NULL;
356
357 chunks = g_list_next (chunks);
358 }
359
360 bits = g_list_next (bits);
361 }
362 }
363
364 static gchar*
365 get_position (struct line_info *chunk,
366 gint x,
367 gboolean smileys)
368 {
369 gint width = x - chunk->x;
370 gchar *text;
371 gchar *pos;
372 guint total = 0;
373
374 switch (chunk->bit->type) {
375 case TYPE_TEXT:
376 case TYPE_COMMENT:
377 text = chunk->text;
378 break;
379 case TYPE_SMILEY:
380 if (smileys)
381 return NULL;
382 else
383 text = chunk->text;
384 break;
385 default:
386 return NULL;
387 break;
388 }
389
390 if (width <= 0)
391 return text;
392
393 for (pos = text; *pos != '\0'; pos++) {
394 gint char_width = gdk_text_width (chunk->bit->font, pos, 1);
395 if ((width > total) && (width <= total + char_width)) {
396 if (width < total + (char_width >> 1))
397 return pos;
398 else
399 return ++pos;
400 }
401 total += char_width;
402 }
403
404 return pos;
405 }
406
407 static GString*
408 append_to_sel (GString *string,
409 struct line_info *chunk,
410 gboolean smileys)
411 {
412 GString *new_string;
413 gchar *buf;
414 gchar *start;
415 gint length;
416
417 switch (chunk->bit->type) {
418 case TYPE_TEXT:
419 case TYPE_COMMENT:
420 start = (chunk->sel_start == NULL) ? chunk->text : chunk->sel_start;
421 length = (chunk->sel_end == NULL) ? strlen (start) : chunk->sel_end - start;
422 if (length <= 0)
423 return string;
424 buf = g_strndup (start, length);
425 break;
426 case TYPE_SMILEY:
427 if (smileys) {
428 start = (chunk->sel_start == NULL) ? chunk->bit->text : chunk->sel_start;
429 length = (chunk->sel_end == NULL) ? strlen (start) : chunk->sel_end - start;
430 if (length <= 0)
431 return string;
432 buf = g_strndup (start, length);
433 } else {
434 start = (chunk->sel_start == NULL) ? chunk->text : chunk->sel_start;
435 length = (chunk->sel_end == NULL) ? strlen (start) : chunk->sel_end - start;
436 if (length <= 0)
437 return string;
438 buf = g_strndup (start, length);
439 }
440 break;
441 case TYPE_BR:
442 buf = g_strdup ("\n");
443 break;
444 default:
445 return string;
446 break;
447 }
448
449 new_string = g_string_append (string, buf);
450 g_free (buf);
451
452 return new_string;
453 }
454
455 #define COORDS_IN_CHUNK(xx, yy) (((xx) < chunk->x + chunk->width) && \
456 ((yy) < chunk->y + chunk->height))
457
458 static void
459 gtk_imhtml_select_bits (GtkIMHtml *imhtml)
460 {
461 GList *bits;
462 GList *chunks;
463 GtkIMHtmlBit *bit;
464 struct line_info *chunk;
465 GtkWidget *darea;
466
467 guint startx = imhtml->sel_startx,
468 starty = imhtml->sel_starty,
469 endx = imhtml->sel_endx,
470 endy = imhtml->sel_endy;
471 gchar *new_pos;
472 gint selection = 0;
473 gboolean smileys = imhtml->smileys;
474 gboolean redraw = FALSE;
475 gboolean got_start = FALSE;
476 gboolean got_end = FALSE;
477
478 g_return_if_fail (GTK_IS_IMHTML (imhtml));
479
480 if (!imhtml->selection)
481 return;
482
483 if (imhtml->selected_text) {
484 g_string_free (imhtml->selected_text, TRUE);
485 imhtml->selected_text = g_string_new ("");
486 }
487
488 bits = imhtml->bits;
489 while (bits) {
490 bit = bits->data;
491 chunks = bit->chunks;
492
493 while (chunks) {
494 darea = chunks->data;
495 chunk = gtk_object_get_user_data (GTK_OBJECT (darea));
496
497 switch (selection) {
498 case 0:
499 if (COORDS_IN_CHUNK (startx, starty)) {
500 new_pos = get_position (chunk, startx, smileys);
501 if ( !chunk->selected ||
502 (chunk->sel_start != new_pos) ||
503 (chunk->sel_end != NULL))
504 redraw = TRUE;
505 chunk->selected = TRUE;
506 chunk->sel_start = new_pos;
507 chunk->sel_end = NULL;
508 selection++;
509 got_start = TRUE;
510 }
511
512 if (COORDS_IN_CHUNK (endx, endy)) {
513 if (got_start) {
514 new_pos = get_position (chunk, endx, smileys);
515 if (chunk->sel_end != new_pos)
516 redraw = TRUE;
517 if (chunk->sel_start > new_pos) {
518 chunk->sel_end = chunk->sel_start;
519 chunk->sel_start = new_pos;
520 } else
521 chunk->sel_end = new_pos;
522 selection = 2;
523 got_end = TRUE;
524 } else {
525 new_pos = get_position (chunk, endx, smileys);
526 if ( !chunk->selected ||
527 (chunk->sel_start != new_pos) ||
528 (chunk->sel_end != NULL))
529 redraw = TRUE;
530 chunk->selected = TRUE;
531 chunk->sel_start = new_pos;
532 chunk->sel_end = NULL;
533 selection++;
534 got_end = TRUE;
535 }
536 } else if (!COORDS_IN_CHUNK (startx, starty) && !got_start) {
537 if (chunk->selected)
538 redraw = TRUE;
539 chunk->selected = FALSE;
540 chunk->sel_start = chunk->text;
541 chunk->sel_end = NULL;
542 }
543
544 break;
545 case 1:
546 if (!got_start && COORDS_IN_CHUNK (startx, starty)) {
547 new_pos = get_position (chunk, startx, smileys);
548 if ( !chunk->selected ||
549 (chunk->sel_end != new_pos) ||
550 (chunk->sel_start != chunk->text))
551 redraw = TRUE;
552 chunk->selected = TRUE;
553 chunk->sel_start = chunk->text;
554 chunk->sel_end = new_pos;
555 selection++;
556 got_start = TRUE;
557 } else if (!got_end && COORDS_IN_CHUNK (endx, endy)) {
558 new_pos = get_position (chunk, endx, smileys);
559 if ( !chunk->selected ||
560 (chunk->sel_end != new_pos) ||
561 (chunk->sel_start != chunk->text))
562 redraw = TRUE;
563 chunk->selected = TRUE;
564 chunk->sel_start = chunk->text;
565 chunk->sel_end = new_pos;
566 selection++;
567 got_end = TRUE;
568 } else {
569 if ( !chunk->selected ||
570 (chunk->sel_end != new_pos) ||
571 (chunk->sel_start != NULL))
572 redraw = TRUE;
573 chunk->selected = TRUE;
574 chunk->sel_start = chunk->text;
575 chunk->sel_end = NULL;
576 }
577
578 break;
579 case 2:
580 if ( chunk->selected ||
581 (chunk->sel_start != chunk->text) ||
582 (chunk->sel_end != NULL))
583 redraw = TRUE;
584 chunk->selected = FALSE;
585 chunk->sel_start = chunk->text;
586 chunk->sel_end = NULL;
587 break;
588 }
589
590 if (chunk->selected == TRUE)
591 imhtml->selected_text = append_to_sel (imhtml->selected_text,
592 chunk, smileys);
593
594 if (redraw) {
595 gtk_widget_queue_draw (darea);
596 redraw = FALSE;
597 }
598
599 chunks = g_list_next (chunks);
600 }
601
602 bits = g_list_next (bits);
603 }
604 }
605
606 static gint
607 scroll_timeout (GtkIMHtml *imhtml)
608 {
609 GdkEventMotion event;
610 gint x, y;
611 GdkModifierType mask;
612
613 imhtml->scroll_timer = 0;
614
615 gdk_window_get_pointer (imhtml->layout.bin_window, &x, &y, &mask);
616
617 if (mask & GDK_BUTTON1_MASK) {
618 event.is_hint = 0;
619 event.x = x;
620 event.y = y;
621 event.state = mask;
622
623 gtk_imhtml_motion_notify_event (GTK_WIDGET (imhtml), &event);
624 }
625
626 return FALSE;
627 }
628
629 static gint
630 gtk_imhtml_motion_notify_event (GtkWidget *widget,
631 GdkEventMotion *event)
632 {
633 gint x, y;
634 GdkModifierType state;
635 GtkIMHtml *imhtml = GTK_IMHTML (widget);
636 GtkAdjustment *vadj = GTK_LAYOUT (widget)->vadjustment;
637 GtkAdjustment *hadj = GTK_LAYOUT (widget)->hadjustment;
638
639 if (event->is_hint)
640 gdk_window_get_pointer (event->window, &x, &y, &state);
641 else {
642 x = event->x + hadj->value;
643 y = event->y + vadj->value;
644 state = event->state;
645 }
646
647 if (state & GDK_BUTTON1_MASK) {
648 gint diff;
649 gint height = vadj->page_size;
650 gint yy = y - vadj->value;
651
652 if (((yy < 0) || (yy > height)) &&
653 (imhtml->scroll_timer == 0) &&
654 (vadj->upper > vadj->page_size)) {
655 imhtml->scroll_timer = gtk_timeout_add (100,
656 (GtkFunction) scroll_timeout,
657 imhtml);
658 diff = (yy < 0) ? (yy >> 1) : ((yy - height) >> 1);
659 gtk_adjustment_set_value (vadj,
660 MIN (vadj->value + diff, vadj->upper - height + 20));
661 }
662
663 if (imhtml->selection) {
664 imhtml->sel_endx = MAX (x, 0);
665 imhtml->sel_endy = MAX (y, 0);
666 gtk_imhtml_select_bits (imhtml);
667 }
668 } else {
669 GList *urls = imhtml->urls;
670 struct url_widget *uw;
671
672 while (urls) {
673 uw = (struct url_widget *) urls->data;
674 if ((x > uw->x) && (x < uw->x + uw->width) &&
675 (y > uw->y) && (y < uw->y + uw->height)) {
676 gdk_window_set_cursor (imhtml->layout.bin_window, imhtml->hand_cursor);
677 return TRUE;
678 }
679 urls = g_list_next (urls);
680 }
681 }
682
683 gdk_window_set_cursor (imhtml->layout.bin_window, imhtml->arrow_cursor);
684
685 return TRUE;
686 }
687
688 static gint
689 gtk_imhtml_button_press_event (GtkWidget *widget,
690 GdkEventButton *event)
691 {
692 GtkIMHtml *imhtml = GTK_IMHTML (widget);
693 GtkAdjustment *vadj = GTK_LAYOUT (widget)->vadjustment;
694 GtkAdjustment *hadj = GTK_LAYOUT (widget)->hadjustment;
695 gint x, y;
696
697 if (event->button == 1) {
698 x = event->x + hadj->value;
699 y = event->y + vadj->value;
700
701 imhtml->sel_startx = x;
702 imhtml->sel_starty = y;
703 imhtml->selection = TRUE;
704 gtk_imhtml_select_none (imhtml);
705 }
706
707 return TRUE;
708 }
709
710 static gint
711 gtk_imhtml_button_release_event (GtkWidget *widget,
712 GdkEventButton *event)
713 {
714 GtkIMHtml *imhtml = GTK_IMHTML (widget);
715 GtkAdjustment *vadj = GTK_LAYOUT (widget)->vadjustment;
716 GtkAdjustment *hadj = GTK_LAYOUT (widget)->hadjustment;
717 gint x, y;
718
719 if ((event->button == 1) && imhtml->selection) {
720 x = event->x + hadj->value;
721 y = event->y + vadj->value;
722
723 if ((x == imhtml->sel_startx) && (y == imhtml->sel_starty)) {
724 imhtml->sel_startx = imhtml->sel_starty = 0;
725 imhtml->selection = FALSE;
726 gtk_imhtml_select_none (imhtml);
727 } else {
728 imhtml->sel_endx = MAX (x, 0);
729 imhtml->sel_endy = MAX (y, 0);
730 gtk_imhtml_select_bits (imhtml);
731 }
732
733 gtk_selection_owner_set (widget, GDK_SELECTION_PRIMARY, event->time);
734 }
735
736 return TRUE;
737 }
738
739 static void
740 gtk_imhtml_selection_get (GtkWidget *widget,
741 GtkSelectionData *sel_data,
742 guint sel_info,
743 guint32 time)
744 {
745 GtkIMHtml *imhtml;
746 gchar *string;
747 gint length;
748
749 g_return_if_fail (widget != NULL);
750 g_return_if_fail (GTK_IS_IMHTML (widget));
751 g_return_if_fail (sel_data->selection == GDK_SELECTION_PRIMARY);
752
753 imhtml = GTK_IMHTML (widget);
754
755 g_return_if_fail (imhtml->selected_text != NULL);
756 g_return_if_fail (imhtml->selected_text->str != NULL);
757
758 if (imhtml->selected_text->len <= 0) {
759 string = NULL;
760 length = 0;
761 } else {
762 string = g_strdup (imhtml->selected_text->str);
763 length = strlen (string);
764 }
765
766 if (sel_info == TARGET_STRING) {
767 gtk_selection_data_set (sel_data,
768 GDK_SELECTION_TYPE_STRING,
769 8 * sizeof (gchar),
770 (guchar *) string,
771 length);
772 } else if ((sel_info == TARGET_TEXT) || (sel_info == TARGET_COMPOUND_TEXT)) {
773 guchar *text;
774 GdkAtom encoding;
775 gint format;
776 gint new_length;
777
778 gdk_string_to_compound_text (string, &encoding, &format, &text, &new_length);
779 gtk_selection_data_set (sel_data, encoding, format, text, new_length);
780 gdk_free_compound_text (text);
781 }
782
783 if (string)
784 g_free (string);
785 }
786
787 static gint
788 gtk_imhtml_selection_clear_event (GtkWidget *widget,
789 GdkEventSelection *event)
790 {
791 GtkIMHtml *imhtml;
792
793 g_return_val_if_fail (widget != NULL, FALSE);
794 g_return_val_if_fail (GTK_IS_IMHTML (widget), FALSE);
795 g_return_val_if_fail (event != NULL, FALSE);
796 g_return_val_if_fail (event->selection == GDK_SELECTION_PRIMARY, TRUE);
797
798 if (!gtk_selection_clear (widget, event))
799 return FALSE;
800
801 imhtml = GTK_IMHTML (widget);
802
803 gtk_imhtml_select_none (imhtml);
804
805 return TRUE;
806 }
807
808 static void
809 gtk_imhtml_set_scroll_adjustments (GtkLayout *layout,
810 GtkAdjustment *hadj,
811 GtkAdjustment *vadj)
812 {
813 if (parent_class->set_scroll_adjustments)
814 (* parent_class->set_scroll_adjustments) (layout, hadj, vadj);
815 }
816
817 static void
818 gtk_imhtml_class_init (GtkIMHtmlClass *class)
819 {
820 GtkObjectClass *object_class;
821 GtkWidgetClass *widget_class;
822 GtkLayoutClass *layout_class;
823
824 object_class = (GtkObjectClass*) class;
825 widget_class = (GtkWidgetClass*) class;
826 layout_class = (GtkLayoutClass*) class;
827
828 parent_class = gtk_type_class (GTK_TYPE_LAYOUT);
829
830 signals [URL_CLICKED] =
831 gtk_signal_new ("url_clicked",
832 GTK_RUN_FIRST,
833 object_class->type,
834 GTK_SIGNAL_OFFSET (GtkIMHtmlClass, url_clicked),
835 gtk_marshal_NONE__POINTER,
836 GTK_TYPE_NONE, 1,
837 GTK_TYPE_POINTER);
838
839 gtk_object_class_add_signals (object_class, signals, LAST_SIGNAL);
840
841 object_class->destroy = gtk_imhtml_destroy;
842
843 widget_class->realize = gtk_imhtml_realize;
844 widget_class->unrealize = gtk_imhtml_unrealize;
845 widget_class->draw = gtk_imhtml_draw;
846 widget_class->style_set = gtk_imhtml_style_set;
847 widget_class->expose_event = gtk_imhtml_expose;
848 widget_class->size_allocate = gtk_imhtml_size_allocate;
849 widget_class->motion_notify_event = gtk_imhtml_motion_notify_event;
850 widget_class->button_press_event = gtk_imhtml_button_press_event;
851 widget_class->button_release_event = gtk_imhtml_button_release_event;
852 widget_class->selection_get = gtk_imhtml_selection_get;
853 widget_class->selection_clear_event = gtk_imhtml_selection_clear_event;
854
855 layout_class->set_scroll_adjustments = gtk_imhtml_set_scroll_adjustments;
856 }
857
858 static GdkFont*
859 gtk_imhtml_font_load (GtkIMHtml *imhtml,
860 gchar *name,
861 gboolean bold,
862 gboolean italics,
863 gint fontsize)
864 {
865 gchar buf [16 * 1024];
866 GdkFont *font;
867 gint size = fontsize ? font_sizes [MIN (fontsize, MAX_SIZE) - 1] : 120;
868
869 g_snprintf (buf, sizeof (buf), "-*-%s-%s-%c-*-*-*-%d-*-*-*-*-*-*",
870 name ? name : DEFAULT_FONT_NAME,
871 bold ? "bold" : "medium",
872 italics ? 'i' : 'r',
873 size);
874 font = gdk_font_load (buf);
875 if (font)
876 return font;
877
878 if (italics) {
879 g_snprintf (buf, sizeof (buf), "-*-%s-%s-%c-*-*-*-%d-*-*-*-*-*-*",
880 name ? name : DEFAULT_FONT_NAME,
881 bold ? "bold" : "medium",
882 'o',
883 size);
884 font = gdk_font_load (buf);
885 if (font)
886 return font;
887
888 if (bold) {
889 g_snprintf (buf, sizeof (buf), "-*-%s-%s-%c-*-*-*-%d-*-*-*-*-*-*",
890 name ? name : DEFAULT_FONT_NAME,
891 "bold",
892 'r',
893 size);
894 font = gdk_font_load (buf);
895 if (font)
896 return font;
897 }
898 }
899
900 if (bold) {
901 g_snprintf (buf, sizeof (buf), "-*-%s-%s-%c-*-*-*-%d-*-*-*-*-*-*",
902 name ? name : DEFAULT_FONT_NAME,
903 "medium",
904 italics ? 'i' : 'r',
905 size);
906 font = gdk_font_load (buf);
907 if (font)
908 return font;
909
910 if (italics) {
911 g_snprintf (buf, sizeof (buf), "-*-%s-%s-%c-*-*-*-%d-*-*-*-*-*-*",
912 name ? name : DEFAULT_FONT_NAME,
913 "medium",
914 'o',
915 size);
916 font = gdk_font_load (buf);
917 if (font)
918 return font;
919 }
920 }
921
922 if (!bold && !italics) {
923 g_snprintf (buf, sizeof (buf), "-*-%s-medium-r-*-*-*-%d-*-*-*-*-*-*",
924 name ? name : DEFAULT_FONT_NAME,
925 size);
926 font = gdk_font_load (buf);
927 if (font)
928 return font;
929 }
930
931 g_snprintf (buf, sizeof (buf), "-*-%s-medium-r-*-*-*-%d-*-*-*-*-*-*",
932 DEFAULT_FONT_NAME,
933 size);
934 font = gdk_font_load (buf);
935 if (font)
936 return font;
937
938 if (imhtml->default_font)
939 return gdk_font_ref (imhtml->default_font);
940
941 return NULL;
942 }
943
944 static void
945 gtk_imhtml_init (GtkIMHtml *imhtml)
946 {
947 static const GtkTargetEntry targets [] = {
948 { "STRING", 0, TARGET_STRING },
949 { "TEXT", 0, TARGET_TEXT },
950 { "COMPOUND_TEXT", 0, TARGET_COMPOUND_TEXT }
951 };
952
953 imhtml->default_font = gtk_imhtml_font_load (imhtml, NULL, FALSE, FALSE, 0);
954 if (imhtml->default_font == NULL)
955 g_warning ("GtkIMHtml: Could not load default font!");
956 imhtml->default_fg_color = gdk_color_copy (&GTK_WIDGET (imhtml)->style->black);
957 imhtml->hand_cursor = gdk_cursor_new (GDK_HAND2);
958 imhtml->arrow_cursor = gdk_cursor_new (GDK_LEFT_PTR);
959
960 GTK_WIDGET_SET_FLAGS (GTK_WIDGET (imhtml), GTK_CAN_FOCUS);
961 gtk_selection_add_targets (GTK_WIDGET (imhtml), GDK_SELECTION_PRIMARY, targets, 3);
962 }
963
964 GtkType
965 gtk_imhtml_get_type (void)
966 {
967 static GtkType imhtml_type = 0;
968
969 if (!imhtml_type) {
970 static const GtkTypeInfo imhtml_info = {
971 "GtkIMHtml",
972 sizeof (GtkIMHtml),
973 sizeof (GtkIMHtmlClass),
974 (GtkClassInitFunc) gtk_imhtml_class_init,
975 (GtkObjectInitFunc) gtk_imhtml_init,
976 NULL,
977 NULL,
978 NULL
979 };
980
981 imhtml_type = gtk_type_unique (GTK_TYPE_LAYOUT, &imhtml_info);
982 }
983
984 return imhtml_type;
985 }
986
987 static void
988 gtk_imhtml_init_smiley_hash (GtkIMHtml *imhtml)
989 {
990 g_return_if_fail (imhtml != NULL);
991 g_return_if_fail (GTK_IS_IMHTML (imhtml));
992
993 imhtml->smiley_hash = g_hash_table_new (g_str_hash, g_str_equal);
994
995 gtk_imhtml_associate_smiley (imhtml, ":)", smile_xpm);
996 gtk_imhtml_associate_smiley (imhtml, ":-)", smile_xpm);
997
998 gtk_imhtml_associate_smiley (imhtml, ":(", sad_xpm);
999 gtk_imhtml_associate_smiley (imhtml, ":-(", sad_xpm);
1000
1001 gtk_imhtml_associate_smiley (imhtml, ";)", wink_xpm);
1002 gtk_imhtml_associate_smiley (imhtml, ";-)", wink_xpm);
1003
1004 gtk_imhtml_associate_smiley (imhtml, ":-p", tongue_xpm);
1005 gtk_imhtml_associate_smiley (imhtml, ":-P", tongue_xpm);
1006
1007 gtk_imhtml_associate_smiley (imhtml, "=-O", scream_xpm);
1008 gtk_imhtml_associate_smiley (imhtml, ":-*", kiss_xpm);
1009 gtk_imhtml_associate_smiley (imhtml, ">:o", yell_xpm);
1010 gtk_imhtml_associate_smiley (imhtml, "8-)", smile8_xpm);
1011 gtk_imhtml_associate_smiley (imhtml, ":-$", moneymouth_xpm);
1012 gtk_imhtml_associate_smiley (imhtml, ":-!", burp_xpm);
1013 gtk_imhtml_associate_smiley (imhtml, ":-[", embarrassed_xpm);
1014 gtk_imhtml_associate_smiley (imhtml, ":'(", cry_xpm);
1015
1016 gtk_imhtml_associate_smiley (imhtml, ":-/", think_xpm);
1017 gtk_imhtml_associate_smiley (imhtml, ":-\\", think_xpm);
1018
1019 gtk_imhtml_associate_smiley (imhtml, ":-X", crossedlips_xpm);
1020 gtk_imhtml_associate_smiley (imhtml, ":-D", bigsmile_xpm);
1021 gtk_imhtml_associate_smiley (imhtml, "O:-)", angel_xpm);
1022 }
1023
1024 GtkWidget*
1025 gtk_imhtml_new (GtkAdjustment *hadj,
1026 GtkAdjustment *vadj)
1027 {
1028 GtkIMHtml *imhtml = gtk_type_new (GTK_TYPE_IMHTML);
1029
1030 gtk_imhtml_set_adjustments (imhtml, hadj, vadj);
1031
1032 imhtml->bits = NULL;
1033 imhtml->urls = NULL;
1034
1035 imhtml->x = BORDER_SIZE;
1036 imhtml->y = BORDER_SIZE + 10;
1037 imhtml->llheight = 0;
1038 imhtml->llascent = 0;
1039 imhtml->line = NULL;
1040
1041 imhtml->selected_text = g_string_new ("");
1042 imhtml->scroll_timer = 0;
1043
1044 imhtml->img = NULL;
1045
1046 imhtml->smileys = TRUE;
1047 imhtml->comments = FALSE;
1048
1049 imhtml->smin = G_MAXINT;
1050 imhtml->smax = 0;
1051 gtk_imhtml_init_smiley_hash (imhtml);
1052
1053 return GTK_WIDGET (imhtml);
1054 }
1055
1056 void
1057 gtk_imhtml_set_adjustments (GtkIMHtml *imhtml,
1058 GtkAdjustment *hadj,
1059 GtkAdjustment *vadj)
1060 {
1061 gtk_layout_set_hadjustment (GTK_LAYOUT (imhtml), hadj);
1062 gtk_layout_set_vadjustment (GTK_LAYOUT (imhtml), vadj);
1063 }
1064
1065 void
1066 gtk_imhtml_set_defaults (GtkIMHtml *imhtml,
1067 GdkFont *font,
1068 GdkColor *fg_color)
1069 {
1070 g_return_if_fail (imhtml != NULL);
1071 g_return_if_fail (GTK_IS_IMHTML (imhtml));
1072
1073 if (font) {
1074 if (imhtml->default_font)
1075 gdk_font_unref (imhtml->default_font);
1076 imhtml->default_font = gdk_font_ref (font);
1077 }
1078
1079 if (fg_color) {
1080 if (imhtml->default_fg_color)
1081 gdk_color_free (imhtml->default_fg_color);
1082 imhtml->default_fg_color = gdk_color_copy (fg_color);
1083 }
1084 }
1085
1086 void
1087 gtk_imhtml_set_img_handler (GtkIMHtml *imhtml,
1088 GtkIMHtmlImage handler)
1089 {
1090 g_return_if_fail (imhtml != NULL);
1091 g_return_if_fail (GTK_IS_IMHTML (imhtml));
1092
1093 imhtml->img = handler;
1094 }
1095
1096 void
1097 gtk_imhtml_associate_smiley (GtkIMHtml *imhtml,
1098 gchar *text,
1099 gchar **xpm)
1100 {
1101 g_return_if_fail (imhtml != NULL);
1102 g_return_if_fail (GTK_IS_IMHTML (imhtml));
1103 g_return_if_fail (text != NULL);
1104
1105 if (strlen (text) < imhtml->smin)
1106 imhtml->smin = strlen (text);
1107
1108 if (strlen (text) > imhtml->smax)
1109 imhtml->smax = strlen (text);
1110
1111 if (xpm == NULL)
1112 g_hash_table_remove (imhtml->smiley_hash, text);
1113 else
1114 g_hash_table_insert (imhtml->smiley_hash, text, xpm);
1115 }
1116
1117 static gint
1118 draw_text (GtkWidget *widget,
1119 GdkEvent *event,
1120 gpointer data)
1121 {
1122 GtkIMHtmlBit *bit;
1123 struct line_info *line;
1124 GdkGC *gc;
1125 GdkColormap *cmap;
1126
1127 line = gtk_object_get_user_data (GTK_OBJECT (widget));
1128 bit = line->bit;
1129 gc = gdk_gc_new (widget->window);
1130 cmap = gdk_colormap_new (gdk_visual_get_best (), FALSE);
1131
1132 if (bit->bg != NULL) {
1133 gdk_color_alloc (cmap, bit->bg);
1134 gdk_gc_set_foreground (gc, bit->bg);
1135 } else
1136 gdk_gc_copy (gc, widget->style->white_gc);
1137
1138 gdk_draw_rectangle (widget->window, gc, TRUE, 0, 0,
1139 widget->allocation.width,
1140 widget->allocation.height);
1141
1142 if (!line->text) {
1143 gdk_colormap_unref (cmap);
1144 gdk_gc_unref (gc);
1145 return TRUE;
1146 }
1147
1148 if (bit->back != NULL) {
1149 gdk_color_alloc (cmap, bit->back);
1150 gdk_gc_set_foreground (gc, bit->back);
1151 gdk_draw_rectangle (widget->window, gc, TRUE, 0, 0,
1152 gdk_string_width (bit->font, line->text),
1153 widget->allocation.height);
1154 }
1155
1156 if (line->selected) {
1157 gint width, x;
1158 gchar *start, *end;
1159 GdkColor col;
1160
1161 if ((line->sel_start > line->sel_end) && (line->sel_end != NULL)) {
1162 start = line->sel_end;
1163 end = line->sel_start;
1164 } else {
1165 start = line->sel_start;
1166 end = line->sel_end;
1167 }
1168
1169 if (start == NULL)
1170 x = 0;
1171 else
1172 x = gdk_text_width (bit->font, line->text, start - line->text);
1173
1174 if (end == NULL)
1175 width = gdk_string_width (bit->font, line->text) - x;
1176 else
1177 width = gdk_text_width (bit->font, line->text, end - line->text) - x;
1178
1179 col.red = col.green = col.blue = 0xc000;
1180 gdk_color_alloc (cmap, &col);
1181 gdk_gc_set_foreground (gc, &col);
1182
1183 gdk_draw_rectangle (widget->window, gc, TRUE, x, 0,
1184 width, widget->allocation.height);
1185 }
1186
1187 if (bit->url) {
1188 GdkColor *tc = gtk_imhtml_get_color ("#0000a0");
1189 gdk_color_alloc (cmap, tc);
1190 gdk_gc_set_foreground (gc, tc);
1191 gdk_color_free (tc);
1192 } else if (bit->fore) {
1193 gdk_color_alloc (cmap, bit->fore);
1194 gdk_gc_set_foreground (gc, bit->fore);
1195 } else
1196 gdk_gc_copy (gc, widget->style->black_gc);
1197
1198 gdk_draw_string (widget->window, bit->font, gc,
1199 0, line->ascent, line->text);
1200
1201 if (bit->underline || bit->url)
1202 gdk_draw_rectangle (widget->window, gc, TRUE,
1203 0, line->ascent + 1,
1204 gdk_string_width (bit->font, line->text), 1);
1205 if (bit->strike)
1206 gdk_draw_rectangle (widget->window, gc, TRUE,
1207 0, line->ascent - (bit->font->ascent >> 1),
1208 gdk_string_width (bit->font, line->text), 1);
1209
1210 gdk_colormap_unref (cmap);
1211 gdk_gc_unref (gc);
1212
1213 return TRUE;
1214 }
1215
1216 static gint
1217 draw_img (GtkWidget *widget,
1218 GdkEvent *event,
1219 gpointer data)
1220 {
1221 GtkIMHtmlBit *bit;
1222 struct line_info *line;
1223 GdkGC *gc;
1224 GdkColormap *cmap;
1225 gint width, height, hoff;
1226
1227 line = gtk_object_get_user_data (GTK_OBJECT (widget));
1228 bit = line->bit;
1229 gdk_window_get_size (bit->pm, &width, &height);
1230 hoff = (widget->allocation.height - height) / 2;
1231 gc = gdk_gc_new (widget->window);
1232 cmap = gdk_colormap_new (gdk_visual_get_best (), FALSE);
1233
1234 if (bit->bg != NULL) {
1235 gdk_color_alloc (cmap, bit->bg);
1236 gdk_gc_set_foreground (gc, bit->bg);
1237 } else
1238 gdk_gc_copy (gc, widget->style->white_gc);
1239
1240 gdk_draw_rectangle (widget->window, gc, TRUE, 0, 0,
1241 widget->allocation.width,
1242 widget->allocation.height);
1243
1244 if (bit->back != NULL) {
1245 gdk_color_alloc (cmap, bit->back);
1246 gdk_gc_set_foreground (gc, bit->back);
1247 gdk_draw_rectangle (widget->window, gc, TRUE, 0, 0,
1248 width, widget->allocation.height);
1249 }
1250
1251 gdk_draw_pixmap (widget->window, gc, bit->pm, 0, 0, 0, hoff, -1, -1);
1252
1253 gdk_colormap_unref (cmap);
1254 gdk_gc_unref (gc);
1255
1256 return TRUE;
1257 }
1258
1259 static gint
1260 draw_line (GtkWidget *widget,
1261 GdkEvent *event,
1262 gpointer data)
1263 {
1264 GtkIMHtmlBit *bit;
1265 GdkDrawable *drawable;
1266 GdkColormap *cmap;
1267 GdkGC *gc;
1268 guint max_width;
1269 guint max_height;
1270
1271 bit = data;
1272 drawable = widget->window;
1273 cmap = gdk_colormap_new (gdk_visual_get_best (), FALSE);
1274 gc = gdk_gc_new (drawable);
1275
1276 if (bit->bg != NULL) {
1277 gdk_color_alloc (cmap, bit->bg);
1278 gdk_gc_set_foreground (gc, bit->bg);
1279
1280 gdk_draw_rectangle (widget->window, gc, TRUE, 0, 0,
1281 widget->allocation.width,
1282 widget->allocation.height);
1283 }
1284
1285 gdk_gc_copy (gc, widget->style->black_gc);
1286
1287 max_width = widget->allocation.width;
1288 max_height = widget->allocation.height / 2;
1289
1290 gdk_draw_rectangle (drawable, gc,
1291 TRUE,
1292 0, max_height / 2,
1293 max_width, max_height);
1294
1295 gdk_colormap_unref (cmap);
1296 gdk_gc_unref (gc);
1297
1298 return TRUE;
1299 }
1300
1301 static gint
1302 click_event_box (GtkBin *bin,
1303 GdkEventButton *event,
1304 GtkIMHtml *imhtml)
1305 {
1306 struct line_info *li = gtk_object_get_user_data (GTK_OBJECT (bin->child));
1307
1308 if (event->button == 1 && event->type == GDK_BUTTON_PRESS)
1309 gtk_signal_emit (GTK_OBJECT (imhtml), signals [URL_CLICKED], li->bit->url);
1310
1311 return TRUE;
1312 }
1313
1314 static void
1315 new_line (GtkIMHtml *imhtml)
1316 {
1317 GList *last = g_list_last (imhtml->line);
1318 GtkWidget *widget;
1319 struct line_info *li;
1320
1321 if (last) {
1322 widget = last->data;
1323 li = gtk_object_get_user_data (GTK_OBJECT (widget));
1324 if (li->x + li->width != imhtml->xsize - BORDER_SIZE) {
1325 li->width = imhtml->xsize - BORDER_SIZE - li->x;
1326 gtk_widget_set_usize (widget, li->width, li->height);
1327 }
1328 }
1329
1330 last = imhtml->line;
1331 if (last) {
1332 widget = last->data;
1333 li = gtk_object_get_user_data (GTK_OBJECT (widget));
1334 if (li->height < MIN_HEIGHT) {
1335 while (last) {
1336 gint diff;
1337 widget = last->data;
1338 li = gtk_object_get_user_data (GTK_OBJECT (widget));
1339 diff = MIN_HEIGHT - li->height;
1340 li->height = MIN_HEIGHT;
1341 gtk_widget_set_usize (widget, li->width, li->height);
1342 li->ascent += diff >> 1;
1343 last = g_list_next (last);
1344 }
1345 imhtml->llheight = MIN_HEIGHT;
1346 }
1347 }
1348
1349 g_list_free (imhtml->line);
1350 imhtml->line = NULL;
1351
1352 imhtml->x = BORDER_SIZE;
1353 imhtml->y += imhtml->llheight;
1354 }
1355
1356 static void
1357 backwards_update (GtkIMHtml *imhtml,
1358 GtkIMHtmlBit *bit,
1359 gint height,
1360 gint ascent)
1361 {
1362 gint diff;
1363 GList *ls = NULL;
1364 struct line_info *li;
1365 struct url_widget *uw;
1366
1367 if (height > imhtml->llheight) {
1368 diff = height - imhtml->llheight;
1369
1370 ls = imhtml->line;
1371 while (ls) {
1372 GtkWidget *data = ls->data;
1373 li = gtk_object_get_user_data (GTK_OBJECT (data));
1374 li->height += diff;
1375 if (ascent)
1376 li->ascent = ascent;
1377 else
1378 li->ascent += diff >> 1;
1379 gtk_widget_set_usize (data, li->width, li->height);
1380 ls = g_list_next (ls);
1381 }
1382
1383 ls = imhtml->urls;
1384 while (ls) {
1385 uw = ls->data;
1386 if (uw->y + diff > imhtml->y)
1387 uw->y += diff;
1388 ls = g_list_next (ls);
1389 }
1390
1391 imhtml->llheight = height;
1392 if (ascent)
1393 imhtml->llascent = ascent;
1394 else
1395 imhtml->llascent += diff >> 1;
1396 }
1397 }
1398
1399 static GtkTooltips *tips = NULL;
1400
1401 static void
1402 add_text_renderer (GtkIMHtml *imhtml,
1403 GtkIMHtmlBit *bit,
1404 gchar *text)
1405 {
1406 GtkWidget *darea;
1407 GtkWidget *eventbox;
1408 struct line_info *li;
1409 struct url_widget *uw;
1410 gint width;
1411
1412 if (text)
1413 width = gdk_string_width (bit->font, text);
1414 else
1415 width = 0;
1416
1417 darea = gtk_drawing_area_new ();
1418 gtk_widget_set_usize (darea, width, imhtml->llheight);
1419 gtk_signal_connect (GTK_OBJECT (darea), "expose_event", GTK_SIGNAL_FUNC (draw_text), NULL);
1420
1421 li = g_new0 (struct line_info, 1);
1422 li->x = imhtml->x;
1423 li->y = imhtml->y;
1424 li->width = width;
1425 li->height = imhtml->llheight;
1426 if (text)
1427 li->ascent = MAX (imhtml->llascent, bit->font->ascent);
1428 else
1429 li->ascent = 0;
1430 li->text = text;
1431 li->bit = bit;
1432
1433 gtk_object_set_user_data (GTK_OBJECT (darea), li);
1434
1435 if (bit->url) {
1436 eventbox = gtk_event_box_new ();
1437 gtk_layout_put (GTK_LAYOUT (imhtml), eventbox, imhtml->x, imhtml->y);
1438 gtk_signal_connect (GTK_OBJECT (eventbox), "button_press_event",
1439 GTK_SIGNAL_FUNC (click_event_box), imhtml);
1440 gtk_widget_show (eventbox);
1441
1442 gtk_container_add (GTK_CONTAINER (eventbox), darea);
1443
1444 uw = g_new0 (struct url_widget, 1);
1445 uw->x = imhtml->x;
1446 uw->y = imhtml->y;
1447 uw->width = width;
1448 uw->height = imhtml->llheight;
1449 uw->url = bit->url;
1450 imhtml->urls = g_list_append (imhtml->urls, uw);
1451
1452 if (!tips)
1453 tips = gtk_tooltips_new ();
1454 gtk_tooltips_set_tip (tips, eventbox, bit->url, "");
1455 } else {
1456 gtk_layout_put (GTK_LAYOUT (imhtml), darea, imhtml->x, imhtml->y);
1457 }
1458
1459 bit->chunks = g_list_append (bit->chunks, darea);
1460 imhtml->line = g_list_append (imhtml->line, darea);
1461 gtk_widget_show (darea);
1462
1463 if (bit->bg) {
1464 GdkColormap *cmap;
1465
1466 cmap = gdk_colormap_new (gdk_visual_get_best (), FALSE);
1467 gdk_color_alloc (cmap, bit->bg);
1468 gdk_window_set_background (darea->window, bit->bg);
1469 gdk_colormap_unref (cmap);
1470 } else
1471 gdk_window_set_background (darea->window, &darea->style->white);
1472 }
1473
1474 static void
1475 add_img_renderer (GtkIMHtml *imhtml,
1476 GtkIMHtmlBit *bit)
1477 {
1478 GtkWidget *darea;
1479 GtkWidget *eventbox;
1480 struct line_info *li;
1481 struct url_widget *uw;
1482 gint width;
1483
1484 gdk_window_get_size (bit->pm, &width, NULL);
1485
1486 darea = gtk_drawing_area_new ();
1487 gtk_widget_set_usize (darea, width, imhtml->llheight);
1488 gtk_signal_connect (GTK_OBJECT (darea), "expose_event", GTK_SIGNAL_FUNC (draw_img), NULL);
1489
1490 li = g_new0 (struct line_info, 1);
1491 li->x = imhtml->x;
1492 li->y = imhtml->y;
1493 li->width = width;
1494 li->height = imhtml->llheight;
1495 li->ascent = 0;
1496 li->bit = bit;
1497
1498 gtk_object_set_user_data (GTK_OBJECT (darea), li);
1499
1500 if (bit->url) {
1501 eventbox = gtk_event_box_new ();
1502 gtk_layout_put (GTK_LAYOUT (imhtml), eventbox, imhtml->x, imhtml->y);
1503 gtk_signal_connect (GTK_OBJECT (eventbox), "button_press_event",
1504 GTK_SIGNAL_FUNC (click_event_box), imhtml);
1505 gtk_widget_show (eventbox);
1506
1507 gtk_container_add (GTK_CONTAINER (eventbox), darea);
1508
1509 uw = g_new0 (struct url_widget, 1);
1510 uw->x = imhtml->x;
1511 uw->y = imhtml->y;
1512 uw->width = width;
1513 uw->height = imhtml->llheight;
1514 uw->url = bit->url;
1515 imhtml->urls = g_list_append (imhtml->urls, uw);
1516
1517 if (!tips)
1518 tips = gtk_tooltips_new ();
1519 gtk_tooltips_set_tip (tips, eventbox, bit->url, "");
1520 } else {
1521 gtk_layout_put (GTK_LAYOUT (imhtml), darea, imhtml->x, imhtml->y);
1522 }
1523
1524 bit->chunks = g_list_append (bit->chunks, darea);
1525 imhtml->line = g_list_append (imhtml->line, darea);
1526 gtk_widget_show (darea);
1527
1528 if (bit->bg) {
1529 GdkColormap *cmap;
1530
1531 cmap = gdk_colormap_new (gdk_visual_get_best (), FALSE);
1532 gdk_color_alloc (cmap, bit->bg);
1533 gdk_window_set_background (darea->window, bit->bg);
1534 gdk_colormap_unref (cmap);
1535 } else
1536 gdk_window_set_background (darea->window, &darea->style->white);
1537
1538 imhtml->x += width;
1539 }
1540
1541 static void
1542 gtk_imhtml_draw_bit (GtkIMHtml *imhtml,
1543 GtkIMHtmlBit *bit)
1544 {
1545 gint width, height;
1546 GdkWindow *window;
1547 GdkGC *gc;
1548
1549 g_return_if_fail (imhtml != NULL);
1550 g_return_if_fail (GTK_IS_IMHTML (imhtml));
1551 g_return_if_fail (bit != NULL);
1552
1553 window = GTK_LAYOUT (imhtml)->bin_window;
1554 gc = gdk_gc_new (window);
1555
1556 if ( (bit->type == TYPE_TEXT) ||
1557 ((bit->type == TYPE_SMILEY) && !imhtml->smileys) ||
1558 ((bit->type == TYPE_COMMENT) && imhtml->comments)) {
1559 gchar *copy = g_strdup (bit->text);
1560 gint pos = 0;
1561 gboolean seenspace = FALSE;
1562 gchar *tmp;
1563
1564 height = bit->font->ascent + bit->font->descent;
1565 width = gdk_string_width (bit->font, bit->text);
1566
1567 if ((imhtml->x != BORDER_SIZE) &&
1568 ((imhtml->x + width + BORDER_SIZE + BORDER_SIZE + 5) > imhtml->xsize)) {
1569 gint remain = imhtml->xsize - imhtml->x - BORDER_SIZE - BORDER_SIZE - 5;
1570 while (gdk_text_width (bit->font, copy, pos) < remain) {
1571 if (copy [pos] == ' ')
1572 seenspace = TRUE;
1573 pos++;
1574 }
1575 if (seenspace) {
1576 while (copy [pos - 1] != ' ') pos--;
1577
1578 tmp = g_strndup (copy, pos);
1579
1580 backwards_update (imhtml, bit, height, bit->font->ascent);
1581 add_text_renderer (imhtml, bit, tmp);
1582 } else
1583 pos = 0;
1584 seenspace = FALSE;
1585 new_line (imhtml);
1586 imhtml->llheight = 0;
1587 imhtml->llascent = 0;
1588 }
1589
1590 backwards_update (imhtml, bit, height, bit->font->ascent);
1591
1592 while (pos < strlen (bit->text)) {
1593 width = gdk_string_width (bit->font, copy + pos);
1594 if (imhtml->x + width + BORDER_SIZE + BORDER_SIZE + 5 > imhtml->xsize) {
1595 gint newpos = 0;
1596 gint remain = imhtml->xsize - imhtml->x - BORDER_SIZE - BORDER_SIZE - 5;
1597 while (gdk_text_width (bit->font, copy + pos, newpos) < remain) {
1598 if (copy [pos + newpos] == ' ')
1599 seenspace = TRUE;
1600 newpos++;
1601 }
1602
1603 if (seenspace)
1604 while (copy [pos + newpos - 1] != ' ') newpos--;
1605
1606 if (newpos == 0)
1607 break;
1608
1609 tmp = g_strndup (copy + pos, newpos);
1610 pos += newpos;
1611
1612 add_text_renderer (imhtml, bit, tmp);
1613
1614 seenspace = FALSE;
1615 new_line (imhtml);
1616 } else {
1617 tmp = g_strdup (copy + pos);
1618
1619 add_text_renderer (imhtml, bit, tmp);
1620
1621 pos = strlen (bit->text);
1622
1623 imhtml->x += width;
1624 }
1625 }
1626
1627 g_free (copy);
1628 } else if ((bit->type == TYPE_SMILEY) || (bit->type == TYPE_IMG)) {
1629 gdk_window_get_size (bit->pm, &width, &height);
1630
1631 if ((imhtml->x != BORDER_SIZE) &&
1632 ((imhtml->x + width + BORDER_SIZE + BORDER_SIZE + 5) > imhtml->xsize)) {
1633 new_line (imhtml);
1634 imhtml->llheight = 0;
1635 imhtml->llascent = 0;
1636 } else
1637 backwards_update (imhtml, bit, height, height * 3 / 4);
1638
1639 add_img_renderer (imhtml, bit);
1640 } else if (bit->type == TYPE_BR) {
1641 new_line (imhtml);
1642 imhtml->llheight = 0;
1643 imhtml->llascent = 0;
1644 add_text_renderer (imhtml, bit, NULL);
1645 } else if (bit->type == TYPE_SEP) {
1646 GtkWidget *darea;
1647 if (imhtml->llheight) {
1648 new_line (imhtml);
1649 imhtml->llheight = 0;
1650 imhtml->llascent = 0;
1651 }
1652 darea = gtk_drawing_area_new ();
1653 gtk_widget_set_usize (darea, imhtml->xsize - (BORDER_SIZE * 2), HR_HEIGHT * 2);
1654 gtk_layout_put (GTK_LAYOUT (imhtml), darea, imhtml->x, imhtml->y);
1655 gtk_signal_connect (GTK_OBJECT (darea), "expose_event",
1656 GTK_SIGNAL_FUNC (draw_line), bit);
1657 gtk_widget_show (darea);
1658 imhtml->llheight = HR_HEIGHT * 2;
1659 new_line (imhtml);
1660 imhtml->llheight = 0;
1661 imhtml->llascent = 0;
1662 add_text_renderer (imhtml, bit, NULL);
1663 }
1664
1665 gtk_layout_set_size (GTK_LAYOUT (imhtml), imhtml->xsize, imhtml->y + 5);
1666
1667 gdk_gc_destroy (gc);
1668 }
1669
1670 void
1671 gtk_imhtml_show_smileys (GtkIMHtml *imhtml,
1672 gboolean show)
1673 {
1674 g_return_if_fail (imhtml != NULL);
1675 g_return_if_fail (GTK_IS_IMHTML (imhtml));
1676
1677 imhtml->smileys = show;
1678
1679 if (GTK_WIDGET_VISIBLE (GTK_WIDGET (imhtml)))
1680 gtk_imhtml_redraw_all (imhtml);
1681 }
1682
1683 void
1684 gtk_imhtml_show_comments (GtkIMHtml *imhtml,
1685 gboolean show)
1686 {
1687 g_return_if_fail (imhtml != NULL);
1688 g_return_if_fail (GTK_IS_IMHTML (imhtml));
1689
1690 imhtml->comments = show;
1691
1692 if (GTK_WIDGET_VISIBLE (GTK_WIDGET (imhtml)))
1693 gtk_imhtml_redraw_all (imhtml);
1694 }
1695
1696 static GdkColor *
1697 gtk_imhtml_get_color (const gchar *color)
1698 {
1699 GdkColor c;
1700 gboolean valid = TRUE;
1701
1702 g_return_val_if_fail (color != NULL, NULL);
1703
1704 c.red = 0; c.green = 0; c.blue = 0;
1705
1706 if (!g_strcasecmp (color, "aliceblue")) {
1707 c.red = 0xf000; c.green = 0xf800; c.blue = 0xff00;
1708 } else if (!g_strcasecmp (color, "antiquewhite")) {
1709 c.red = 0xfa00; c.green = 0xeb00; c.blue = 0xd700;
1710 } else if (!g_strcasecmp (color, "aqua")) {
1711 c.red = 0; c.green = 0xff00; c.blue = 0xff00;
1712 } else if (!g_strcasecmp (color, "aquamarine")) {
1713 c.red = 0; c.green = 0xff00; c.blue = 0xff00;
1714 } else if (!g_strcasecmp (color, "azure")) {
1715 c.red = 0xf000; c.green = 0xff00; c.blue = 0xff00;
1716 } else if (!g_strcasecmp (color, "beige")) {
1717 c.red = 0xf500; c.green = 0xf500; c.blue = 0xdc00;
1718 } else if (!g_strcasecmp (color, "bisque")) {
1719 c.red = 0xff00; c.green = 0xe400; c.blue = 0xc400;
1720 } else if (!g_strcasecmp (color, "black")) {
1721 c.red = 0; c.green = 0; c.blue = 0;
1722 } else if (!g_strcasecmp (color, "blanchedalmond")) {
1723 c.red = 0xff00; c.green = 0xeb00; c.blue = 0xcd00;
1724 } else if (!g_strcasecmp (color, "blue")) {
1725 c.red = 0; c.green = 0; c.blue = 0xff00;
1726 } else if (!g_strcasecmp (color, "blueviolet")) {
1727 c.red = 0; c.green = 0; c.blue = 0xff00;
1728 } else if (!g_strcasecmp (color, "brown")) {
1729 c.red = 0xa500; c.green = 0x2a00; c.blue = 0x2a00;
1730 } else if (!g_strcasecmp (color, "burlywood")) {
1731 c.red = 0xde00; c.green = 0xb800; c.blue = 0x8700;
1732 } else if (!g_strcasecmp (color, "cadetblue")) {
1733 c.red = 0x5f00; c.green = 0x9e00; c.blue = 0xa000;
1734 } else if (!g_strcasecmp (color, "chartreuse")) {
1735 c.red = 0x7f00; c.green = 0xff00; c.blue = 0;
1736 } else if (!g_strcasecmp (color, "chocolate")) {
1737 c.red = 0xd200; c.green = 0x6900; c.blue = 0x1e00;
1738 } else if (!g_strcasecmp (color, "coral")) {
1739 c.red = 0xff00; c.green = 0x7f00; c.blue = 0x5000;
1740 } else if (!g_strcasecmp (color, "cornflowerblue")) {
1741 c.red = 0x6400; c.green = 0x9500; c.blue = 0xed00;
1742 } else if (!g_strcasecmp (color, "cornsilk")) {
1743 c.red = 0xff00; c.green = 0xf800; c.blue = 0xdc00;
1744 } else if (!g_strcasecmp (color, "crimson")) {
1745 c.red = 0xdc00; c.green = 0x1400; c.blue = 0x3c00;
1746 } else if (!g_strcasecmp (color, "cyan")) {
1747 c.red = 0; c.green = 0xff00; c.blue = 0xff00;
1748 } else if (!g_strcasecmp (color, "darkblue")) {
1749 c.red = 0; c.green = 0; c.blue = 0x8b00;
1750 } else if (!g_strcasecmp (color, "darkcyan")) {
1751 c.red = 0; c.green = 0x8b00; c.blue = 0x8b00;
1752 } else if (!g_strcasecmp (color, "darkgoldenrod")) {
1753 c.red = 0xb800; c.green = 0x8600; c.blue = 0x0b00;
1754 } else if (!g_strcasecmp (color, "darkgray")) {
1755 c.red = 0xa900; c.green = 0xa900; c.blue = 0xa900;
1756 } else if (!g_strcasecmp (color, "darkgreen")) {
1757 c.red = 0; c.green = 0x6400; c.blue = 0;
1758 } else if (!g_strcasecmp (color, "darkkhaki")) {
1759 c.red = 0xbd00; c.green = 0xb700; c.blue = 0x6b00;
1760 } else if (!g_strcasecmp (color, "darkmagenta")) {
1761 c.red = 0x8b00; c.green = 0; c.blue = 0x8b00;
1762 } else if (!g_strcasecmp (color, "darkolivegreen")) {
1763 c.red = 0x5500; c.green = 0x6b00; c.blue = 0x2f00;
1764 } else if (!g_strcasecmp (color, "darkorange")) {
1765 c.red = 0xff00; c.green = 0x8c00; c.blue = 0;
1766 } else if (!g_strcasecmp (color, "darkorchid")) {
1767 c.red = 0x9900; c.green = 0x3200; c.blue = 0xcc00;
1768 } else if (!g_strcasecmp (color, "darkred")) {
1769 c.red = 0x8b00; c.green = 0; c.blue = 0;
1770 } else if (!g_strcasecmp (color, "darksalmon")) {
1771 c.red = 0xe900; c.green = 0x9600; c.blue = 0x7a00;
1772 } else if (!g_strcasecmp (color, "darkseagreen")) {
1773 c.red = 0x8f00; c.green = 0xbc00; c.blue = 0x8f00;
1774 } else if (!g_strcasecmp (color, "darkslateblue")) {
1775 c.red = 0x4800; c.green = 0x3d00; c.blue = 0x8b00;
1776 } else if (!g_strcasecmp (color, "darkslategray")) {
1777 c.red = 0x2f00; c.green = 0x4f00; c.blue = 0x4f00;
1778 } else if (!g_strcasecmp (color, "darkturquoise")) {
1779 c.red = 0; c.green = 0xce00; c.blue = 0xd100;
1780 } else if (!g_strcasecmp (color, "darkviolet")) {
1781 c.red = 0x9400; c.green = 0; c.blue = 0xd300;
1782 } else if (!g_strcasecmp (color, "deeppink")) {
1783 c.red = 0xff00; c.green = 0x1400; c.blue = 0x9300;
1784 } else if (!g_strcasecmp (color, "deepskyblue")) {
1785 c.red = 0; c.green = 0xbf00; c.blue = 0xff00;
1786 } else if (!g_strcasecmp (color, "dimgray")) {
1787 c.red = 0x6900; c.green = 0x6900; c.blue = 0x6900;
1788 } else if (!g_strcasecmp (color, "dodgerblue")) {
1789 c.red = 0x1e00; c.green = 0x9000; c.blue = 0xff00;
1790 } else if (!g_strcasecmp (color, "firebrick")) {
1791 c.red = 0xb200; c.green = 0x2200; c.blue = 0x2200;
1792 } else if (!g_strcasecmp (color, "floralwhite")) {
1793 c.red = 0xff00; c.green = 0xfa00; c.blue = 0xf000;
1794 } else if (!g_strcasecmp (color, "forestgreen")) {
1795 c.red = 0x2200; c.green = 0x8b00; c.blue = 0x2200;
1796 } else if (!g_strcasecmp (color, "fuchsia")) {
1797 c.red = 0xff00; c.green = 0; c.blue = 0xff00;
1798 } else if (!g_strcasecmp (color, "gainsboro")) {
1799 c.red = 0xdc00; c.green = 0xdc00; c.blue = 0xdc00;
1800 } else if (!g_strcasecmp (color, "ghostwhite")) {
1801 c.red = 0xf800; c.green = 0xf800; c.blue = 0xff00;
1802 } else if (!g_strcasecmp (color, "gold")) {
1803 c.red = 0xff00; c.green = 0xd700; c.blue = 0;
1804 } else if (!g_strcasecmp (color, "goldenrod")) {
1805 c.red = 0xff00; c.green = 0xd700; c.blue = 0;
1806 } else if (!g_strcasecmp (color, "gray")) {
1807 c.red = 0x8000; c.green = 0x8000; c.blue = 0x8000;
1808 } else if (!g_strcasecmp (color, "green")) {
1809 c.red = 0; c.green = 0x8000; c.blue = 0;
1810 } else if (!g_strcasecmp (color, "greenyellow")) {
1811 c.red = 0; c.green = 0x8000; c.blue = 0;
1812 } else if (!g_strcasecmp (color, "honeydew")) {
1813 c.red = 0xf000; c.green = 0xff00; c.blue = 0xf000;
1814 } else if (!g_strcasecmp (color, "hotpink")) {
1815 c.red = 0xff00; c.green = 0x6900; c.blue = 0xb400;
1816 } else if (!g_strcasecmp (color, "indianred")) {
1817 c.red = 0xcd00; c.green = 0x5c00; c.blue = 0x5c00;
1818 } else if (!g_strcasecmp (color, "indigo")) {
1819 c.red = 0x4b00; c.green = 0; c.blue = 0x8200;
1820 } else if (!g_strcasecmp (color, "ivory")) {
1821 c.red = 0xff00; c.green = 0xff00; c.blue = 0xf000;
1822 } else if (!g_strcasecmp (color, "khaki")) {
1823 c.red = 0xf000; c.green = 0xe600; c.blue = 0x8c00;
1824 } else if (!g_strcasecmp (color, "lavender")) {
1825 c.red = 0xe600; c.green = 0xe600; c.blue = 0xfa00;
1826 } else if (!g_strcasecmp (color, "lavenderblush")) {
1827 c.red = 0xe600; c.green = 0xe600; c.blue = 0xfa00;
1828 } else if (!g_strcasecmp (color, "lawngreen")) {
1829 c.red = 0x7c00; c.green = 0xfc00; c.blue = 0;
1830 } else if (!g_strcasecmp (color, "lemonchiffon")) {
1831 c.red = 0xff00; c.green = 0xfa00; c.blue = 0xcd00;
1832 } else if (!g_strcasecmp (color, "lightblue")) {
1833 c.red = 0xad00; c.green = 0xd800; c.blue = 0xe600;
1834 } else if (!g_strcasecmp (color, "lightcoral")) {
1835 c.red = 0xf000; c.green = 0x8000; c.blue = 0x8000;
1836 } else if (!g_strcasecmp (color, "lightcyan")) {
1837 c.red = 0xe000; c.green = 0xff00; c.blue = 0xff00;
1838 } else if (!g_strcasecmp (color, "lightgoldenrodyellow")) {
1839 c.red = 0xfa00; c.green = 0xfa00; c.blue = 0xd200;
1840 } else if (!g_strcasecmp (color, "lightgreen")) {
1841 c.red = 0x9000; c.green = 0xee00; c.blue = 0x9000;
1842 } else if (!g_strcasecmp (color, "lightgray")) {
1843 c.red = 0xd300; c.green = 0xd300; c.blue = 0xd300;
1844 } else if (!g_strcasecmp (color, "lightpink")) {
1845 c.red = 0xff00; c.green = 0xb600; c.blue = 0xc100;
1846 } else if (!g_strcasecmp (color, "lightsalmon")) {
1847 c.red = 0xff00; c.green = 0xa000; c.blue = 0x7a00;
1848 } else if (!g_strcasecmp (color, "lightseagreen")) {
1849 c.red = 0x2000; c.green = 0xb200; c.blue = 0xaa00;
1850 } else if (!g_strcasecmp (color, "lightskyblue")) {
1851 c.red = 0x8700; c.green = 0xce00; c.blue = 0xfa00;
1852 } else if (!g_strcasecmp (color, "lightslategray")) {
1853 c.red = 0x7700; c.green = 0x8800; c.blue = 0x9900;
1854 } else if (!g_strcasecmp (color, "lightsteelblue")) {
1855 c.red = 0xb000; c.green = 0xc400; c.blue = 0xde00;
1856 } else if (!g_strcasecmp (color, "lightyellow")) {
1857 c.red = 0xff00; c.green = 0xff00; c.blue = 0xe000;
1858 } else if (!g_strcasecmp (color, "lime")) {
1859 c.red = 0; c.green = 0xff00; c.blue = 0;
1860 } else if (!g_strcasecmp (color, "limegreen")) {
1861 c.red = 0; c.green = 0xff00; c.blue = 0;
1862 } else if (!g_strcasecmp (color, "linen")) {
1863 c.red = 0xfa00; c.green = 0xf000; c.blue = 0xe600;
1864 } else if (!g_strcasecmp (color, "magenta")) {
1865 c.red = 0xff00; c.green = 0; c.blue = 0xff00;
1866 } else if (!g_strcasecmp (color, "maroon")) {
1867 c.red = 0x8000; c.green = 0; c.blue = 0;
1868 } else if (!g_strcasecmp (color, "mediumaquamarine")) {
1869 c.red = 0x6600; c.green = 0xcd00; c.blue = 0xaa00;
1870 } else if (!g_strcasecmp (color, "mediumblue")) {
1871 c.red = 0; c.green = 0; c.blue = 0xcd00;
1872 } else if (!g_strcasecmp (color, "mediumorchid")) {
1873 c.red = 0xba00; c.green = 0x5500; c.blue = 0xd300;
1874 } else if (!g_strcasecmp (color, "mediumpurple")) {
1875 c.red = 0x93; c.green = 0x7000; c.blue = 0xdb00;
1876 } else if (!g_strcasecmp (color, "mediumseagreen")) {
1877 c.red = 0x3c00; c.green = 0xb300; c.blue = 0x7100;
1878 } else if (!g_strcasecmp (color, "mediumslateblue")) {
1879 c.red = 0x7b00; c.green = 0x6800; c.blue = 0xee00;
1880 } else if (!g_strcasecmp (color, "mediumspringgreen")) {
1881 c.red = 0; c.green = 0xfa00; c.blue = 0x9a00;
1882 } else if (!g_strcasecmp (color, "mediumturquoise")) {
1883 c.red = 0x4800; c.green = 0xd100; c.blue = 0xcc00;
1884 } else if (!g_strcasecmp (color, "mediumvioletred")) {
1885 c.red = 0xc700; c.green = 0x1500; c.blue = 0x8500;
1886 } else if (!g_strcasecmp (color, "midnightblue")) {
1887 c.red = 0x1900; c.green = 0x1900; c.blue = 0x7000;
1888 } else if (!g_strcasecmp (color, "mintcream")) {
1889 c.red = 0xf500; c.green = 0xff00; c.blue = 0xfa00;
1890 } else if (!g_strcasecmp (color, "mistyrose")) {
1891 c.red = 0xff00; c.green = 0xe400; c.blue = 0xe100;
1892 } else if (!g_strcasecmp (color, "moccasin")) {
1893 c.red = 0xff00; c.green = 0xe400; c.blue = 0xb500;
1894 } else if (!g_strcasecmp (color, "navajowhite")) {
1895 c.red = 0xff00; c.green = 0xde00; c.blue = 0xad00;
1896 } else if (!g_strcasecmp (color, "navy")) {
1897 c.red = 0; c.green = 0x8000; c.blue = 0;
1898 } else if (!g_strcasecmp (color, "oldlace")) {
1899 c.red = 0xfd00; c.green = 0xf500; c.blue = 0xe600;
1900 } else if (!g_strcasecmp (color, "olive")) {
1901 c.red = 0x8000; c.green = 0x8000; c.blue = 0;
1902 } else if (!g_strcasecmp (color, "olivedrab")) {
1903 c.red = 0x8000; c.green = 0x8000; c.blue = 0;
1904 } else if (!g_strcasecmp (color, "orange")) {
1905 c.red = 0xff00; c.green = 0xa500; c.blue = 0;
1906 } else if (!g_strcasecmp (color, "orangered")) {
1907 c.red = 0xff00; c.green = 0xa500; c.blue = 0;
1908 } else if (!g_strcasecmp (color, "orchid")) {
1909 c.red = 0xda00; c.green = 0x7000; c.blue = 0xd600;
1910 } else if (!g_strcasecmp (color, "palegoldenrod")) {
1911 c.red = 0xee00; c.green = 0xe800; c.blue = 0xaa00;
1912 } else if (!g_strcasecmp (color, "palegreen")) {
1913 c.red = 0x9800; c.green = 0xfb00; c.blue = 0x9800;
1914 } else if (!g_strcasecmp (color, "paleturquoise")) {
1915 c.red = 0xaf00; c.green = 0xee00; c.blue = 0xee00;
1916 } else if (!g_strcasecmp (color, "palevioletred")) {
1917 c.red = 0xdb00; c.green = 0x7000; c.blue = 0x9300;
1918 } else if (!g_strcasecmp (color, "papayawhip")) {
1919 c.red = 0xff00; c.green = 0xef00; c.blue = 0xd500;
1920 } else if (!g_strcasecmp (color, "peachpuff")) {
1921 c.red = 0xff00; c.green = 0xda00; c.blue = 0xb900;
1922 } else if (!g_strcasecmp (color, "peru")) {
1923 c.red = 0xcd00; c.green = 0x8500; c.blue = 0x3f00;
1924 } else if (!g_strcasecmp (color, "pink")) {
1925 c.red = 0xff00; c.green = 0xc000; c.blue = 0xcb00;
1926 } else if (!g_strcasecmp (color, "plum")) {
1927 c.red = 0xdd00; c.green = 0xa000; c.blue = 0xdd00;
1928 } else if (!g_strcasecmp (color, "powderblue")) {
1929 c.red = 0xb000; c.green = 0xe000; c.blue = 0xe600;
1930 } else if (!g_strcasecmp (color, "purple")) {
1931 c.red = 0x8000; c.green = 0; c.blue = 0x8000;
1932 } else if (!g_strcasecmp (color, "red")) {
1933 c.red = 0xff00; c.green = 0; c.blue = 0;
1934 } else if (!g_strcasecmp (color, "rosybrown")) {
1935 c.red = 0xbc00; c.green = 0x8f00; c.blue = 0x8f00;
1936 } else if (!g_strcasecmp (color, "royalblue")) {
1937 c.red = 0x4100; c.green = 0x6900; c.blue = 0xe100;
1938 } else if (!g_strcasecmp (color, "saddlebrown")) {
1939 c.red = 0x8b00; c.green = 0x4500; c.blue = 0x1300;
1940 } else if (!g_strcasecmp (color, "salmon")) {
1941 c.red = 0xfa00; c.green = 0x8000; c.blue = 0x7200;
1942 } else if (!g_strcasecmp (color, "sandybrown")) {
1943 c.red = 0xf400; c.green = 0xa400; c.blue = 0x6000;
1944 } else if (!g_strcasecmp (color, "seagreen")) {
1945 c.red = 0x2e00; c.green = 0x8b00; c.blue = 0x5700;
1946 } else if (!g_strcasecmp (color, "seashell")) {
1947 c.red = 0xff00; c.green = 0xf500; c.blue = 0xee00;
1948 } else if (!g_strcasecmp (color, "sienna")) {
1949 c.red = 0xa000; c.green = 0x5200; c.blue = 0x2d00;
1950 } else if (!g_strcasecmp (color, "silver")) {
1951 c.red = 0xc000; c.green = 0xc000; c.blue = 0xc000;
1952 } else if (!g_strcasecmp (color, "skyblue")) {
1953 c.red = 0x8700; c.green = 0xce00; c.blue = 0xeb00;
1954 } else if (!g_strcasecmp (color, "slateblue")) {
1955 c.red = 0x6a00; c.green = 0x5a00; c.blue = 0xcd00;
1956 } else if (!g_strcasecmp (color, "slategray")) {
1957 c.red = 0x7000; c.green = 0x8000; c.blue = 0x9000;
1958 } else if (!g_strcasecmp (color, "springgreen")) {
1959 c.red = 0; c.green = 0xff00; c.blue = 0x7f00;
1960 } else if (!g_strcasecmp (color, "steelblue")) {
1961 c.red = 0x4600; c.green = 0x8200; c.blue = 0xb400;
1962 } else if (!g_strcasecmp (color, "teal")) {
1963 c.red = 0; c.green = 0x8000; c.blue = 0x8000;
1964 } else if (!g_strcasecmp (color, "thistle")) {
1965 c.red = 0xd800; c.green = 0xbf00; c.blue = 0xd800;
1966 } else if (!g_strcasecmp (color, "tomato")) {
1967 c.red = 0xff00; c.green = 0x6300; c.blue = 0x4700;
1968 } else if (!g_strcasecmp (color, "turquoise")) {
1969 c.red = 0x4000; c.green = 0xe000; c.blue = 0xd000;
1970 } else if (!g_strcasecmp (color, "violet")) {
1971 c.red = 0xee00; c.green = 0x8200; c.blue = 0xee00;
1972 } else if (!g_strcasecmp (color, "wheat")) {
1973 c.red = 0xf500; c.green = 0xde00; c.blue = 0xb300;
1974 } else if (!g_strcasecmp (color, "white")) {
1975 c.red = 0xfe00; c.green = 0xfe00; c.blue = 0xfe00;
1976 } else if (!g_strcasecmp (color, "whitesmoke")) {
1977 c.red = 0xfe00; c.green = 0xfe00; c.blue = 0xfe00;
1978 } else if (!g_strcasecmp (color, "yellow")) {
1979 c.red = 0xff00; c.green = 0xff00; c.blue = 0;
1980 } else if (!g_strcasecmp (color, "yellowgreen")) {
1981 c.red = 0xff00; c.green = 0xff00; c.blue = 0;
1982 } else {
1983 const gchar *hex;
1984 guint32 value;
1985
1986 if (color [0] == '#')
1987 hex = color + 1;
1988 else
1989 hex = color;
1990
1991 if (strlen (hex) == 6) {
1992 gint i = 0;
1993 for ( ; i < 6; i++)
1994 if (!isxdigit ((gint) hex [i]))
1995 break;
1996 if (i == 6) {
1997 sscanf (hex, "%x", &value);
1998 c.red = (value & 0xff0000) >> 8;
1999 c.green = value & 0xff00;
2000 c.blue = (value & 0xff) << 8;
2001 } else {
2002 valid = FALSE;
2003 }
2004 } else {
2005 valid = FALSE;
2006 }
2007 }
2008
2009 if (valid)
2010 return gdk_color_copy (&c);
2011
2012 return NULL;
2013 }
2014
2015 static gint
2016 gtk_imhtml_is_smiley (GtkIMHtml *imhtml,
2017 const gchar *text)
2018 {
2019 gchar *tmp;
2020 gint i;
2021
2022 g_return_val_if_fail (imhtml != NULL, 0);
2023 g_return_val_if_fail (GTK_IS_IMHTML (imhtml), 0);
2024 g_return_val_if_fail (text != NULL, 0);
2025
2026 tmp = g_malloc (imhtml->smax + 1);
2027
2028 for (i = imhtml->smin; i <= imhtml->smax; i++) {
2029 if (strlen (text) < i) {
2030 g_free (tmp);
2031 return 0;
2032 }
2033 g_snprintf (tmp, i + 1, "%s", text);
2034 if (g_hash_table_lookup (imhtml->smiley_hash, tmp)) {
2035 g_free (tmp);
2036 return i;
2037 }
2038 }
2039
2040 g_free (tmp);
2041 return 0;
2042 }
2043
2044 static GtkIMHtmlBit *
2045 gtk_imhtml_new_bit (GtkIMHtml *imhtml,
2046 gint type,
2047 gchar *text,
2048 gint bold,
2049 gint italics,
2050 gint underline,
2051 gint strike,
2052 FontDetail *font,
2053 GdkColor *bg,
2054 gchar *url)
2055 {
2056 GtkIMHtmlBit *bit = NULL;
2057
2058 g_return_val_if_fail (imhtml != NULL, NULL);
2059 g_return_val_if_fail (GTK_IS_IMHTML (imhtml), NULL);
2060
2061 if ((type == TYPE_TEXT) && ((text == NULL) || (strlen (text) == 0)))
2062 return NULL;
2063
2064 bit = g_new0 (GtkIMHtmlBit, 1);
2065 bit->type = type;
2066
2067 if ((text != NULL) && (strlen (text) != 0))
2068 bit->text = g_strdup (text);
2069
2070 if ((font != NULL) || bold || italics) {
2071 if (font && (bold || italics || font->size || font->face)) {
2072 bit->font = gtk_imhtml_font_load (imhtml, font->face, bold, italics, font->size);
2073 } else if (bold || italics) {
2074 bit->font = gtk_imhtml_font_load (imhtml, NULL, bold, italics, 0);
2075 }
2076
2077 if (font && (type != TYPE_BR)) {
2078 if (font->fore != NULL)
2079 bit->fore = gdk_color_copy (font->fore);
2080
2081 if (font->back != NULL)
2082 bit->back = gdk_color_copy (font->back);
2083 }
2084 }
2085
2086 if (((bit->type == TYPE_TEXT) || (bit->type == TYPE_SMILEY) || (bit->type == TYPE_COMMENT)) &&
2087 (bit->font == NULL))
2088 bit->font = gdk_font_ref (imhtml->default_font);
2089
2090 if (bg != NULL)
2091 bit->bg = gdk_color_copy (bg);
2092
2093 bit->underline = underline;
2094 bit->strike = strike;
2095
2096 if (url != NULL)
2097 bit->url = g_strdup (url);
2098
2099 if (type == TYPE_SMILEY) {
2100 GdkColor *clr;
2101
2102 if ((font != NULL) && (font->back != NULL))
2103 clr = font->back;
2104 else
2105 clr = (bg != NULL) ? bg : &GTK_WIDGET (imhtml)->style->white;
2106
2107 bit->pm = gdk_pixmap_create_from_xpm_d (GTK_WIDGET (imhtml)->window,
2108 &bit->bm,
2109 clr,
2110 g_hash_table_lookup (imhtml->smiley_hash, text));
2111 }
2112
2113 return bit;
2114 }
2115
2116 #define NEW_TEXT_BIT gtk_imhtml_new_bit (imhtml, TYPE_TEXT, ws, bold, italics, underline, strike, \
2117 fonts ? fonts->data : NULL, bg, url)
2118 #define NEW_SMILEY_BIT gtk_imhtml_new_bit (imhtml, TYPE_SMILEY, ws, bold, italics, underline, strike, \
2119 fonts ? fonts->data : NULL, bg, url)
2120 #define NEW_SEP_BIT gtk_imhtml_new_bit (imhtml, TYPE_SEP, NULL, 0, 0, 0, 0, NULL, bg, NULL)
2121 #define NEW_BR_BIT gtk_imhtml_new_bit (imhtml, TYPE_BR, NULL, 0, 0, 0, 0, \
2122 fonts ? fonts->data : NULL, bg, NULL)
2123 #define NEW_COMMENT_BIT gtk_imhtml_new_bit (imhtml, TYPE_COMMENT, ws, bold, italics, underline, strike, \
2124 fonts ? fonts->data : NULL, bg, url)
2125
2126 #define NEW_BIT(bit) { GtkIMHtmlBit *tmp = bit; if (tmp != NULL) \
2127 newbits = g_list_append (newbits, tmp); }
2128
2129 #define UPDATE_BG_COLORS \
2130 { \
2131 GdkColormap *cmap; \
2132 GList *rev; \
2133 cmap = gdk_colormap_new (gdk_visual_get_best (), FALSE); \
2134 rev = g_list_last (newbits); \
2135 while (rev) { \
2136 GtkIMHtmlBit *bit = rev->data; \
2137 if (bit->type == TYPE_BR) \
2138 break; \
2139 if (bit->bg) \
2140 gdk_color_free (bit->bg); \
2141 bit->bg = gdk_color_copy (bg); \
2142 rev = g_list_previous (rev); \
2143 } \
2144 if (!rev) { \
2145 rev = g_list_last (imhtml->bits); \
2146 while (rev) { \
2147 GList *ln; \
2148 GtkIMHtmlBit *bit = rev->data; \
2149 if (bit->type == TYPE_BR) \
2150 break; \
2151 if (bit->bg) \
2152 gdk_color_free (bit->bg); \
2153 bit->bg = gdk_color_copy (bg); \
2154 gdk_color_alloc (cmap, bit->bg); \
2155 ln = bit->chunks; \
2156 while (ln) { \
2157 GtkWidget *widget = ln->data; \
2158 gdk_window_set_background (widget->window, bit->bg); \
2159 ln = g_list_next (ln); \
2160 } \
2161 rev = g_list_previous (rev); \
2162 } \
2163 gdk_colormap_unref (cmap); \
2164 } \
2165 }
2166
2167 GString*
2168 gtk_imhtml_append_text (GtkIMHtml *imhtml,
2169 const gchar *text,
2170 GtkIMHtmlOptions options)
2171 {
2172 const gchar *c;
2173 gboolean intag = FALSE;
2174 gboolean tagquote = FALSE;
2175 gboolean incomment = FALSE;
2176 gchar *ws;
2177 gchar *tag;
2178 gint wpos = 0;
2179 gint tpos = 0;
2180 int smilelen;
2181 GList *newbits = NULL;
2182
2183 guint bold = 0,
2184 italics = 0,
2185 underline = 0,
2186 strike = 0,
2187 sub = 0,
2188 sup = 0,
2189 title = 0;
2190 GSList *fonts = NULL;
2191 GdkColor *bg = NULL;
2192 gchar *url = NULL;
2193
2194 GtkAdjustment *vadj;
2195 gboolean scrolldown = TRUE;
2196
2197 GString *retval = NULL;
2198
2199 g_return_val_if_fail (imhtml != NULL, NULL);
2200 g_return_val_if_fail (GTK_IS_IMHTML (imhtml), NULL);
2201 g_return_val_if_fail (text != NULL, NULL);
2202
2203 if (options & GTK_IMHTML_RETURN_LOG)
2204 retval = g_string_new ("");
2205
2206 vadj = GTK_LAYOUT (imhtml)->vadjustment;
2207 if ((vadj->value < imhtml->y + 5 - GTK_WIDGET (imhtml)->allocation.height) &&
2208 (vadj->upper >= GTK_WIDGET (imhtml)->allocation.height))
2209 scrolldown = FALSE;
2210
2211 c = text;
2212 ws = g_malloc (strlen (text) + 1);
2213 tag = g_malloc (strlen (text) + 1);
2214
2215 ws [0] = '\0';
2216
2217 while (*c) {
2218 if (*c == '<') {
2219 if (intag) {
2220 ws [wpos] = 0;
2221 tag [tpos] = 0;
2222 tpos = 0;
2223 strcat (ws, tag);
2224 wpos = strlen (ws);
2225 }
2226
2227 if (incomment) {
2228 ws [wpos++] = *c++;
2229 continue;
2230 }
2231
2232 if (!g_strncasecmp (c, "<!--", strlen ("<!--"))) {
2233 if (!(options & GTK_IMHTML_NO_COMMENTS)) {
2234 ws [wpos] = 0;
2235 wpos = 0;
2236 tag [tpos] = 0;
2237 strcat (tag, ws);
2238 incomment = TRUE;
2239 intag = FALSE;
2240 }
2241 ws [wpos++] = *c++;
2242 ws [wpos++] = *c++;
2243 ws [wpos++] = *c++;
2244 ws [wpos++] = *c++;
2245 continue;
2246 }
2247
2248 tag [tpos++] = *c++;
2249 intag = TRUE;
2250 } else if (incomment && (*c == '-') && !g_strncasecmp (c, "-->", strlen ("-->"))) {
2251 gchar *tmp;
2252 ws [wpos] = 0;
2253 wpos = 0;
2254 tmp = g_strdup (ws);
2255 ws [wpos] = 0;
2256 strcat (ws, tag);
2257 NEW_BIT (NEW_TEXT_BIT);
2258 ws [wpos] = 0;
2259 strcat (ws, tmp + strlen ("<!--"));
2260 g_free (tmp);
2261 NEW_BIT (NEW_COMMENT_BIT);
2262 incomment = FALSE;
2263 c += strlen ("-->");
2264 } else if (*c == '>' && intag && !tagquote) {
2265 gboolean got_tag = FALSE;
2266 tag [tpos++] = *c++;
2267 tag [tpos] = 0;
2268 ws [wpos] = 0;
2269
2270 if (!g_strcasecmp (tag, "<B>") || !g_strcasecmp (tag, "<BOLD>")) {
2271 got_tag = TRUE;
2272 NEW_BIT (NEW_TEXT_BIT);
2273 bold++;
2274 } else if (!g_strcasecmp (tag, "</B>") || !g_strcasecmp (tag, "</BOLD>")) {
2275 got_tag = TRUE;
2276 if (bold) {
2277 NEW_BIT (NEW_TEXT_BIT);
2278 bold--;
2279 }
2280 } else if (!g_strcasecmp (tag, "<I>") || !g_strcasecmp (tag, "<ITALIC>")) {
2281 got_tag = TRUE;
2282 NEW_BIT (NEW_TEXT_BIT);
2283 italics++;
2284 } else if (!g_strcasecmp (tag, "</I>") || !g_strcasecmp (tag, "</ITALIC>")) {
2285 got_tag = TRUE;
2286 if (italics) {
2287 NEW_BIT (NEW_TEXT_BIT);
2288 italics--;
2289 }
2290 } else if (!g_strcasecmp (tag, "<U>") || !g_strcasecmp (tag, "<UNDERLINE>")) {
2291 got_tag = TRUE;
2292 NEW_BIT (NEW_TEXT_BIT);
2293 underline++;
2294 } else if (!g_strcasecmp (tag, "</U>") || !g_strcasecmp (tag, "</UNDERLINE>")) {
2295 got_tag = TRUE;
2296 if (underline) {
2297 NEW_BIT (NEW_TEXT_BIT);
2298 underline--;
2299 }
2300 } else if (!g_strcasecmp (tag, "<S>") || !g_strcasecmp (tag, "<STRIKE>")) {
2301 got_tag = TRUE;
2302 NEW_BIT (NEW_TEXT_BIT);
2303 strike++;
2304 } else if (!g_strcasecmp (tag, "</S>") || !g_strcasecmp (tag, "</STRIKE>")) {
2305 got_tag = TRUE;
2306 if (strike) {
2307 NEW_BIT (NEW_TEXT_BIT);
2308 strike--;
2309 }
2310 } else if (!g_strcasecmp (tag, "<SUB>")) {
2311 got_tag = TRUE;
2312 sub++;
2313 } else if (!g_strcasecmp (tag, "</SUB>")) {
2314 got_tag = TRUE;
2315 if (sub) {
2316 sub--;
2317 }
2318 } else if (!g_strcasecmp (tag, "<SUP>")) {
2319 got_tag = TRUE;
2320 sup++;
2321 } else if (!g_strcasecmp (tag, "</SUP>")) {
2322 got_tag = TRUE;
2323 if (sup) {
2324 sup--;
2325 }
2326 } else if (!g_strcasecmp (tag, "<TITLE>")) {
2327 if (options & GTK_IMHTML_NO_TITLE) {
2328 got_tag = TRUE;
2329 title++;
2330 } else {
2331 intag = FALSE;
2332 tpos = 0;
2333 continue;
2334 }
2335 } else if (!g_strcasecmp (tag, "</TITLE>")) {
2336 if (title) {
2337 got_tag = TRUE;
2338 wpos = 0;
2339 ws [wpos] = '\0';
2340 title--;
2341 } else {
2342 intag = FALSE;
2343 tpos = 0;
2344 continue;
2345 }
2346 } else if (!g_strcasecmp (tag, "<BR>")) {
2347 got_tag = TRUE;
2348 NEW_BIT (NEW_TEXT_BIT);
2349 NEW_BIT (NEW_BR_BIT);
2350 } else if (!g_strcasecmp (tag, "<HR>") ||
2351 !g_strncasecmp (tag, "<HR ", strlen ("<HR "))) {
2352 got_tag = TRUE;
2353 NEW_BIT (NEW_TEXT_BIT);
2354 NEW_BIT (NEW_SEP_BIT);
2355 } else if (!g_strncasecmp (tag, "<FONT ", strlen ("<FONT "))) {
2356 gchar *t, *e, *a, *value;
2357 FontDetail *font = NULL;
2358 GdkColor *clr;
2359 gint saw;
2360 gint i;
2361
2362 t = tag + strlen ("<FONT ");
2363
2364 while (*t != '\0') {
2365 value = NULL;
2366 saw = 0;
2367
2368 while (g_strncasecmp (t, "COLOR=", strlen ("COLOR="))
2369 && g_strncasecmp (t, "BACK=", strlen ("BACK="))
2370 && g_strncasecmp (t, "FACE=", strlen ("FACE="))
2371 && g_strncasecmp (t, "SIZE=", strlen ("SIZE="))) {
2372 gboolean quote = FALSE;
2373 if (*t == '\0') break;
2374 while (*t && !((*t == ' ') && !quote)) {
2375 if (*t == '\"')
2376 quote = ! quote;
2377 t++;
2378 }
2379 while (*t && (*t == ' ')) t++;
2380 }
2381
2382 if (!g_strncasecmp (t, "COLOR=", strlen ("COLOR="))) {
2383 t += strlen ("COLOR=");
2384 saw = 1;
2385 } else if (!g_strncasecmp (t, "BACK=", strlen ("BACK="))) {
2386 t += strlen ("BACK=");
2387 saw = 2;
2388 } else if (!g_strncasecmp (t, "FACE=", strlen ("FACE="))) {
2389 t += strlen ("FACE=");
2390 saw = 3;
2391 } else if (!g_strncasecmp (t, "SIZE=", strlen ("SIZE="))) {
2392 t += strlen ("SIZE=");
2393 saw = 4;
2394 }
2395
2396 if (!saw)
2397 continue;
2398
2399 if ((*t == '\"') || (*t == '\'')) {
2400 e = a = ++t;
2401 while (*e && (*e != *(t - 1))) e++;
2402 if (*e != '\0') {
2403 *e = '\0';
2404 t = e + 1;
2405 value = g_strdup (a);
2406 } else {
2407 *t = '\0';
2408 }
2409 } else {
2410 e = a = t;
2411 while (*e && !isspace ((gint) *e)) e++;
2412 if (*e == '\0') e--;
2413 *e = '\0';
2414 t = e + 1;
2415 value = g_strdup (a);
2416 }
2417
2418 if (value == NULL)
2419 continue;
2420
2421 if (font == NULL)
2422 font = g_new0 (FontDetail, 1);
2423
2424 switch (saw) {
2425 case 1:
2426 clr = gtk_imhtml_get_color (value);
2427 if (clr != NULL) {
2428 if ( (font->fore == NULL) &&
2429 !(options & GTK_IMHTML_NO_COLOURS))
2430 font->fore = clr;
2431 }
2432 break;
2433 case 2:
2434 clr = gtk_imhtml_get_color (value);
2435 if (clr != NULL) {
2436 if ( (font->back == NULL) &&
2437 !(options & GTK_IMHTML_NO_COLOURS))
2438 font->back = clr;
2439 }
2440 break;
2441 case 3:
2442 if ( (font->face == NULL) &&
2443 !(options & GTK_IMHTML_NO_FONTS))
2444 font->face = g_strdup (value);
2445 break;
2446 case 4:
2447 if ((font->size != 0) ||
2448 (options & GTK_IMHTML_NO_SIZES))
2449 break;
2450
2451 if (isdigit ((gint) value [0])) {
2452 for (i = 0; i < strlen (value); i++)
2453 if (!isdigit ((gint) value [i]))
2454 break;
2455 if (i != strlen (value))
2456 break;
2457
2458 sscanf (value, "%hd", &font->size);
2459 break;
2460 }
2461
2462 if ((value [0] == '+') && (value [1] != '\0')) {
2463 for (i = 1; i < strlen (value); i++)
2464 if (!isdigit ((gint) value [i]))
2465 break;
2466 if (i != strlen (value))
2467 break;
2468
2469 sscanf (value + 1, "%hd", &font->size);
2470 font->size += 3;
2471 break;
2472 }
2473
2474 if ((value [0] == '-') && (value [1] != '\0')) {
2475 for (i = 1; i < strlen (value); i++)
2476 if (!isdigit ((gint) value [i]))
2477 break;
2478 if (i != strlen (value))
2479 break;
2480
2481 sscanf (value + 1, "%hd", &font->size);
2482 font->size = MIN (font->size, 2);
2483 font->size = 3 - font->size;
2484 break;
2485 }
2486
2487 break;
2488 }
2489
2490 g_free (value);
2491 }
2492
2493 if (!font) {
2494 intag = FALSE;
2495 tpos = 0;
2496 continue;
2497 }
2498
2499 if (!(font->size || font->face || font->fore || font->back)) {
2500 g_free (font);
2501 intag = FALSE;
2502 tpos = 0;
2503 continue;
2504 }
2505
2506 NEW_BIT (NEW_TEXT_BIT);
2507
2508 if (fonts) {
2509 FontDetail *oldfont = fonts->data;
2510 if (!font->size)
2511 font->size = oldfont->size;
2512 if (!font->face)
2513 font->face = g_strdup (oldfont->face);
2514 if (!font->fore && oldfont->fore)
2515 font->fore = gdk_color_copy (oldfont->fore);
2516 if (!font->back && oldfont->back)
2517 font->back = gdk_color_copy (oldfont->back);
2518 } else {
2519 if (!font->size)
2520 font->size = 3;
2521 if (!font->face)
2522 font->face = g_strdup ("helvetica");
2523 }
2524
2525 fonts = g_slist_prepend (fonts, font);
2526 got_tag = TRUE;
2527 } else if (!g_strcasecmp (tag, "</FONT>")) {
2528 FontDetail *font;
2529
2530 if (fonts) {
2531 got_tag = TRUE;
2532 NEW_BIT (NEW_TEXT_BIT);
2533 font = fonts->data;
2534 fonts = g_slist_remove (fonts, font);
2535 g_free (font->face);
2536 if (font->fore)
2537 gdk_color_free (font->fore);
2538 if (font->back)
2539 gdk_color_free (font->back);
2540 g_free (font);
2541 } else {
2542 intag = FALSE;
2543 tpos = 0;
2544 continue;
2545 }
2546 } else if (!g_strncasecmp (tag, "<BODY ", strlen ("<BODY "))) {
2547 gchar *t, *e, *color = NULL;
2548 GdkColor *tmp;
2549
2550 got_tag = TRUE;
2551
2552 if (!(options & GTK_IMHTML_NO_COLOURS)) {
2553 t = tag + strlen ("<BODY");
2554 do {
2555 gboolean quote = FALSE;
2556 if (*t == '\0') break;
2557 while (*t && !((*t == ' ') && !quote)) {
2558 if (*t == '\"')
2559 quote = ! quote;
2560 t++;
2561 }
2562 while (*t && (*t == ' ')) t++;
2563 } while (g_strncasecmp (t, "BGCOLOR=", strlen ("BGCOLOR=")));
2564
2565 if (!g_strncasecmp (t, "BGCOLOR=", strlen ("BGCOLOR="))) {
2566 t += strlen ("BGCOLOR=");
2567 if ((*t == '\"') || (*t == '\'')) {
2568 e = ++t;
2569 while (*e && (*e != *(t - 1))) e++;
2570 if (*e != '\0') {
2571 *e = '\0';
2572 color = g_strdup (t);
2573 }
2574 } else {
2575 e = t;
2576 while (*e && !isspace ((gint) *e)) e++;
2577 if (*e == '\0') e--;
2578 *e = '\0';
2579 color = g_strdup (t);
2580 }
2581
2582 if (color != NULL) {
2583 tmp = gtk_imhtml_get_color (color);
2584 g_free (color);
2585 if (tmp != NULL) {
2586 NEW_BIT (NEW_TEXT_BIT);
2587 bg = tmp;
2588 UPDATE_BG_COLORS;
2589 }
2590 }
2591 }
2592 }
2593 } else if (!g_strncasecmp (tag, "<A ", strlen ("<A "))) {
2594 gchar *t, *e;
2595
2596 got_tag = TRUE;
2597 NEW_BIT (NEW_TEXT_BIT);
2598
2599 if (url != NULL)
2600 g_free (url);
2601 url = NULL;
2602
2603 t = tag + strlen ("<A");
2604 do {
2605 gboolean quote = FALSE;
2606 if (*t == '\0') break;
2607 while (*t && !((*t == ' ') && !quote)) {
2608 if (*t == '\"')
2609 quote = ! quote;
2610 t++;
2611 }
2612 while (*t && (*t == ' ')) t++;
2613 } while (g_strncasecmp (t, "HREF=", strlen ("HREF=")));
2614
2615 if (!g_strncasecmp (t, "HREF=", strlen ("HREF="))) {
2616 t += strlen ("HREF=");
2617 if ((*t == '\"') || (*t == '\'')) {
2618 e = ++t;
2619 while (*e && (*e != *(t - 1))) e++;
2620 if (*e != '\0') {
2621 *e = '\0';
2622 url = g_strdup (t);
2623 }
2624 } else {
2625 e = t;
2626 while (*e && !isspace ((gint) *e)) e++;
2627 if (*e == '\0') e--;
2628 *e = '\0';
2629 url = g_strdup (t);
2630 }
2631 }
2632 } else if (!g_strcasecmp (tag, "</A>")) {
2633 got_tag = TRUE;
2634 if (url != NULL) {
2635 NEW_BIT (NEW_TEXT_BIT);
2636 g_free (url);
2637 }
2638 url = NULL;
2639 } else if (!g_strncasecmp (tag, "<IMG ", strlen ("<IMG "))) {
2640 gchar *t, *e, *src = NULL;
2641 gchar *copy = g_strdup (tag);
2642 gchar **xpm;
2643 GdkColor *clr = NULL;
2644 GtkIMHtmlBit *bit;
2645
2646 intag = FALSE;
2647 tpos = 0;
2648
2649 if (imhtml->img == NULL)
2650 continue;
2651
2652 t = tag + strlen ("<IMG");
2653 do {
2654 gboolean quote = FALSE;
2655 if (*t == '\0') break;
2656 while (*t && !((*t == ' ') && !quote)) {
2657 if (*t == '\"')
2658 quote = ! quote;
2659 t++;
2660 }
2661 while (*t && (*t == ' ')) t++;
2662 } while (g_strncasecmp (t, "SRC=", strlen ("SRC=")));
2663
2664 if (!g_strncasecmp (t, "SRC=", strlen ("SRC="))) {
2665 t += strlen ("SRC=");
2666 if ((*t == '\"') || (*t == '\'')) {
2667 e = ++t;
2668 while (*e && (*e != *(t - 1))) e++;
2669 if (*e != '\0') {
2670 *e = '\0';
2671 src = g_strdup (t);
2672 }
2673 } else {
2674 e = t;
2675 while (*e && !isspace ((gint) *e)) e++;
2676 if (*e == '\0') e--;
2677 *e = '\0';
2678 src = g_strdup (t);
2679 }
2680 }
2681
2682 if (src == NULL) {
2683 ws [wpos] = 0;
2684 strcat (ws, copy);
2685 wpos = strlen (ws);
2686 g_free (copy);
2687 continue;
2688 }
2689
2690 xpm = (* imhtml->img) (src);
2691 if (xpm == NULL) {
2692 g_free (src);
2693 ws [wpos] = 0;
2694 strcat (ws, copy);
2695 wpos = strlen (ws);
2696 g_free (copy);
2697 continue;
2698 }
2699
2700 g_free (copy);
2701
2702 if (!fonts || ((clr = ((FontDetail *)fonts->data)->back) == NULL))
2703 clr = (bg != NULL) ? bg : &GTK_WIDGET (imhtml)->style->white;
2704
2705 if (!GTK_WIDGET_REALIZED (imhtml))
2706 gtk_widget_realize (GTK_WIDGET (imhtml));
2707
2708 bit = g_new0 (GtkIMHtmlBit, 1);
2709 bit->type = TYPE_IMG;
2710 bit->pm = gdk_pixmap_create_from_xpm_d (GTK_WIDGET (imhtml)->window,
2711 &bit->bm,
2712 clr,
2713 xpm);
2714 if (url)
2715 bit->url = g_strdup (url);
2716
2717 NEW_BIT (bit);
2718
2719 g_free (src);
2720
2721 continue;
2722 } else if (!g_strcasecmp (tag, "<P>") ||
2723 !g_strcasecmp (tag, "</P>") ||
2724 !g_strncasecmp (tag, "<P ", strlen ("<P ")) ||
2725 !g_strcasecmp (tag, "<PRE>") ||
2726 !g_strcasecmp (tag, "</PRE>") ||
2727 !g_strcasecmp (tag, "<HTML>") ||
2728 !g_strcasecmp (tag, "</HTML>") ||
2729 !g_strcasecmp (tag, "<BODY>") ||
2730 !g_strcasecmp (tag, "</BODY>") ||
2731 !g_strcasecmp (tag, "<FONT>") ||
2732 !g_strcasecmp (tag, "<HEAD>") ||
2733 !g_strcasecmp (tag, "</HEAD>")) {
2734 intag = FALSE;
2735 tpos = 0;
2736 continue;
2737 }
2738
2739 if (!got_tag) {
2740 ws [wpos] = 0;
2741 strcat (ws, tag);
2742 wpos = strlen (ws);
2743 } else {
2744 wpos = 0;
2745 }
2746 intag = FALSE;
2747 tpos = 0;
2748 } else if (*c == '&' && !intag) {
2749 if (!g_strncasecmp (c, "&amp;", 5)) {
2750 ws [wpos++] = '&';
2751 c += 5;
2752 } else if (!g_strncasecmp (c, "&lt;", 4)) {
2753 ws [wpos++] = '<';
2754 c += 4;
2755 } else if (!g_strncasecmp (c, "&gt;", 4)) {
2756 ws [wpos++] = '>';
2757 c += 4;
2758 } else if (!g_strncasecmp (c, "&nbsp;", 6)) {
2759 ws [wpos++] = ' ';
2760 c += 6;
2761 } else if (!g_strncasecmp (c, "&copy;", 6)) {
2762 ws [wpos++] = '©';
2763 c += 6;
2764 } else if (!g_strncasecmp (c, "&quot;", 6)) {
2765 ws [wpos++] = '\"';
2766 c += 6;
2767 } else if (!g_strncasecmp (c, "&reg;", 5)) {
2768 ws [wpos++] = '®';
2769 c += 5;
2770 } else if (*(c + 1) == '#') {
2771 gint pound = 0;
2772 if (sscanf (c, "&#%d;", &pound) == 1) {
2773 if (*(c + 3 + (gint)log10 (pound)) != ';') {
2774 ws [wpos++] = *c++;
2775 continue;
2776 }
2777 ws [wpos++] = (gchar)pound;
2778 c += 2;
2779 while (isdigit ((gint) *c)) c++;
2780 if (*c == ';') c++;
2781 } else {
2782 ws [wpos++] = *c++;
2783 }
2784 } else {
2785 ws [wpos++] = *c++;
2786 }
2787 } else if (intag) {
2788 if (*c == '\"')
2789 tagquote = !tagquote;
2790 tag [tpos++] = *c++;
2791 } else if (incomment) {
2792 ws [wpos++] = *c++;
2793 } else if (((smilelen = gtk_imhtml_is_smiley (imhtml, c)) != 0)) {
2794 ws [wpos] = 0;
2795 wpos = 0;
2796 NEW_BIT (NEW_TEXT_BIT);
2797 g_snprintf (ws, smilelen + 1, "%s", c);
2798 NEW_BIT (NEW_SMILEY_BIT);
2799 c += smilelen;
2800 } else if (*c == '\n') {
2801 if (!(options & GTK_IMHTML_NO_NEWLINE)) {
2802 ws [wpos] = 0;
2803 wpos = 0;
2804 NEW_BIT (NEW_TEXT_BIT);
2805 NEW_BIT (NEW_BR_BIT);
2806 }
2807 c++;
2808 } else {
2809 ws [wpos++] = *c++;
2810 }
2811 }
2812
2813 if (intag) {
2814 tag [tpos] = 0;
2815 c = tag;
2816 while (*c) {
2817 if ((smilelen = gtk_imhtml_is_smiley (imhtml, c)) != 0) {
2818 ws [wpos] = 0;
2819 wpos = 0;
2820 NEW_BIT (NEW_TEXT_BIT);
2821 g_snprintf (ws, smilelen + 1, "%s", c);
2822 NEW_BIT (NEW_SMILEY_BIT);
2823 c += smilelen;
2824 } else {
2825 ws [wpos++] = *c++;
2826 }
2827 }
2828 } else if (incomment) {
2829 ws [wpos] = 0;
2830 wpos = 0;
2831 strcat (tag, ws);
2832 ws [wpos] = 0;
2833 c = tag;
2834 while (*c) {
2835 if ((smilelen = gtk_imhtml_is_smiley (imhtml, c)) != 0) {
2836 ws [wpos] = 0;
2837 wpos = 0;
2838 NEW_BIT (NEW_TEXT_BIT);
2839 g_snprintf (ws, smilelen + 1, "%s", c);
2840 NEW_BIT (NEW_SMILEY_BIT);
2841 c += smilelen;
2842 } else {
2843 ws [wpos++] = *c++;
2844 }
2845 }
2846 }
2847
2848 ws [wpos] = 0;
2849 NEW_BIT (NEW_TEXT_BIT);
2850
2851 while (newbits) {
2852 GtkIMHtmlBit *bit = newbits->data;
2853 imhtml->bits = g_list_append (imhtml->bits, bit);
2854 newbits = g_list_remove (newbits, bit);
2855 gtk_imhtml_draw_bit (imhtml, bit);
2856 }
2857
2858 gtk_widget_set_usize (GTK_WIDGET (imhtml), -1, imhtml->y + 5);
2859
2860 if (!(options & GTK_IMHTML_NO_SCROLL) &&
2861 scrolldown &&
2862 (imhtml->y + 5 >= GTK_WIDGET (imhtml)->allocation.height))
2863 gtk_adjustment_set_value (vadj, imhtml->y + 5 - GTK_WIDGET (imhtml)->allocation.height);
2864
2865 if (url) {
2866 g_free (url);
2867 if (retval)
2868 retval = g_string_append (retval, "</A>");
2869 }
2870 if (bg)
2871 gdk_color_free (bg);
2872 while (fonts) {
2873 FontDetail *font = fonts->data;
2874 fonts = g_slist_remove (fonts, font);
2875 g_free (font->face);
2876 if (font->fore)
2877 gdk_color_free (font->fore);
2878 if (font->back)
2879 gdk_color_free (font->back);
2880 g_free (font);
2881 if (retval)
2882 retval = g_string_append (retval, "</FONT>");
2883 }
2884 if (retval) {
2885 while (bold) {
2886 retval = g_string_append (retval, "</B>");
2887 bold--;
2888 }
2889 while (italics) {
2890 retval = g_string_append (retval, "</I>");
2891 italics--;
2892 }
2893 while (underline) {
2894 retval = g_string_append (retval, "</U>");
2895 underline--;
2896 }
2897 while (strike) {
2898 retval = g_string_append (retval, "</S>");
2899 strike--;
2900 }
2901 while (sub) {
2902 retval = g_string_append (retval, "</SUB>");
2903 sub--;
2904 }
2905 while (sup) {
2906 retval = g_string_append (retval, "</SUP>");
2907 sup--;
2908 }
2909 while (title) {
2910 retval = g_string_append (retval, "</TITLE>");
2911 title--;
2912 }
2913 }
2914 g_free (ws);
2915 g_free (tag);
2916
2917 return retval;
2918 }