Add some GT code points.
[chise/xemacs-chise.git.1] / src / gtk-xemacs.c
1 /* gtk-xemacs.c
2 **
3 ** Description: A widget to encapsulate a XEmacs 'text widget'
4 **
5 ** Created by: William M. Perry
6 ** Copyright (c) 2000 William M. Perry <wmperry@gnu.org>
7 **
8 */
9
10 #include <config.h>
11
12 #include "lisp.h"
13 #include "console-gtk.h"
14 #include "objects-gtk.h"
15 #include "gtk-xemacs.h"
16 #include "window.h"
17 #include "faces.h"
18
19 extern Lisp_Object Vmodeline_face;
20 extern Lisp_Object Vscrollbar_on_left_p;
21
22 EXFUN (Fmake_image_instance, 4);
23
24 static void gtk_xemacs_class_init       (GtkXEmacsClass *klass);
25 static void gtk_xemacs_init             (GtkXEmacs *xemacs);
26 static void gtk_xemacs_size_allocate    (GtkWidget *widget, GtkAllocation *allocaction);
27 static void gtk_xemacs_draw             (GtkWidget *widget, GdkRectangle *area);
28 static void gtk_xemacs_paint            (GtkWidget *widget, GdkRectangle *area);
29 static void gtk_xemacs_size_request     (GtkWidget *widget, GtkRequisition *requisition);
30 static void gtk_xemacs_realize          (GtkWidget *widget);
31 static void gtk_xemacs_style_set        (GtkWidget *widget, GtkStyle *previous_style);
32 static gint gtk_xemacs_expose           (GtkWidget *widget, GdkEventExpose *event);
33
34 guint
35 gtk_xemacs_get_type (void)
36 {
37   static guint xemacs_type = 0;
38
39   if (!xemacs_type)
40     {
41       static const GtkTypeInfo xemacs_info =
42       {
43         "GtkXEmacs",
44         sizeof (GtkXEmacs),
45         sizeof (GtkXEmacsClass),
46         (GtkClassInitFunc) gtk_xemacs_class_init,
47         (GtkObjectInitFunc) gtk_xemacs_init,
48         /* reserved_1 */ NULL,
49         /* reserved_2 */ NULL,
50         (GtkClassInitFunc) NULL,
51       };
52
53       xemacs_type = gtk_type_unique (gtk_fixed_get_type (), &xemacs_info);
54     }
55
56   return xemacs_type;
57 }
58
59 static GtkWidgetClass *parent_class;
60
61 extern gint emacs_gtk_button_event_handler(GtkWidget *widget, GdkEventButton *event);
62 extern gint emacs_gtk_key_event_handler(GtkWidget *widget, GdkEventKey *event);
63 extern gint emacs_gtk_motion_event_handler(GtkWidget *widget, GdkEventMotion *event);
64
65 static void
66 gtk_xemacs_class_init (GtkXEmacsClass *class)
67 {
68   GtkWidgetClass *widget_class;
69
70   widget_class = (GtkWidgetClass*) class;
71   parent_class = (GtkWidgetClass *) gtk_type_class (gtk_fixed_get_type ());
72
73   widget_class->size_allocate = gtk_xemacs_size_allocate;
74   widget_class->size_request = gtk_xemacs_size_request;
75   widget_class->draw = gtk_xemacs_draw;
76   widget_class->expose_event = gtk_xemacs_expose;
77   widget_class->realize = gtk_xemacs_realize;
78   widget_class->button_press_event = emacs_gtk_button_event_handler;
79   widget_class->button_release_event = emacs_gtk_button_event_handler;
80   widget_class->key_press_event = emacs_gtk_key_event_handler;
81   widget_class->key_release_event = emacs_gtk_key_event_handler;
82   widget_class->motion_notify_event = emacs_gtk_motion_event_handler;
83   widget_class->style_set = gtk_xemacs_style_set;
84 }
85
86 static void
87 gtk_xemacs_init (GtkXEmacs *xemacs)
88 {
89     GTK_WIDGET_SET_FLAGS (xemacs, GTK_CAN_FOCUS);
90 }
91
92 GtkWidget*
93 gtk_xemacs_new (struct frame *f)
94 {
95   GtkXEmacs *xemacs;
96
97   xemacs = gtk_type_new (gtk_xemacs_get_type ());
98   xemacs->f = f;
99
100   return GTK_WIDGET (xemacs);
101 }
102
103 static void
104 __nuke_background_items (GtkWidget *widget)
105 {
106   /* This bit of voodoo is here to get around the annoying flicker
107      when GDK tries to futz with our background pixmap as well as
108      XEmacs doing it
109
110      We do NOT set the background of this widget window, that way
111      there is NO flickering, etc.  The downside is the XEmacs frame
112      appears as 'seethru' when XEmacs is too busy to redraw the
113      frame.
114
115      Well, wait, we do... otherwise there sre weird 'seethru' areas
116      even when XEmacs does a full redisplay.  Most noticable in some
117      areas of the modeline, or in the right-hand-side of the window
118      between the scrollbar ad n the edge of the window.
119   */
120   if (widget->window)
121     {
122       gdk_window_set_back_pixmap (widget->window, NULL, 0);
123       gdk_window_set_back_pixmap (widget->parent->window, NULL, 0);
124       gdk_window_set_background (widget->parent->window,
125                                  &widget->style->bg[GTK_STATE_NORMAL]);
126       gdk_window_set_background (widget->window,
127                                  &widget->style->bg[GTK_STATE_NORMAL]);
128     }
129 }
130
131 extern Lisp_Object xemacs_gtk_convert_color(GdkColor *c, GtkWidget *w);
132
133 /* From objects-gtk.c */
134 extern Lisp_Object __get_gtk_font_truename (GdkFont *gdk_font, int expandp);
135
136 #define convert_font(f) __get_gtk_font_truename (f, 0)
137
138 static void
139 smash_face_fallbacks (struct frame *f, GtkStyle *style)
140 {
141 #define FROB(face,prop,slot) do {                                                       \
142                                 Lisp_Object fallback = Qnil;                            \
143                                 Lisp_Object specifier = Fget (face, prop, Qnil);        \
144                                 struct Lisp_Specifier *sp = NULL;                       \
145                                 if (NILP (specifier)) continue;                         \
146                                 sp = XSPECIFIER (specifier);                            \
147                                 fallback = sp->fallback;                                \
148                                 if (EQ (Fcar (Fcar (Fcar (fallback))), Qgtk))           \
149                                         fallback = XCDR (fallback);                     \
150                                 if (! NILP (slot))                                      \
151                                         fallback = acons (list1 (Qgtk),                 \
152                                                                   slot,                 \
153                                                                   fallback);            \
154                                 set_specifier_fallback (specifier, fallback);           \
155                              } while (0);
156 #define FROB_FACE(face,fg_slot,bg_slot) \
157 do {                                                                                    \
158         FROB (face, Qforeground, xemacs_gtk_convert_color (&style->fg_slot[GTK_STATE_NORMAL], FRAME_GTK_SHELL_WIDGET (f)));     \
159         FROB (face, Qbackground, xemacs_gtk_convert_color (&style->bg_slot[GTK_STATE_NORMAL], FRAME_GTK_SHELL_WIDGET (f)));     \
160         if (style->rc_style && style->rc_style->bg_pixmap_name[GTK_STATE_NORMAL])       \
161         {                                                                               \
162                 FROB (Vdefault_face, Qbackground_pixmap,                                \
163                         Fmake_image_instance (build_string (style->rc_style->bg_pixmap_name[GTK_STATE_NORMAL]), \
164                                           f->device, Qnil, make_int (5)));                      \
165         }                                                                               \
166         else                                                                            \
167         {                                                                               \
168                 FROB (Vdefault_face, Qbackground_pixmap, Qnil);                         \
169         }                                                                               \
170 } while (0)
171
172   FROB (Vdefault_face, Qfont, convert_font (style->font));
173   FROB_FACE (Vdefault_face, fg, bg);
174   FROB_FACE (Vgui_element_face, text, mid);
175
176 #undef FROB
177 #undef FROB_FACE
178 }
179
180 #ifdef HAVE_SCROLLBARS
181 static void
182 smash_scrollbar_specifiers (struct frame *f, GtkStyle *style)
183 {
184   Lisp_Object frame;
185   int slider_size = 0;
186   int hsize, vsize;
187   GtkRangeClass *klass;
188
189   XSETFRAME (frame, f);
190
191   klass = (GtkRangeClass *) gtk_type_class (GTK_TYPE_SCROLLBAR);
192   slider_size = klass->slider_width;
193   hsize = slider_size + (style->klass->ythickness * 2);
194   vsize = slider_size + (style->klass->xthickness * 2);
195
196   style = gtk_style_attach (style,
197                             GTK_WIDGET (DEVICE_GTK_APP_SHELL (XDEVICE (FRAME_DEVICE (f))))->window);
198
199   Fadd_spec_to_specifier (Vscrollbar_width, make_int (vsize), frame, Qnil, Qnil);
200   Fadd_spec_to_specifier (Vscrollbar_height, make_int (hsize), frame, Qnil, Qnil);
201 }
202 #else
203 #define smash_scrollbar_specifiers(x,y)
204 #endif /* HAVE_SCROLLBARS */
205
206 static void
207 gtk_xemacs_realize (GtkWidget *widget)
208 {
209   parent_class->realize (widget);
210   gtk_xemacs_style_set (widget, gtk_widget_get_style (widget));
211 }
212
213 static void
214 gtk_xemacs_style_set (GtkWidget *widget, GtkStyle *previous_style)
215 {
216   GtkStyle *new_style = gtk_widget_get_style (widget);
217   GtkXEmacs *x = GTK_XEMACS (widget);
218
219   parent_class->style_set (widget, previous_style);
220
221   if (x->f)
222     {
223       __nuke_background_items (widget);
224 #if 0
225       smash_face_fallbacks (x->f, new_style);
226 #endif
227       smash_scrollbar_specifiers (x->f, new_style);
228     }
229 }
230
231 static void
232 gtk_xemacs_size_request (GtkWidget *widget, GtkRequisition *requisition)
233 {
234     GtkXEmacs *x = GTK_XEMACS (widget);
235     struct frame *f = GTK_XEMACS_FRAME (x);
236     int width, height;
237
238     if (f)
239       {
240         char_to_pixel_size (f, FRAME_WIDTH (f), FRAME_HEIGHT (f),
241                             &width, &height);
242         requisition->width = width;
243         requisition->height = height;
244       }
245     else
246       {
247         parent_class->size_request (widget, requisition);
248       }
249 }
250
251 static void
252 gtk_xemacs_size_allocate (GtkWidget *widget, GtkAllocation *allocation)
253 {
254     GtkXEmacs *x = GTK_XEMACS (widget);
255     struct frame *f = GTK_XEMACS_FRAME (x);
256     int columns, rows;
257
258     parent_class->size_allocate(widget, allocation);
259
260     if (f)
261       {
262         f->pixwidth = allocation->width;
263         f->pixheight = allocation->height;
264
265         pixel_to_char_size (f,
266                             allocation->width,
267                             allocation->height, &columns, &rows);
268
269         change_frame_size (f, rows, columns, 1);
270       }
271 }
272
273 static void
274 gtk_xemacs_paint (GtkWidget *widget, GdkRectangle *area)
275 {
276     GtkXEmacs *x = GTK_XEMACS (widget);
277     struct frame *f = GTK_XEMACS_FRAME (x);
278     gtk_redraw_exposed_area (f, area->x, area->y, area->width, area->height);
279 }
280
281 static void
282 gtk_xemacs_draw (GtkWidget *widget, GdkRectangle *area)
283 {
284     GtkFixed *fixed = GTK_FIXED (widget);
285     GtkFixedChild *child;
286     GdkRectangle child_area;
287     GList *children;
288
289     /* I need to manually iterate over the children instead of just
290        chaining to parent_class->draw() because it calls
291        gtk_fixed_paint() directly, which clears the background window,
292        which causes A LOT of flashing. */
293
294     gtk_xemacs_paint (widget, area);
295
296     children = fixed->children;
297
298     while (children)
299       {
300         child = children->data;
301         children = children->next;
302         /* #### This is what causes the scrollbar flickering!
303            Evidently the scrollbars pretty much take care of drawing
304            themselves in most cases.  Then we come along and tell them
305            to redraw again!
306
307            But if we just leave it out, then they do not get drawn
308            correctly the first time!
309
310            Scrollbar flickering has been greatly helped by the
311            optimizations in scrollbar-gtk.c /
312            gtk_update_scrollbar_instance_status (), so this is not that
313            big a deal anymore.
314         */
315         if (gtk_widget_intersect (child->widget, area, &child_area))
316           {
317             gtk_widget_draw (child->widget, &child_area);
318           }
319       }
320 }
321
322 static gint
323 gtk_xemacs_expose (GtkWidget *widget, GdkEventExpose *event)
324 {
325     GtkXEmacs *x = GTK_XEMACS (widget);
326     struct frame *f = GTK_XEMACS_FRAME (x);
327     GdkRectangle *a = &event->area;
328
329     /* This takes care of drawing the scrollbars, etc */
330     parent_class->expose_event (widget, event);
331
332     /* Now draw the actual frame data */
333     if (!check_for_ignored_expose (f, a->x, a->y, a->width, a->height) &&
334         !find_matching_subwindow (f, a->x, a->y, a->width, a->height))
335       gtk_redraw_exposed_area (f, a->x, a->y, a->width, a->height);
336     return (TRUE);
337 }
338
339 Lisp_Object
340 xemacs_gtk_convert_color(GdkColor *c, GtkWidget *w)
341 {
342   char color_buf[255];
343
344   sprintf (color_buf, "#%04x%04x%04x", c->red, c->green, c->blue);
345
346   return (build_string (color_buf));
347 }