Pileus Git - ~andy/gtk/blob - demos/gtk-demo/offscreen_window.c

   1 /* Offscreen windows/Rotated button
   2  *
   3  * Offscreen windows can be used to transform parts of a widget
   4  * hierarchy. Note that the rotated button is fully functional.
   5  */
   6 #include <math.h>
   7 #include <gtk/gtk.h>
   8
   9 #define GTK_TYPE_ROTATED_BIN              (gtk_rotated_bin_get_type ())
  10 #define GTK_ROTATED_BIN(obj)              (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_ROTATED_BIN, GtkRotatedBin))
  11 #define GTK_ROTATED_BIN_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_ROTATED_BIN, GtkRotatedBinClass))
  12 #define GTK_IS_ROTATED_BIN(obj)           (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_ROTATED_BIN))
  13 #define GTK_IS_ROTATED_BIN_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ROTATED_BIN))
  14 #define GTK_ROTATED_BIN_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_ROTATED_BIN, GtkRotatedBinClass))
  15
  16 typedef struct _GtkRotatedBin   GtkRotatedBin;
  17 typedef struct _GtkRotatedBinClass  GtkRotatedBinClass;
  18
  19 struct _GtkRotatedBin
  20 {
  21   GtkContainer container;
  22
  23   GtkWidget *child;
  24   GdkWindow *offscreen_window;
  25   gdouble angle;
  26 };
  27
  28 struct _GtkRotatedBinClass
  29 {
  30   GtkContainerClass parent_class;
  31 };
  32
  33 GType      gtk_rotated_bin_get_type  (void) G_GNUC_CONST;
  34 GtkWidget* gtk_rotated_bin_new       (void);
  35 void       gtk_rotated_bin_set_angle (GtkRotatedBin *bin,
  36                                       gdouble        angle);
  37
  38 /*** implementation ***/
  39
  40 static void     gtk_rotated_bin_realize       (GtkWidget       *widget);
  41 static void     gtk_rotated_bin_unrealize     (GtkWidget       *widget);
  42 static void     gtk_rotated_bin_size_request  (GtkWidget       *widget,
  43                                                GtkRequisition  *requisition);
  44 static void     gtk_rotated_bin_size_allocate (GtkWidget       *widget,
  45                                                GtkAllocation   *allocation);
  46 static gboolean gtk_rotated_bin_damage        (GtkWidget       *widget,
  47                                                GdkEventExpose  *event);
  48 static gboolean gtk_rotated_bin_expose        (GtkWidget       *widget,
  49                                                GdkEventExpose  *offscreen);
  50
  51 static void     gtk_rotated_bin_add           (GtkContainer    *container,
  52                                                GtkWidget       *child);
  53 static void     gtk_rotated_bin_remove        (GtkContainer    *container,
  54                                                GtkWidget       *widget);
  55 static void     gtk_rotated_bin_forall        (GtkContainer    *container,
  56                                                gboolean         include_internals,
  57                                                GtkCallback      callback,
  58                                                gpointer         callback_data);
  59 static GType    gtk_rotated_bin_child_type    (GtkContainer    *container);
  60
  61 G_DEFINE_TYPE (GtkRotatedBin, gtk_rotated_bin, GTK_TYPE_CONTAINER);
  62
  63 static void
  64 to_child (GtkRotatedBin *bin,
  65           double         widget_x,
  66           double         widget_y,
  67           double        *x_out,
  68           double        *y_out)
  69 {
  70   GtkAllocation child_area;
  71   double x, y, xr, yr;
  72   double c, s;
  73   double w, h;
  74
  75   s = sin (bin->angle);
  76   c = cos (bin->angle);
  77   child_area = bin->child->allocation;
  78
  79   w = c * child_area.width + s * child_area.height;
  80   h = s * child_area.width + c * child_area.height;
  81
  82   x = widget_x;
  83   y = widget_y;
  84
  85   x -= (w - child_area.width) / 2;
  86   y -= (h - child_area.height) / 2;
  87
  88   x -= child_area.width / 2;
  89   y -= child_area.height / 2;
  90
  91   xr = x * c + y * s;
  92   yr = y * c - x * s;
  93   x = xr;
  94   y = yr;
  95
  96   x += child_area.width / 2;
  97   y += child_area.height / 2;
  98
  99   *x_out = x;
 100   *y_out = y;
 101 }
 102
 103 static void
 104 to_parent (GtkRotatedBin *bin,
 105            double         offscreen_x,
 106            double         offscreen_y,
 107            double        *x_out,
 108            double        *y_out)
 109 {
 110   GtkAllocation child_area;
 111   double x, y, xr, yr;
 112   double c, s;
 113   double w, h;
 114
 115   s = sin (bin->angle);
 116   c = cos (bin->angle);
 117   child_area = bin->child->allocation;
 118
 119   w = c * child_area.width + s * child_area.height;
 120   h = s * child_area.width + c * child_area.height;
 121
 122   x = offscreen_x;
 123   y = offscreen_y;
 124
 125   x -= child_area.width / 2;
 126   y -= child_area.height / 2;
 127
 128   xr = x * c - y * s;
 129   yr = x * s + y * c;
 130   x = xr;
 131   y = yr;
 132
 133   x += child_area.width / 2;
 134   y += child_area.height / 2;
 135
 136   x -= (w - child_area.width) / 2;
 137   y -= (h - child_area.height) / 2;
 138
 139   *x_out = x;
 140   *y_out = y;
 141 }
 142
 143 static void
 144 gtk_rotated_bin_class_init (GtkRotatedBinClass *klass)
 145 {
 146   GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
 147   GtkContainerClass *container_class = GTK_CONTAINER_CLASS (klass);
 148
 149   widget_class->realize = gtk_rotated_bin_realize;
 150   widget_class->unrealize = gtk_rotated_bin_unrealize;
 151   widget_class->size_request = gtk_rotated_bin_size_request;
 152   widget_class->size_allocate = gtk_rotated_bin_size_allocate;
 153   widget_class->expose_event = gtk_rotated_bin_expose;
 154
 155   g_signal_override_class_closure (g_signal_lookup ("damage-event", GTK_TYPE_WIDGET),
 156                                    GTK_TYPE_ROTATED_BIN,
 157                                    g_cclosure_new (G_CALLBACK (gtk_rotated_bin_damage),
 158                                                    NULL, NULL));
 159
 160   container_class->add = gtk_rotated_bin_add;
 161   container_class->remove = gtk_rotated_bin_remove;
 162   container_class->forall = gtk_rotated_bin_forall;
 163   container_class->child_type = gtk_rotated_bin_child_type;
 164 }
 165
 166 static void
 167 gtk_rotated_bin_init (GtkRotatedBin *bin)
 168 {
 169   GTK_WIDGET_UNSET_FLAGS (bin, GTK_NO_WINDOW);
 170 }
 171
 172 GtkWidget *
 173 gtk_rotated_bin_new (void)
 174 {
 175   return g_object_new (GTK_TYPE_ROTATED_BIN, NULL);
 176 }
 177
 178 static GdkWindow *
 179 pick_offscreen_child (GdkWindow     *offscreen_window,
 180                       double         widget_x,
 181                       double         widget_y,
 182                       GtkRotatedBin *bin)
 183 {
 184  GtkAllocation child_area;
 185  double x, y;
 186
 187  if (bin->child && gtk_widget_get_visible (bin->child))
 188     {
 189       to_child (bin, widget_x, widget_y, &x, &y);
 190
 191       child_area = bin->child->allocation;
 192
 193       if (x >= 0 && x < child_area.width &&
 194           y >= 0 && y < child_area.height)
 195         return bin->offscreen_window;
 196     }
 197
 198   return NULL;
 199 }
 200
 201 static void
 202 offscreen_window_to_parent (GdkWindow     *offscreen_window,
 203                             double         offscreen_x,
 204                             double         offscreen_y,
 205                             double        *parent_x,
 206                             double        *parent_y,
 207                             GtkRotatedBin *bin)
 208 {
 209   to_parent (bin, offscreen_x, offscreen_y, parent_x, parent_y);
 210 }
 211
 212 static void
 213 offscreen_window_from_parent (GdkWindow     *window,
 214                               double         parent_x,
 215                               double         parent_y,
 216                               double        *offscreen_x,
 217                               double        *offscreen_y,
 218                               GtkRotatedBin *bin)
 219 {
 220   to_child (bin, parent_x, parent_y, offscreen_x, offscreen_y);
 221 }
 222
 223 static void
 224 gtk_rotated_bin_realize (GtkWidget *widget)
 225 {
 226   GtkRotatedBin *bin = GTK_ROTATED_BIN (widget);
 227   GdkWindowAttr attributes;
 228   gint attributes_mask;
 229   gint border_width;
 230   GtkRequisition child_requisition;
 231
 232   GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
 233
 234   border_width = GTK_CONTAINER (widget)->border_width;
 235
 236   attributes.x = widget->allocation.x + border_width;
 237   attributes.y = widget->allocation.y + border_width;
 238   attributes.width = widget->allocation.width - 2 * border_width;
 239   attributes.height = widget->allocation.height - 2 * border_width;
 240   attributes.window_type = GDK_WINDOW_CHILD;
 241   attributes.event_mask = gtk_widget_get_events (widget)
 242                         | GDK_EXPOSURE_MASK
 243                         | GDK_POINTER_MOTION_MASK
 244                         | GDK_BUTTON_PRESS_MASK
 245                         | GDK_BUTTON_RELEASE_MASK
 246                         | GDK_SCROLL_MASK
 247                         | GDK_ENTER_NOTIFY_MASK
 248                         | GDK_LEAVE_NOTIFY_MASK;
 249
 250   attributes.visual = gtk_widget_get_visual (widget);
 251   attributes.colormap = gtk_widget_get_colormap (widget);
 252   attributes.wclass = GDK_INPUT_OUTPUT;
 253
 254   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
 255
 256   widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
 257                                    &attributes, attributes_mask);
 258   gdk_window_set_user_data (widget->window, widget);
 259   g_signal_connect (widget->window, "pick-embedded-child",
 260                     G_CALLBACK (pick_offscreen_child), bin);
 261
 262   attributes.window_type = GDK_WINDOW_OFFSCREEN;
 263
 264   child_requisition.width = child_requisition.height = 0;
 265   if (bin->child && gtk_widget_get_visible (bin->child))
 266     {
 267       attributes.width = bin->child->allocation.width;
 268       attributes.height = bin->child->allocation.height;
 269     }
 270   bin->offscreen_window = gdk_window_new (gtk_widget_get_root_window (widget),
 271                                           &attributes, attributes_mask);
 272   gdk_window_set_user_data (bin->offscreen_window, widget);
 273   if (bin->child)
 274     gtk_widget_set_parent_window (bin->child, bin->offscreen_window);
 275   gdk_offscreen_window_set_embedder (bin->offscreen_window, widget->window);
 276   g_signal_connect (bin->offscreen_window, "to-embedder",
 277                     G_CALLBACK (offscreen_window_to_parent), bin);
 278   g_signal_connect (bin->offscreen_window, "from-embedder",
 279                     G_CALLBACK (offscreen_window_from_parent), bin);
 280
 281   widget->style = gtk_style_attach (widget->style, widget->window);
 282
 283   gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
 284   gtk_style_set_background (widget->style, bin->offscreen_window, GTK_STATE_NORMAL);
 285   gdk_window_show (bin->offscreen_window);
 286 }
 287
 288 static void
 289 gtk_rotated_bin_unrealize (GtkWidget *widget)
 290 {
 291   GtkRotatedBin *bin = GTK_ROTATED_BIN (widget);
 292
 293   gdk_window_set_user_data (bin->offscreen_window, NULL);
 294   gdk_window_destroy (bin->offscreen_window);
 295   bin->offscreen_window = NULL;
 296
 297   GTK_WIDGET_CLASS (gtk_rotated_bin_parent_class)->unrealize (widget);
 298 }
 299
 300 static GType
 301 gtk_rotated_bin_child_type (GtkContainer *container)
 302 {
 303   GtkRotatedBin *bin = GTK_ROTATED_BIN (container);
 304
 305   if (bin->child)
 306     return G_TYPE_NONE;
 307
 308   return GTK_TYPE_WIDGET;
 309 }
 310
 311 static void
 312 gtk_rotated_bin_add (GtkContainer *container,
 313                      GtkWidget    *widget)
 314 {
 315   GtkRotatedBin *bin = GTK_ROTATED_BIN (container);
 316
 317   if (!bin->child)
 318     {
 319       gtk_widget_set_parent_window (widget, bin->offscreen_window);
 320       gtk_widget_set_parent (widget, GTK_WIDGET (bin));
 321       bin->child = widget;
 322     }
 323   else
 324     g_warning ("GtkRotatedBin cannot have more than one child\n");
 325 }
 326
 327 static void
 328 gtk_rotated_bin_remove (GtkContainer *container,
 329                         GtkWidget    *widget)
 330 {
 331   GtkRotatedBin *bin = GTK_ROTATED_BIN (container);
 332   gboolean was_visible;
 333
 334   was_visible = gtk_widget_get_visible (widget);
 335
 336   if (bin->child == widget)
 337     {
 338       gtk_widget_unparent (widget);
 339
 340       bin->child = NULL;
 341
 342       if (was_visible && gtk_widget_get_visible (GTK_WIDGET (container)))
 343         gtk_widget_queue_resize (GTK_WIDGET (container));
 344     }
 345 }
 346
 347 static void
 348 gtk_rotated_bin_forall (GtkContainer *container,
 349                         gboolean      include_internals,
 350                         GtkCallback   callback,
 351                         gpointer      callback_data)
 352 {
 353   GtkRotatedBin *bin = GTK_ROTATED_BIN (container);
 354
 355   g_return_if_fail (callback != NULL);
 356
 357   if (bin->child)
 358     (*callback) (bin->child, callback_data);
 359 }
 360
 361 void
 362 gtk_rotated_bin_set_angle (GtkRotatedBin *bin,
 363                            gdouble        angle)
 364 {
 365   g_return_if_fail (GTK_IS_ROTATED_BIN (bin));
 366
 367   bin->angle = angle;
 368   gtk_widget_queue_resize (GTK_WIDGET (bin));
 369
 370   gdk_window_geometry_changed (bin->offscreen_window);
 371 }
 372
 373 static void
 374 gtk_rotated_bin_size_request (GtkWidget      *widget,
 375                               GtkRequisition *requisition)
 376 {
 377   GtkRotatedBin *bin = GTK_ROTATED_BIN (widget);
 378   GtkRequisition child_requisition;
 379   double s, c;
 380   double w, h;
 381
 382   child_requisition.width = 0;
 383   child_requisition.height = 0;
 384
 385   if (bin->child && gtk_widget_get_visible (bin->child))
 386     gtk_widget_size_request (bin->child, &child_requisition);
 387
 388   s = sin (bin->angle);
 389   c = cos (bin->angle);
 390   w = c * child_requisition.width + s * child_requisition.height;
 391   h = s * child_requisition.width + c * child_requisition.height;
 392
 393   requisition->width = GTK_CONTAINER (widget)->border_width * 2 + w;
 394   requisition->height = GTK_CONTAINER (widget)->border_width * 2 + h;
 395 }
 396
 397 static void
 398 gtk_rotated_bin_size_allocate (GtkWidget     *widget,
 399                                GtkAllocation *allocation)
 400 {
 401   GtkRotatedBin *bin = GTK_ROTATED_BIN (widget);
 402   gint border_width;
 403   gint w, h;
 404   gdouble s, c;
 405
 406   widget->allocation = *allocation;
 407
 408   border_width = GTK_CONTAINER (widget)->border_width;
 409
 410   w = allocation->width - border_width * 2;
 411   h = allocation->height - border_width * 2;
 412
 413   if (GTK_WIDGET_REALIZED (widget))
 414     gdk_window_move_resize (widget->window,
 415                             allocation->x + border_width,
 416                             allocation->y + border_width,
 417                             w, h);
 418
 419   if (bin->child && gtk_widget_get_visible (bin->child))
 420     {
 421       GtkRequisition child_requisition;
 422       GtkAllocation child_allocation;
 423
 424       s = sin (bin->angle);
 425       c = cos (bin->angle);
 426
 427       gtk_widget_get_child_requisition (bin->child, &child_requisition);
 428       child_allocation.x = 0;
 429       child_allocation.y = 0;
 430       child_allocation.height = child_requisition.height;
 431       if (c == 0.0)
 432         child_allocation.width = h / s;
 433       else if (s == 0.0)
 434         child_allocation.width = w / c;
 435       else
 436         child_allocation.width = MIN ((w - s * child_allocation.height) / c,
 437                                       (h - c * child_allocation.height) / s);
 438
 439       if (GTK_WIDGET_REALIZED (widget))
 440         gdk_window_move_resize (bin->offscreen_window,
 441                                 child_allocation.x,
 442                                 child_allocation.y,
 443                                 child_allocation.width,
 444                                 child_allocation.height);
 445
 446       child_allocation.x = child_allocation.y = 0;
 447       gtk_widget_size_allocate (bin->child, &child_allocation);
 448     }
 449 }
 450
 451 static gboolean
 452 gtk_rotated_bin_damage (GtkWidget      *widget,
 453                         GdkEventExpose *event)
 454 {
 455   gdk_window_invalidate_rect (widget->window, NULL, FALSE);
 456
 457   return TRUE;
 458 }
 459
 460 static gboolean
 461 gtk_rotated_bin_expose (GtkWidget      *widget,
 462                         GdkEventExpose *event)
 463 {
 464   GtkRotatedBin *bin = GTK_ROTATED_BIN (widget);
 465   gint width, height;
 466   gdouble s, c;
 467   gdouble w, h;
 468
 469   if (gtk_widget_is_drawable (widget))
 470     {
 471       if (event->window == widget->window)
 472         {
 473           GdkPixmap *pixmap;
 474           GtkAllocation child_area;
 475           cairo_t *cr;
 476
 477           if (bin->child && gtk_widget_get_visible (bin->child))
 478             {
 479               pixmap = gdk_offscreen_window_get_pixmap (bin->offscreen_window);
 480               child_area = bin->child->allocation;
 481
 482               cr = gdk_cairo_create (widget->window);
 483
 484               /* transform */
 485               s = sin (bin->angle);
 486               c = cos (bin->angle);
 487               w = c * child_area.width + s * child_area.height;
 488               h = s * child_area.width + c * child_area.height;
 489
 490               cairo_translate (cr, (w - child_area.width) / 2, (h - child_area.height) / 2);
 491               cairo_translate (cr, child_area.width / 2, child_area.height / 2);
 492               cairo_rotate (cr, bin->angle);
 493               cairo_translate (cr, -child_area.width / 2, -child_area.height / 2);
 494
 495               /* clip */
 496               gdk_drawable_get_size (pixmap, &width, &height);
 497               cairo_rectangle (cr, 0, 0, width, height);
 498               cairo_clip (cr);
 499               /* paint */
 500               gdk_cairo_set_source_pixmap (cr, pixmap, 0, 0);
 501               cairo_paint (cr);
 502
 503               cairo_destroy (cr);
 504             }
 505         }
 506       else if (event->window == bin->offscreen_window)
 507         {
 508           gtk_paint_flat_box (widget->style, event->window,
 509                               GTK_STATE_NORMAL, GTK_SHADOW_NONE,
 510                               &event->area, widget, "blah",
 511                               0, 0, -1, -1);
 512
 513           if (bin->child)
 514             gtk_container_propagate_expose (GTK_CONTAINER (widget),
 515                                             bin->child,
 516                                             event);
 517         }
 518     }
 519
 520   return FALSE;
 521 }
 522
 523 /*** ***/
 524
 525 static void
 526 scale_changed (GtkRange      *range,
 527                GtkRotatedBin *bin)
 528 {
 529   gtk_rotated_bin_set_angle (bin, gtk_range_get_value (range));
 530 }
 531
 532 static GtkWidget *window = NULL;
 533
 534 GtkWidget *
 535 do_offscreen_window (GtkWidget *do_widget)
 536 {
 537   if (!window)
 538     {
 539       GtkWidget *bin, *vbox, *scale, *button;
 540       GdkColor black;
 541
 542       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 543       gtk_window_set_screen (GTK_WINDOW (window),
 544                              gtk_widget_get_screen (do_widget));
 545       gtk_window_set_title (GTK_WINDOW (window), "Rotated widget");
 546
 547       g_signal_connect (window, "destroy",
 548                         G_CALLBACK (gtk_widget_destroyed), &window);
 549
 550       gdk_color_parse ("black", &black);
 551       gtk_widget_modify_bg (window, GTK_STATE_NORMAL, &black);
 552       gtk_container_set_border_width (GTK_CONTAINER (window), 10);
 553
 554       vbox = gtk_vbox_new (0, FALSE);
 555       scale = gtk_hscale_new_with_range (0, G_PI/2, 0.01);
 556       gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
 557
 558       button = gtk_button_new_with_label ("A Button");
 559       bin = gtk_rotated_bin_new ();
 560
 561       g_signal_connect (scale, "value-changed", G_CALLBACK (scale_changed), bin);
 562
 563       gtk_container_add (GTK_CONTAINER (window), vbox);
 564       gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
 565       gtk_box_pack_start (GTK_BOX (vbox), bin, TRUE, TRUE, 0);
 566       gtk_container_add (GTK_CONTAINER (bin), button);
 567     }
 568
 569   if (!gtk_widget_get_visible (window))
 570     gtk_widget_show_all (window);
 571   else
 572     {
 573       gtk_widget_destroy (window);
 574       window = NULL;
 575     }
 576
 577   return window;
 578 }
 579