src/gtk1/win_gtk.c

   1 /* ///////////////////////////////////////////////////////////////////////////
   2 // Name:        win_gtk.c
   3 // Purpose:     native GTK+ widget for wxWindows
   4 // Author:      Robert Roebling
   5 // Id:          $Id$
   6 // Copyright:   (c) 1998 Robert Roebling
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////// */
   9
  10 #include "wx/gtk/win_gtk.h"
  11 #include "gtk/gtksignal.h"
  12
  13 #ifdef __cplusplus
  14 extern "C" {
  15 #endif /* __cplusplus */
  16
  17 static void gtk_myfixed_class_init    (GtkMyFixedClass    *klass);
  18 static void gtk_myfixed_init          (GtkMyFixed         *myfixed);
  19 static void gtk_myfixed_map           (GtkWidget        *widget);
  20 #if (GTK_MINOR_VERSION == 0)
  21 static void gtk_myfixed_unmap         (GtkWidget        *widget);
  22 #endif
  23 static void gtk_myfixed_realize       (GtkWidget        *widget);
  24 static void gtk_myfixed_size_request  (GtkWidget        *widget,
  25                                      GtkRequisition   *requisition);
  26 static void gtk_myfixed_size_allocate (GtkWidget        *widget,
  27                                      GtkAllocation    *allocation);
  28 static void gtk_myfixed_paint         (GtkWidget        *widget,
  29                                      GdkRectangle     *area);
  30 static void gtk_myfixed_draw          (GtkWidget        *widget,
  31                                      GdkRectangle     *area);
  32 static gint gtk_myfixed_expose        (GtkWidget        *widget,
  33                                      GdkEventExpose   *event);
  34 static void gtk_myfixed_add           (GtkContainer     *container,
  35                                      GtkWidget        *widget);
  36 static void gtk_myfixed_remove        (GtkContainer     *container,
  37                                      GtkWidget        *widget);
  38 static void gtk_myfixed_foreach       (GtkContainer     *container,
  39 #if (GTK_MINOR_VERSION > 0)
  40                                      gboolean         include_internals,
  41 #endif
  42                                      GtkCallback      callback,
  43                                      gpointer         callback_data);
  44 #if (GTK_MINOR_VERSION > 0)
  45 static GtkType gtk_myfixed_child_type (GtkContainer     *container);
  46 #endif
  47
  48 #if (GTK_MINOR_VERSION > 0)
  49 static void  gtk_myfixed_scroll_set_adjustments    (GtkMyFixed   *myfixed,
  50                                                GtkAdjustment *hadj,
  51                                                GtkAdjustment *vadj);
  52 #endif
  53
  54
  55
  56 static GtkContainerClass *parent_class = NULL;
  57
  58 guint
  59 gtk_myfixed_get_type ()
  60 {
  61   static guint myfixed_type = 0;
  62
  63   if (!myfixed_type)
  64     {
  65       GtkTypeInfo myfixed_info =
  66       {
  67         "GtkMyFixed",
  68         sizeof (GtkMyFixed),
  69         sizeof (GtkMyFixedClass),
  70         (GtkClassInitFunc) gtk_myfixed_class_init,
  71         (GtkObjectInitFunc) gtk_myfixed_init,
  72 #if (GTK_MINOR_VERSION > 0)
  73         /* reserved_1 */ NULL,
  74         /* reserved_2 */ NULL,
  75         (GtkClassInitFunc) NULL,
  76 #else
  77         (GtkArgSetFunc) NULL,
  78         (GtkArgGetFunc) NULL,
  79 #endif
  80       };
  81
  82       myfixed_type = gtk_type_unique (gtk_container_get_type (), &myfixed_info);
  83     }
  84
  85   return myfixed_type;
  86 }
  87
  88 static void
  89 gtk_myfixed_class_init (GtkMyFixedClass *klass)
  90 {
  91   GtkObjectClass *object_class;
  92   GtkWidgetClass *widget_class;
  93   GtkContainerClass *container_class;
  94
  95   object_class = (GtkObjectClass*) klass;
  96   widget_class = (GtkWidgetClass*) klass;
  97   container_class = (GtkContainerClass*) klass;
  98
  99 #if (GTK_MINOR_VERSION > 0)
 100   parent_class = gtk_type_class (GTK_TYPE_CONTAINER);
 101 #else
 102   parent_class = gtk_type_class (gtk_container_get_type ());
 103 #endif
 104
 105   widget_class->map = gtk_myfixed_map;
 106 #if (GTK_MINOR_VERSION == 0)
 107   widget_class->unmap = gtk_myfixed_unmap;
 108 #endif
 109   widget_class->realize = gtk_myfixed_realize;
 110   widget_class->size_request = gtk_myfixed_size_request;
 111   widget_class->size_allocate = gtk_myfixed_size_allocate;
 112   widget_class->draw = gtk_myfixed_draw;
 113   widget_class->expose_event = gtk_myfixed_expose;
 114
 115   container_class->add = gtk_myfixed_add;
 116   container_class->remove = gtk_myfixed_remove;
 117 #if (GTK_MINOR_VERSION > 0)
 118   container_class->forall = gtk_myfixed_foreach;
 119 #else
 120   container_class->foreach = gtk_myfixed_foreach;
 121 #endif
 122
 123 #if (GTK_MINOR_VERSION > 0)
 124   container_class->child_type = gtk_myfixed_child_type;
 125 #endif
 126
 127 #if (GTK_MINOR_VERSION > 0)
 128   klass->set_scroll_adjustments = gtk_myfixed_scroll_set_adjustments;
 129
 130   widget_class->set_scroll_adjustments_signal =
 131     gtk_signal_new ("set_scroll_adjustments",
 132                     GTK_RUN_LAST,
 133                     object_class->type,
 134                     GTK_SIGNAL_OFFSET (GtkMyFixedClass, set_scroll_adjustments),
 135                     gtk_marshal_NONE__POINTER_POINTER,
 136                     GTK_TYPE_NONE, 2, GTK_TYPE_ADJUSTMENT, GTK_TYPE_ADJUSTMENT);
 137 #endif
 138 }
 139
 140 #if (GTK_MINOR_VERSION > 0)
 141 static GtkType
 142 gtk_myfixed_child_type (GtkContainer     *container)
 143 {
 144   return GTK_TYPE_WIDGET;
 145 }
 146 #endif
 147
 148 static void
 149 gtk_myfixed_init (GtkMyFixed *myfixed)
 150 {
 151   GTK_WIDGET_UNSET_FLAGS (myfixed, GTK_NO_WINDOW);
 152
 153 #if (GTK_MINOR_VERSION == 0)
 154   GTK_WIDGET_SET_FLAGS (myfixed, GTK_BASIC);
 155 #endif
 156
 157 #if (GTK_MINOR_VERSION > 0)
 158   myfixed->shadow_type = GTK_SHADOW_NONE;
 159 #endif
 160
 161   myfixed->children = NULL;
 162 }
 163
 164 GtkWidget*
 165 gtk_myfixed_new ()
 166 {
 167   GtkMyFixed *myfixed;
 168
 169   myfixed = gtk_type_new (gtk_myfixed_get_type ());
 170
 171   return GTK_WIDGET (myfixed);
 172 }
 173
 174 #if (GTK_MINOR_VERSION > 0)
 175 void  gtk_myfixed_scroll_set_adjustments (GtkMyFixed     *myfixed,
 176                                                GtkAdjustment *hadj,
 177                                                GtkAdjustment *vadj)
 178 {
 179    /* OK, this is embarassing, but this function has to be here */
 180 }
 181
 182 void
 183 gtk_myfixed_set_shadow_type (GtkMyFixed   *myfixed,
 184                               GtkShadowType  type)
 185 {
 186   g_return_if_fail (myfixed != NULL);
 187   g_return_if_fail (GTK_IS_MYFIXED (myfixed));
 188
 189   if ((GtkShadowType) myfixed->shadow_type != type)
 190     {
 191       myfixed->shadow_type = type;
 192
 193       if (GTK_WIDGET_VISIBLE (myfixed))
 194         {
 195           gtk_widget_size_allocate (GTK_WIDGET (myfixed), &(GTK_WIDGET (myfixed)->allocation));
 196           gtk_widget_queue_draw (GTK_WIDGET (myfixed));
 197         }
 198     }
 199 }
 200 #endif
 201
 202 void
 203 gtk_myfixed_put (GtkMyFixed   *myfixed,
 204                GtkWidget      *widget,
 205                gint16         x,
 206                gint16         y)
 207 {
 208   GtkMyFixedChild *child_info;
 209
 210   g_return_if_fail (myfixed != NULL);
 211   g_return_if_fail (GTK_IS_MYFIXED (myfixed));
 212   g_return_if_fail (widget != NULL);
 213
 214   child_info = g_new (GtkMyFixedChild, 1);
 215   child_info->widget = widget;
 216   child_info->x = x;
 217   child_info->y = y;
 218
 219   gtk_widget_set_parent (widget, GTK_WIDGET (myfixed));
 220
 221   myfixed->children = g_list_append (myfixed->children, child_info);
 222
 223   if (GTK_WIDGET_REALIZED (myfixed) && !GTK_WIDGET_REALIZED (widget))
 224     gtk_widget_realize (widget);
 225
 226   if (GTK_WIDGET_MAPPED (myfixed) && !GTK_WIDGET_MAPPED (widget))
 227     gtk_widget_map (widget);
 228
 229   if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (myfixed))
 230     gtk_widget_queue_resize (GTK_WIDGET (myfixed));
 231 }
 232
 233 void
 234 gtk_myfixed_move (GtkMyFixed       *myfixed,
 235                 GtkWidget      *widget,
 236                 gint16         x,
 237                 gint16         y)
 238 {
 239   GtkMyFixedChild *child;
 240   GList *children;
 241
 242   g_return_if_fail (myfixed != NULL);
 243   g_return_if_fail (GTK_IS_MYFIXED (myfixed));
 244   g_return_if_fail (widget != NULL);
 245
 246   children = myfixed->children;
 247   while (children)
 248     {
 249       child = children->data;
 250       children = children->next;
 251
 252       if (child->widget == widget)
 253         {
 254           if ((child->x == x) && (child->y == y)) return;
 255
 256           child->x = x;
 257           child->y = y;
 258
 259           if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (myfixed))
 260             gtk_widget_queue_resize (GTK_WIDGET (myfixed));
 261
 262           break;
 263         }
 264     }
 265 }
 266
 267 static void
 268 gtk_myfixed_map (GtkWidget *widget)
 269 {
 270   GtkMyFixed *myfixed;
 271   GtkMyFixedChild *child;
 272   GList *children;
 273
 274   g_return_if_fail (widget != NULL);
 275   g_return_if_fail (GTK_IS_MYFIXED (widget));
 276
 277   GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
 278   myfixed = GTK_MYFIXED (widget);
 279
 280   gdk_window_show (widget->window);
 281
 282   children = myfixed->children;
 283   while (children)
 284     {
 285       child = children->data;
 286       children = children->next;
 287
 288       if (GTK_WIDGET_VISIBLE (child->widget) &&
 289           !GTK_WIDGET_MAPPED (child->widget))
 290         gtk_widget_map (child->widget);
 291     }
 292 }
 293
 294 #if (GTK_MINOR_VERSION == 0)
 295 static void
 296 gtk_myfixed_unmap (GtkWidget *widget)
 297 {
 298   g_return_if_fail (widget != NULL);
 299   g_return_if_fail (GTK_IS_MYFIXED (widget));
 300
 301   GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
 302 }
 303 #endif
 304
 305 static void
 306 gtk_myfixed_realize (GtkWidget *widget)
 307 {
 308   GtkMyFixed *myfixed;
 309   GdkWindowAttr attributes;
 310   gint attributes_mask;
 311
 312   g_return_if_fail (widget != NULL);
 313   g_return_if_fail (GTK_IS_MYFIXED (widget));
 314
 315   myfixed = GTK_MYFIXED (widget);
 316
 317   GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
 318
 319   attributes.window_type = GDK_WINDOW_CHILD;
 320
 321 #if (GTK_MINOR_VERSION > 0)
 322   if (myfixed->shadow_type != GTK_SHADOW_NONE)
 323     {
 324       attributes.x = 2;
 325       attributes.y = 2;
 326     }
 327   else
 328     {
 329       attributes.x = 0;
 330       attributes.y = 0;
 331     }
 332   attributes.width = MAX (1, (gint)widget->allocation.width - attributes.x * 2 );
 333   attributes.height = MAX (1, (gint)widget->allocation.height - attributes.y * 2 );
 334 #else
 335   attributes.x = widget->allocation.x;
 336   attributes.y = widget->allocation.y;
 337   attributes.width = 32000;
 338   attributes.height = 32000;
 339 #endif
 340   attributes.wclass = GDK_INPUT_OUTPUT;
 341   attributes.visual = gtk_widget_get_visual (widget);
 342   attributes.colormap = gtk_widget_get_colormap (widget);
 343   attributes.event_mask = gtk_widget_get_events (widget);
 344   attributes.event_mask |=
 345   GDK_EXPOSURE_MASK     |
 346   GDK_POINTER_MOTION_MASK       |
 347   GDK_POINTER_MOTION_HINT_MASK  |
 348   GDK_BUTTON_MOTION_MASK        |
 349   GDK_BUTTON1_MOTION_MASK       |
 350   GDK_BUTTON2_MOTION_MASK       |
 351   GDK_BUTTON3_MOTION_MASK       |
 352   GDK_BUTTON_PRESS_MASK         |
 353   GDK_BUTTON_RELEASE_MASK       |
 354   GDK_KEY_PRESS_MASK            |
 355   GDK_KEY_RELEASE_MASK          |
 356   GDK_ENTER_NOTIFY_MASK         |
 357   GDK_LEAVE_NOTIFY_MASK         |
 358   GDK_FOCUS_CHANGE_MASK;
 359
 360   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
 361
 362   widget->window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes,
 363                                    attributes_mask);
 364   gdk_window_set_user_data (widget->window, widget);
 365
 366   widget->style = gtk_style_attach (widget->style, widget->window);
 367   gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
 368 }
 369
 370 static void
 371 gtk_myfixed_size_request (GtkWidget      *widget,
 372                         GtkRequisition *requisition)
 373 {
 374   GtkMyFixed *myfixed;
 375   GtkMyFixedChild *child;
 376   GList *children;
 377
 378   g_return_if_fail (widget != NULL);
 379   g_return_if_fail (GTK_IS_MYFIXED (widget));
 380   g_return_if_fail (requisition != NULL);
 381
 382   myfixed = GTK_MYFIXED (widget);
 383
 384   requisition->width = 0;
 385   requisition->height = 0;
 386
 387   children = myfixed->children;
 388   while (children)
 389     {
 390       child = children->data;
 391       children = children->next;
 392
 393       if (GTK_WIDGET_VISIBLE (child->widget))
 394         {
 395           gtk_widget_size_request (child->widget, &child->widget->requisition);
 396         }
 397     }
 398 }
 399
 400 static void
 401 gtk_myfixed_size_allocate (GtkWidget     *widget,
 402                          GtkAllocation *allocation)
 403 {
 404   GtkMyFixed *myfixed;
 405   gint border;
 406   GtkMyFixedChild *child;
 407   GtkAllocation child_allocation;
 408   GList *children;
 409
 410   g_return_if_fail (widget != NULL);
 411   g_return_if_fail (GTK_IS_MYFIXED(widget));
 412   g_return_if_fail (allocation != NULL);
 413
 414   myfixed = GTK_MYFIXED (widget);
 415
 416   if (myfixed->shadow_type == GTK_SHADOW_NONE)
 417     border = 0;
 418   else
 419     border = 2;
 420
 421   widget->allocation = *allocation;
 422   if (GTK_WIDGET_REALIZED (widget))
 423   {
 424     gdk_window_move_resize( widget->window,
 425                             allocation->x+border, allocation->y+border,
 426 #if (GTK_MINOR_VERSION > 0)
 427                             allocation->width-border*2, allocation->height-border*2 );
 428 #else
 429                             32000, 32000 );
 430 #endif
 431   }
 432
 433   children = myfixed->children;
 434   while (children)
 435     {
 436       child = children->data;
 437       children = children->next;
 438
 439       if (GTK_WIDGET_VISIBLE (child->widget))
 440         {
 441           child_allocation.x = child->x;
 442           child_allocation.y = child->y;
 443           child_allocation.width = child->widget->requisition.width;
 444           child_allocation.height = child->widget->requisition.height;
 445           gtk_widget_size_allocate (child->widget, &child_allocation);
 446         }
 447     }
 448 }
 449
 450 static void
 451 gtk_myfixed_paint (GtkWidget    *widget,
 452                  GdkRectangle *area)
 453 {
 454   g_return_if_fail (widget != NULL);
 455   g_return_if_fail (GTK_IS_MYFIXED (widget));
 456   g_return_if_fail (area != NULL);
 457
 458   if (GTK_WIDGET_DRAWABLE (widget))
 459       gdk_window_clear_area (widget->window,
 460                              area->x, area->y,
 461                              area->width, area->height);
 462 }
 463
 464 static void
 465 gtk_myfixed_draw (GtkWidget    *widget,
 466                 GdkRectangle *area)
 467 {
 468   GtkMyFixed *myfixed;
 469   GtkMyFixedChild *child;
 470   GdkRectangle child_area;
 471   GList *children;
 472
 473   g_return_if_fail (widget != NULL);
 474   g_return_if_fail (GTK_IS_MYFIXED (widget));
 475
 476   if (GTK_WIDGET_DRAWABLE (widget))
 477     {
 478       myfixed = GTK_MYFIXED (widget);
 479       gtk_myfixed_paint (widget, area);
 480
 481       children = myfixed->children;
 482       while (children)
 483         {
 484           child = children->data;
 485           children = children->next;
 486
 487           if (gtk_widget_intersect (child->widget, area, &child_area))
 488             gtk_widget_draw (child->widget, &child_area);
 489         }
 490     }
 491 }
 492
 493 static gint
 494 gtk_myfixed_expose (GtkWidget      *widget,
 495                   GdkEventExpose *event)
 496 {
 497   GtkMyFixed *myfixed;
 498   GtkMyFixedChild *child;
 499   GdkEventExpose child_event;
 500   GList *children;
 501
 502   g_return_val_if_fail (widget != NULL, FALSE);
 503   g_return_val_if_fail (GTK_IS_MYFIXED (widget), FALSE);
 504   g_return_val_if_fail (event != NULL, FALSE);
 505
 506   if (GTK_WIDGET_DRAWABLE (widget))
 507     {
 508       myfixed = GTK_MYFIXED (widget);
 509
 510       child_event = *event;
 511
 512       children = myfixed->children;
 513       while (children)
 514         {
 515           child = children->data;
 516           children = children->next;
 517
 518           if (GTK_WIDGET_NO_WINDOW (child->widget) &&
 519               gtk_widget_intersect (child->widget, &event->area,
 520                                     &child_event.area))
 521             gtk_widget_event (child->widget, (GdkEvent*) &child_event);
 522         }
 523     }
 524
 525   return FALSE;
 526 }
 527
 528 static void
 529 gtk_myfixed_add (GtkContainer *container,
 530                GtkWidget    *widget)
 531 {
 532   g_return_if_fail (container != NULL);
 533   g_return_if_fail (GTK_IS_MYFIXED (container));
 534   g_return_if_fail (widget != NULL);
 535
 536   gtk_myfixed_put (GTK_MYFIXED (container), widget, 0, 0);
 537 }
 538
 539 static void
 540 gtk_myfixed_remove (GtkContainer *container,
 541                   GtkWidget    *widget)
 542 {
 543   GtkMyFixed *myfixed;
 544   GtkMyFixedChild *child;
 545   GList *children;
 546
 547   g_return_if_fail (container != NULL);
 548   g_return_if_fail (GTK_IS_MYFIXED (container));
 549   g_return_if_fail (widget != NULL);
 550
 551   myfixed = GTK_MYFIXED (container);
 552
 553   children = myfixed->children;
 554   while (children)
 555     {
 556       child = children->data;
 557
 558       if (child->widget == widget)
 559         {
 560           gtk_widget_unparent (widget);
 561
 562           myfixed->children = g_list_remove_link (myfixed->children, children);
 563           g_list_free (children);
 564           g_free (child);
 565
 566           if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (container))
 567             gtk_widget_queue_resize (GTK_WIDGET (container));
 568
 569           break;
 570         }
 571
 572       children = children->next;
 573     }
 574 }
 575
 576 static void
 577 gtk_myfixed_foreach (GtkContainer *container,
 578 #if (GTK_MINOR_VERSION > 0)
 579                    gboolean      include_internals,
 580 #endif
 581                    GtkCallback   callback,
 582                    gpointer      callback_data)
 583 {
 584   GtkMyFixed *myfixed;
 585   GtkMyFixedChild *child;
 586   GList *children;
 587
 588   g_return_if_fail (container != NULL);
 589   g_return_if_fail (GTK_IS_MYFIXED (container));
 590   g_return_if_fail (callback != NULL);
 591
 592   myfixed = GTK_MYFIXED (container);
 593
 594   children = myfixed->children;
 595   while (children)
 596     {
 597       child = children->data;
 598       children = children->next;
 599
 600       (* callback) (child->widget, callback_data);
 601     }
 602 }
 603
 604
 605 #ifdef __cplusplus
 606 }
 607 #endif /* __cplusplus */
 608