]> git.saurik.com Git - wxWidgets.git/blob - src/gtk/win_gtk.c
projects / wxWidgets.git / blob
? search:


232fb546531b78ce44e4594cd65fc7d9cef7ba4e
[wxWidgets.git] / src / gtk / win_gtk.c
1 /* ///////////////////////////////////////////////////////////////////////////
2 // Name: src/gtk/win_gtk.c
3 // Purpose: Native GTK+ widget for wxWidgets, based on GtkLayout and
4 // GtkFixed. It makes use of the gravity window property and
5 // therefore does not work with GTK 1.0.
6 // Author: Robert Roebling
7 // Id: $Id$
8 // Copyright: (c) 1998 Robert Roebling
9 // Licence: wxWidgets licence
10 /////////////////////////////////////////////////////////////////////////// */
11
12 #ifdef VMS
13 #define XCheckIfEvent XCHECKIFEVENT
14 #endif
15
16 #include "wx/platform.h"
17 #include "wx/gtk/win_gtk.h"
18
19 #ifdef __cplusplus
20 extern "C" {
21 #endif /* __cplusplus */
22
23 typedef struct _GtkPizzaAdjData GtkPizzaAdjData;
24
25 struct _GtkPizzaAdjData
26 {
27 gint dx;
28 gint dy;
29 };
30
31 static void gtk_pizza_class_init (GtkPizzaClass *klass);
32 static void gtk_pizza_init (GtkPizza *pizza);
33
34 static void gtk_pizza_realize (GtkWidget *widget);
35 static void gtk_pizza_unrealize (GtkWidget *widget);
36
37 static void gtk_pizza_map (GtkWidget *widget);
38
39 static void gtk_pizza_size_request (GtkWidget *widget,
40 GtkRequisition *requisition);
41 static void gtk_pizza_size_allocate (GtkWidget *widget,
42 GtkAllocation *allocation);
43 static void gtk_pizza_style_set (GtkWidget *widget,
44 GtkStyle *previous_style);
45 static void gtk_pizza_add (GtkContainer *container,
46 GtkWidget *widget);
47 static void gtk_pizza_remove (GtkContainer *container,
48 GtkWidget *widget);
49 static void gtk_pizza_forall (GtkContainer *container,
50 gboolean include_internals,
51 GtkCallback callback,
52 gpointer callback_data);
53
54 static void gtk_pizza_allocate_child (GtkPizza *pizza,
55 GtkPizzaChild *child);
56 static void gtk_pizza_adjust_allocations_recurse (GtkWidget *widget,
57 gpointer cb_data);
58
59 static GtkType gtk_pizza_child_type (GtkContainer *container);
60
61 static void gtk_pizza_scroll_set_adjustments (GtkPizza *pizza,
62 GtkAdjustment *hadj,
63 GtkAdjustment *vadj);
64
65 static GtkWidgetClass* pizza_parent_class;
66
67 GtkType
68 gtk_pizza_get_type ()
69 {
70 static GtkType pizza_type = 0;
71
72 if (!pizza_type)
73 {
74 static const GTypeInfo pizza_info =
75 {
76 sizeof (GtkPizzaClass),
77 NULL, /* base_init */
78 NULL, /* base_finalize */
79 (GClassInitFunc) gtk_pizza_class_init,
80 NULL, /* class_finalize */
81 NULL, /* class_data */
82 sizeof (GtkPizza),
83 16, /* n_preallocs */
84 (GInstanceInitFunc) gtk_pizza_init,
85 NULL
86 };
87 pizza_type = g_type_register_static (GTK_TYPE_CONTAINER, "GtkPizza", &pizza_info, (GTypeFlags)0);
88 }
89
90 return pizza_type;
91 }
92
93 /* Marshaller needed for set_scroll_adjustments signal,
94 generated with GLib-2.4.6 glib-genmarshal */
95 #define g_marshal_value_peek_object(v) g_value_get_object (v)
96 static void
97 g_cclosure_user_marshal_VOID__OBJECT_OBJECT (GClosure *closure,
98 GValue *return_value,
99 guint n_param_values,
100 const GValue *param_values,
101 gpointer invocation_hint,
102 gpointer marshal_data)
103 {
104 typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT) (gpointer data1,
105 gpointer arg_1,
106 gpointer arg_2,
107 gpointer data2);
108 register GMarshalFunc_VOID__OBJECT_OBJECT callback;
109 register GCClosure *cc = (GCClosure*) closure;
110 register gpointer data1, data2;
111
112 g_return_if_fail (n_param_values == 3);
113
114 if (G_CCLOSURE_SWAP_DATA (closure))
115 {
116 data1 = closure->data;
117 data2 = g_value_peek_pointer (param_values + 0);
118 }
119 else
120 {
121 data1 = g_value_peek_pointer (param_values + 0);
122 data2 = closure->data;
123 }
124 callback = (GMarshalFunc_VOID__OBJECT_OBJECT) (marshal_data ? marshal_data : cc->callback);
125
126 callback (data1,
127 g_marshal_value_peek_object (param_values + 1),
128 g_marshal_value_peek_object (param_values + 2),
129 data2);
130 }
131
132 static void
133 gtk_pizza_class_init (GtkPizzaClass *klass)
134 {
135 GtkObjectClass *object_class;
136 GtkWidgetClass *widget_class;
137 GtkContainerClass *container_class;
138
139 object_class = (GtkObjectClass*) klass;
140 widget_class = (GtkWidgetClass*) klass;
141 container_class = (GtkContainerClass*) klass;
142 pizza_parent_class = gtk_type_class (GTK_TYPE_CONTAINER);
143
144 widget_class->map = gtk_pizza_map;
145 widget_class->realize = gtk_pizza_realize;
146 widget_class->unrealize = gtk_pizza_unrealize;
147 widget_class->size_request = gtk_pizza_size_request;
148 widget_class->size_allocate = gtk_pizza_size_allocate;
149 widget_class->style_set = gtk_pizza_style_set;
150
151 container_class->add = gtk_pizza_add;
152 container_class->remove = gtk_pizza_remove;
153 container_class->forall = gtk_pizza_forall;
154
155 container_class->child_type = gtk_pizza_child_type;
156
157 klass->set_scroll_adjustments = gtk_pizza_scroll_set_adjustments;
158
159 widget_class->set_scroll_adjustments_signal =
160 g_signal_new(
161 "set_scroll_adjustments",
162 G_TYPE_FROM_CLASS(object_class),
163 G_SIGNAL_RUN_LAST,
164 G_STRUCT_OFFSET(GtkPizzaClass, set_scroll_adjustments),
165 NULL,
166 NULL,
167 g_cclosure_user_marshal_VOID__OBJECT_OBJECT,
168 G_TYPE_NONE,
169 2,
170 GTK_TYPE_ADJUSTMENT,
171 GTK_TYPE_ADJUSTMENT);
172 }
173
174 static GtkType
175 gtk_pizza_child_type (GtkContainer *container)
176 {
177 return GTK_TYPE_WIDGET;
178 }
179
180 static void
181 gtk_pizza_init (GtkPizza *pizza)
182 {
183 GTK_WIDGET_UNSET_FLAGS (pizza, GTK_NO_WINDOW);
184
185 pizza->children = NULL;
186
187 pizza->bin_window = NULL;
188
189 pizza->m_xoffset = 0;
190 pizza->m_yoffset = 0;
191 }
192
193 GtkWidget*
194 gtk_pizza_new ()
195 {
196 GtkPizza *pizza;
197
198 pizza = g_object_new (gtk_pizza_get_type (), NULL);
199
200 return GTK_WIDGET (pizza);
201 }
202
203 gint gtk_pizza_get_xoffset (GtkPizza *pizza)
204 {
205 g_return_val_if_fail ( (pizza != NULL), -1 );
206 g_return_val_if_fail ( (GTK_IS_PIZZA (pizza)), -1 );
207
208 return pizza->m_xoffset;
209 }
210
211 gint gtk_pizza_get_yoffset (GtkPizza *pizza)
212 {
213 g_return_val_if_fail ( (pizza != NULL), -1 );
214 g_return_val_if_fail ( (GTK_IS_PIZZA (pizza)), -1 );
215
216 return pizza->m_yoffset;
217 }
218
219 void gtk_pizza_set_xoffset (GtkPizza *pizza, gint xoffset)
220 {
221 g_return_if_fail (pizza != NULL);
222 g_return_if_fail (GTK_IS_PIZZA (pizza));
223
224 pizza->m_xoffset = xoffset;
225 // do something
226 }
227
228 void gtk_pizza_set_yoffset (GtkPizza *pizza, gint yoffset)
229 {
230 g_return_if_fail (pizza != NULL);
231 g_return_if_fail (GTK_IS_PIZZA (pizza));
232
233 pizza->m_xoffset = yoffset;
234 // do something
235 }
236
237 gint gtk_pizza_get_rtl_offset (GtkPizza *pizza)
238 {
239 gint border;
240
241 g_return_val_if_fail ( (pizza != NULL), 0 );
242 g_return_val_if_fail ( (GTK_IS_PIZZA (pizza)), 0 );
243
244 if (!pizza->bin_window) return 0;
245
246 border = pizza->container.border_width;
247
248 return GTK_WIDGET(pizza)->allocation.width - border*2;
249 }
250
251
252 static void
253 gtk_pizza_scroll_set_adjustments (GtkPizza *pizza,
254 GtkAdjustment *hadj,
255 GtkAdjustment *vadj)
256 {
257 /* We handle scrolling in the wxScrolledWindow, not here. */
258 }
259
260 void
261 gtk_pizza_put (GtkPizza *pizza,
262 GtkWidget *widget,
263 gint x,
264 gint y,
265 gint width,
266 gint height)
267 {
268 GtkPizzaChild *child_info;
269
270 g_return_if_fail (pizza != NULL);
271 g_return_if_fail (GTK_IS_PIZZA (pizza));
272 g_return_if_fail (widget != NULL);
273
274 child_info = g_new (GtkPizzaChild, 1);
275
276 child_info->widget = widget;
277 child_info->x = x;
278 child_info->y = y;
279 child_info->width = width;
280 child_info->height = height;
281
282 pizza->children = g_list_append (pizza->children, child_info);
283
284 if (GTK_WIDGET_REALIZED (pizza))
285 gtk_widget_set_parent_window (widget, pizza->bin_window);
286
287 gtk_widget_set_parent (widget, GTK_WIDGET (pizza));
288
289 if (GTK_WIDGET_REALIZED (pizza))
290 gtk_pizza_allocate_child (pizza, child_info);
291 }
292
293 void
294 gtk_pizza_set_size (GtkPizza *pizza,
295 GtkWidget *widget,
296 gint x,
297 gint y,
298 gint width,
299 gint height)
300 {
301 GtkPizzaChild *child;
302 GList *children;
303
304 g_return_if_fail (pizza != NULL);
305 g_return_if_fail (GTK_IS_PIZZA (pizza));
306 g_return_if_fail (widget != NULL);
307
308 #ifndef WX_WARN_ILLEGAL_SETSIZE
309 /* this really shouldn't happen -- but it does, a lot, right now and we
310 can't pass negative values to gtk_widget_set_size_request() without getting
311 a warning printed out, so filter them out here */
312 if ( width < 0 )
313 width = 0;
314 if ( height < 0 )
315 height = 0;
316 #endif
317
318 children = pizza->children;
319 while (children)
320 {
321 child = children->data;
322 children = children->next;
323
324 if (child->widget == widget)
325 {
326 if ((child->x == x) &&
327 (child->y == y) &&
328 (child->width == width) &&
329 (child->height == height)) return;
330
331 child->x = x;
332 child->y = y;
333 child->width = width;
334 child->height = height;
335
336 gtk_widget_set_size_request (widget, width, height);
337
338 return;
339 }
340 }
341 }
342
343 static void
344 gtk_pizza_map (GtkWidget *widget)
345 {
346 GtkPizza *pizza;
347 GtkPizzaChild *child;
348 GList *children;
349
350 g_return_if_fail (widget != NULL);
351 g_return_if_fail (GTK_IS_PIZZA (widget));
352
353 GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
354 pizza = GTK_PIZZA (widget);
355
356 children = pizza->children;
357 while (children)
358 {
359 child = children->data;
360 children = children->next;
361
362 if ( GTK_WIDGET_VISIBLE (child->widget) &&
363 !GTK_WIDGET_MAPPED (child->widget) )
364 {
365 gtk_widget_map (child->widget);
366 }
367 }
368
369 gdk_window_show (widget->window);
370 gdk_window_show (pizza->bin_window);
371 }
372
373 static void
374 gtk_pizza_realize (GtkWidget *widget)
375 {
376 GtkPizza *pizza;
377 GdkWindowAttr attributes;
378 gint attributes_mask;
379 GtkPizzaChild *child;
380 GList *children;
381 int border;
382
383 g_return_if_fail (widget != NULL);
384 g_return_if_fail (GTK_IS_PIZZA (widget));
385
386 pizza = GTK_PIZZA (widget);
387 GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
388
389 attributes.window_type = GDK_WINDOW_CHILD;
390
391 attributes.x = widget->allocation.x;
392 attributes.y = widget->allocation.y;
393 attributes.width = widget->allocation.width;
394 attributes.height = widget->allocation.height;
395
396 border = pizza->container.border_width;
397 attributes.x += border;
398 attributes.y += border;
399 attributes.width -= 2 * border;
400 attributes.height -= 2 * border;
401
402 /* minimal size */
403 if (attributes.width < 2) attributes.width = 2;
404 if (attributes.height < 2) attributes.height = 2;
405
406 attributes.wclass = GDK_INPUT_OUTPUT;
407 attributes.visual = gtk_widget_get_visual (widget);
408 attributes.colormap = gtk_widget_get_colormap (widget);
409 attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK;
410 attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
411
412 widget->window = gdk_window_new(gtk_widget_get_parent_window (widget),
413 &attributes, attributes_mask);
414 gdk_window_set_user_data (widget->window, widget);
415
416 attributes.x = 0;
417 attributes.y = 0;
418
419 attributes.event_mask = gtk_widget_get_events (widget);
420 attributes.event_mask |= GDK_EXPOSURE_MASK |
421 GDK_SCROLL_MASK |
422 GDK_POINTER_MOTION_MASK |
423 GDK_POINTER_MOTION_HINT_MASK |
424 GDK_BUTTON_MOTION_MASK |
425 GDK_BUTTON1_MOTION_MASK |
426 GDK_BUTTON2_MOTION_MASK |
427 GDK_BUTTON3_MOTION_MASK |
428 GDK_BUTTON_PRESS_MASK |
429 GDK_BUTTON_RELEASE_MASK |
430 GDK_KEY_PRESS_MASK |
431 GDK_KEY_RELEASE_MASK |
432 GDK_ENTER_NOTIFY_MASK |
433 GDK_LEAVE_NOTIFY_MASK |
434 GDK_FOCUS_CHANGE_MASK;
435
436 pizza->bin_window = gdk_window_new(widget->window,
437 &attributes, attributes_mask);
438 gdk_window_set_user_data (pizza->bin_window, widget);
439
440 widget->style = gtk_style_attach (widget->style, widget->window);
441 gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
442 gtk_style_set_background (widget->style, pizza->bin_window, GTK_STATE_NORMAL );
443
444 /*
445 gdk_window_set_back_pixmap( widget->window, NULL, FALSE );
446 gdk_window_set_back_pixmap( pizza->bin_window, NULL, FALSE );
447 */
448
449 /* cannot be done before realisation */
450 children = pizza->children;
451 while (children)
452 {
453 child = children->data;
454 children = children->next;
455
456 gtk_widget_set_parent_window (child->widget, pizza->bin_window);
457 }
458 }
459
460 static void
461 gtk_pizza_unrealize (GtkWidget *widget)
462 {
463 GtkPizza *pizza;
464
465 g_return_if_fail (widget != NULL);
466 g_return_if_fail (GTK_IS_PIZZA (widget));
467
468 pizza = GTK_PIZZA (widget);
469
470 gdk_window_set_user_data (pizza->bin_window, NULL);
471 gdk_window_destroy (pizza->bin_window);
472 pizza->bin_window = NULL;
473
474 if (pizza_parent_class->unrealize)
475 pizza_parent_class->unrealize(widget);
476 }
477
478 static void
479 gtk_pizza_size_request (GtkWidget *widget,
480 GtkRequisition *requisition)
481 {
482 GtkPizza *pizza;
483 GtkPizzaChild *child;
484 GList *children;
485 GtkRequisition child_requisition;
486
487 g_return_if_fail (widget != NULL);
488 g_return_if_fail (GTK_IS_PIZZA (widget));
489 g_return_if_fail (requisition != NULL);
490
491 pizza = GTK_PIZZA (widget);
492
493 children = pizza->children;
494 while (children)
495 {
496 child = children->data;
497 children = children->next;
498
499 if (GTK_WIDGET_VISIBLE (child->widget))
500 {
501 gtk_widget_size_request (child->widget, &child_requisition);
502 }
503 }
504
505 /* request very little, I'm not sure if requesting nothing
506 will always have positive effects on stability... */
507 requisition->width = 2;
508 requisition->height = 2;
509 }
510
511 static void
512 gtk_pizza_size_allocate (GtkWidget *widget,
513 GtkAllocation *allocation)
514 {
515 GtkPizza *pizza;
516 gint border;
517 gint x,y,w,h;
518 GtkPizzaChild *child;
519 GList *children;
520 gboolean only_resize;
521
522 g_return_if_fail (widget != NULL);
523 g_return_if_fail (GTK_IS_PIZZA(widget));
524 g_return_if_fail (allocation != NULL);
525
526 pizza = GTK_PIZZA (widget);
527
528 only_resize = ((widget->allocation.x == allocation->x) &&
529 (widget->allocation.y == allocation->y));
530 widget->allocation = *allocation;
531
532 border = pizza->container.border_width;
533
534 x = allocation->x + border;
535 y = allocation->y + border;
536 w = allocation->width - border*2;
537 h = allocation->height - border*2;
538 if (w < 0)
539 w = 0;
540 if (h < 0)
541 h = 0;
542
543 if (GTK_WIDGET_REALIZED (widget))
544 {
545 if (only_resize)
546 gdk_window_resize( widget->window, w, h );
547 else
548 gdk_window_move_resize( widget->window, x, y, w, h );
549
550 gdk_window_resize( pizza->bin_window, w, h );
551 }
552
553 children = pizza->children;
554 while (children)
555 {
556 child = children->data;
557 children = children->next;
558
559 gtk_pizza_allocate_child (pizza, child);
560 }
561 }
562
563 static void
564 gtk_pizza_style_set(GtkWidget *widget, GtkStyle *previous_style)
565 {
566 if (GTK_WIDGET_REALIZED(widget))
567 {
568 gtk_style_set_background(widget->style, widget->window, GTK_STATE_NORMAL);
569 gtk_style_set_background(widget->style, GTK_PIZZA(widget)->bin_window, GTK_STATE_NORMAL );
570 }
571
572 pizza_parent_class->style_set(widget, previous_style);
573 }
574
575 static void
576 gtk_pizza_add (GtkContainer *container,
577 GtkWidget *widget)
578 {
579 g_return_if_fail (container != NULL);
580 g_return_if_fail (GTK_IS_PIZZA (container));
581 g_return_if_fail (widget != NULL);
582
583 gtk_pizza_put (GTK_PIZZA (container), widget, 0, 0, 20, 20 );
584 }
585
586 static void
587 gtk_pizza_remove (GtkContainer *container,
588 GtkWidget *widget)
589 {
590 GtkPizza *pizza;
591 GtkPizzaChild *child;
592 GList *children;
593
594 g_return_if_fail (container != NULL);
595 g_return_if_fail (GTK_IS_PIZZA (container));
596 g_return_if_fail (widget != NULL);
597
598 pizza = GTK_PIZZA (container);
599
600 children = pizza->children;
601 while (children)
602 {
603 child = children->data;
604
605 if (child->widget == widget)
606 {
607 gtk_widget_unparent (widget);
608
609 /* security checks */
610 g_return_if_fail (GTK_IS_WIDGET (widget));
611
612 pizza->children = g_list_remove_link (pizza->children, children);
613 g_list_free (children);
614 g_free (child);
615
616 /* security checks */
617 g_return_if_fail (GTK_IS_WIDGET (widget));
618
619 break;
620 }
621
622 children = children->next;
623 }
624 }
625
626 static void
627 gtk_pizza_forall (GtkContainer *container,
628 gboolean include_internals,
629 GtkCallback callback,
630 gpointer callback_data)
631 {
632 GtkPizza *pizza;
633 GtkPizzaChild *child;
634 GList *children;
635
636 g_return_if_fail (container != NULL);
637 g_return_if_fail (GTK_IS_PIZZA (container));
638 g_return_if_fail (callback != (GtkCallback)NULL);
639
640 pizza = GTK_PIZZA (container);
641
642 children = pizza->children;
643 while (children)
644 {
645 child = children->data;
646 children = children->next;
647
648 (* callback) (child->widget, callback_data);
649 }
650 }
651
652 static void
653 gtk_pizza_allocate_child (GtkPizza *pizza,
654 GtkPizzaChild *child)
655 {
656 GtkAllocation allocation;
657 GtkRequisition requisition;
658
659 allocation.x = child->x - pizza->m_xoffset;
660 allocation.y = child->y - pizza->m_yoffset;
661 gtk_widget_get_child_requisition (child->widget, &requisition);
662 allocation.width = requisition.width;
663 allocation.height = requisition.height;
664
665 if (gtk_widget_get_direction( GTK_WIDGET(pizza) ) == GTK_TEXT_DIR_RTL)
666 {
667 /* reverse horizontal placement */
668 gint offset,border;
669
670 offset = GTK_WIDGET(pizza)->allocation.width;
671 border = pizza->container.border_width;
672 offset -= border*2;
673
674 allocation.x = offset - child->x - allocation.width + pizza->m_xoffset;
675 }
676
677 gtk_widget_size_allocate (child->widget, &allocation);
678 }
679
680 static void
681 gtk_pizza_adjust_allocations_recurse (GtkWidget *widget,
682 gpointer cb_data)
683 {
684 GtkPizzaAdjData *data = cb_data;
685
686 widget->allocation.x += data->dx;
687 widget->allocation.y += data->dy;
688
689 if (GTK_WIDGET_NO_WINDOW (widget) && GTK_IS_CONTAINER (widget))
690 {
691 gtk_container_forall (GTK_CONTAINER (widget),
692 gtk_pizza_adjust_allocations_recurse,
693 cb_data);
694 }
695 }
696
697 static void
698 gtk_pizza_adjust_allocations (GtkPizza *pizza,
699 gint dx,
700 gint dy)
701 {
702 GList *tmp_list;
703 GtkPizzaAdjData data;
704
705 data.dx = dx;
706 data.dy = dy;
707
708 tmp_list = pizza->children;
709 while (tmp_list)
710 {
711 GtkPizzaChild *child = tmp_list->data;
712 tmp_list = tmp_list->next;
713
714 child->widget->allocation.x += dx;
715 child->widget->allocation.y += dy;
716
717 if (GTK_WIDGET_NO_WINDOW (child->widget) &&
718 GTK_IS_CONTAINER (child->widget))
719 {
720 gtk_container_forall (GTK_CONTAINER (child->widget),
721 gtk_pizza_adjust_allocations_recurse,
722 &data);
723 }
724 }
725 }
726
727 void
728 gtk_pizza_scroll (GtkPizza *pizza, gint dx, gint dy)
729 {
730 pizza->m_xoffset += dx;
731 pizza->m_yoffset += dy;
732
733 gtk_pizza_adjust_allocations (pizza, -dx, -dy);
734
735 if (pizza->bin_window)
736 gdk_window_scroll( pizza->bin_window, -dx, -dy );
737 }
738
739 #ifdef __cplusplus
740 }
741 #endif /* __cplusplus */
wxWidgets (Impactor)