src/frame.c

   1 /*      $Id$
   2
   3         This program is free software; you can redistribute it and/or modify
   4         it under the terms of the GNU General Public License as published by
   5         the Free Software Foundation; either version 2, or (at your option)
   6         any later version.
   7
   8         This program is distributed in the hope that it will be useful,
   9         but WITHOUT ANY WARRANTY; without even the implied warranty of
  10         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11         GNU General Public License for more details.
  12
  13         You should have received a copy of the GNU General Public License
  14         along with this program; if not, write to the Free Software
  15         Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  16
  17         oroborus - (c) 2001 Ken Lynch
  18         xfwm4    - (c) 2002-2007 Olivier Fourdan
  19
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include "config.h"
  24 #endif
  25
  26 #include <glib.h>
  27 #include <gdk/gdk.h>
  28 #include <gdk/gdkx.h>
  29 #include <pango/pango.h>
  30 #include <libxfce4util/libxfce4util.h>
  31
  32 #include "screen.h"
  33 #include "client.h"
  34 #include "settings.h"
  35 #include "mywindow.h"
  36 #include "focus.h"
  37 #include "frame.h"
  38 #include "compositor.h"
  39
  40 #ifndef ShapeInput
  41 #define ShapeInput 2
  42 #endif
  43
  44 typedef struct
  45 {
  46     xfwmPixmap pm_title;
  47     xfwmPixmap pm_sides[SIDE_COUNT];
  48 } FramePixmap;
  49
  50
  51 int
  52 frameDecorationLeft (ScreenInfo *screen_info)
  53 {
  54     TRACE ("entering frameDecorationLeft");
  55
  56     g_return_val_if_fail (screen_info != NULL, 0);
  57     return screen_info->sides[SIDE_LEFT][ACTIVE].width;
  58 }
  59
  60 int
  61 frameDecorationRight (ScreenInfo *screen_info)
  62 {
  63     TRACE ("entering frameDecorationRight");
  64
  65     g_return_val_if_fail (screen_info != NULL, 0);
  66     return screen_info->sides[SIDE_RIGHT][ACTIVE].width;
  67 }
  68
  69 int
  70 frameDecorationTop (ScreenInfo *screen_info)
  71 {
  72     TRACE ("entering frameDecorationTop");
  73
  74     g_return_val_if_fail (screen_info != NULL, 0);
  75     return screen_info->title[TITLE_3][ACTIVE].height;
  76 }
  77
  78 int
  79 frameDecorationBottom (ScreenInfo *screen_info)
  80 {
  81     TRACE ("entering frameDecorationBottom");
  82
  83     g_return_val_if_fail (screen_info != NULL, 0);
  84     return screen_info->sides[SIDE_BOTTOM][ACTIVE].height;
  85 }
  86
  87 int
  88 frameLeft (Client * c)
  89 {
  90     TRACE ("entering frameLeft");
  91
  92     g_return_val_if_fail (c != NULL, 0);
  93     if (FLAG_TEST (c->xfwm_flags, XFWM_FLAG_HAS_BORDER)
  94         && !FLAG_TEST (c->flags, CLIENT_FLAG_FULLSCREEN)
  95         && (!FLAG_TEST_ALL (c->flags, CLIENT_FLAG_MAXIMIZED)
  96             || !(c->screen_info->params->borderless_maximize)))
  97     {
  98         return c->screen_info->sides[SIDE_LEFT][ACTIVE].width;
  99     }
 100     return 0;
 101 }
 102
 103 int
 104 frameRight (Client * c)
 105 {
 106     TRACE ("entering frameRight");
 107
 108     g_return_val_if_fail (c != NULL, 0);
 109     if (FLAG_TEST (c->xfwm_flags, XFWM_FLAG_HAS_BORDER)
 110         && !FLAG_TEST (c->flags, CLIENT_FLAG_FULLSCREEN)
 111         && (!FLAG_TEST_ALL (c->flags, CLIENT_FLAG_MAXIMIZED)
 112             || !(c->screen_info->params->borderless_maximize)))
 113     {
 114         return c->screen_info->sides[SIDE_RIGHT][ACTIVE].width;
 115     }
 116     return 0;
 117 }
 118
 119 int
 120 frameTop (Client * c)
 121 {
 122     TRACE ("entering frameTop");
 123
 124     g_return_val_if_fail (c != NULL, 0);
 125     if (FLAG_TEST (c->xfwm_flags, XFWM_FLAG_HAS_BORDER)
 126         && !FLAG_TEST (c->flags, CLIENT_FLAG_FULLSCREEN))
 127     {
 128         return c->screen_info->title[TITLE_3][ACTIVE].height;
 129     }
 130     return 0;
 131 }
 132
 133 int
 134 frameBottom (Client * c)
 135 {
 136     TRACE ("entering frameBottom");
 137
 138     g_return_val_if_fail (c != NULL, 0);
 139     if (FLAG_TEST (c->xfwm_flags, XFWM_FLAG_HAS_BORDER)
 140         && !FLAG_TEST (c->flags, CLIENT_FLAG_FULLSCREEN)
 141         && (!FLAG_TEST_ALL (c->flags, CLIENT_FLAG_MAXIMIZED)
 142             || !(c->screen_info->params->borderless_maximize)))
 143     {
 144         return c->screen_info->sides[SIDE_BOTTOM][ACTIVE].height;
 145     }
 146     return 0;
 147 }
 148
 149 int
 150 frameX (Client * c)
 151 {
 152     TRACE ("entering frameX");
 153
 154     g_return_val_if_fail (c != NULL, 0);
 155     if (FLAG_TEST (c->xfwm_flags, XFWM_FLAG_HAS_BORDER)
 156         && !FLAG_TEST (c->flags, CLIENT_FLAG_FULLSCREEN)
 157         && (!FLAG_TEST_ALL (c->flags, CLIENT_FLAG_MAXIMIZED)
 158             || !(c->screen_info->params->borderless_maximize)))
 159     {
 160         return c->x - frameLeft (c);
 161     }
 162     return c->x;
 163 }
 164
 165 int
 166 frameY (Client * c)
 167 {
 168     TRACE ("entering frameY");
 169
 170     g_return_val_if_fail (c != NULL, 0);
 171     if (FLAG_TEST (c->xfwm_flags, XFWM_FLAG_HAS_BORDER)
 172          && !FLAG_TEST (c->flags, CLIENT_FLAG_FULLSCREEN))
 173     {
 174         return c->y - frameTop (c);
 175     }
 176     return c->y;
 177 }
 178
 179 int
 180 frameWidth (Client * c)
 181 {
 182     TRACE ("entering frameWidth");
 183
 184     g_return_val_if_fail (c != NULL, 0);
 185     if (FLAG_TEST (c->xfwm_flags, XFWM_FLAG_HAS_BORDER)
 186         && !FLAG_TEST (c->flags, CLIENT_FLAG_FULLSCREEN)
 187         && (!FLAG_TEST_ALL (c->flags, CLIENT_FLAG_MAXIMIZED)
 188             || !(c->screen_info->params->borderless_maximize)))
 189     {
 190         return c->width + frameLeft (c) + frameRight (c);
 191     }
 192     return c->width;
 193 }
 194
 195 int
 196 frameHeight (Client * c)
 197 {
 198     TRACE ("entering frameHeight");
 199
 200     g_return_val_if_fail (c != NULL, 0);
 201     if (FLAG_TEST (c->xfwm_flags, XFWM_FLAG_HAS_BORDER)
 202         && FLAG_TEST (c->flags, CLIENT_FLAG_SHADED)
 203         && !FLAG_TEST (c->flags, CLIENT_FLAG_FULLSCREEN))
 204     {
 205         return frameTop (c) + frameBottom (c);
 206     }
 207     else if (FLAG_TEST (c->xfwm_flags, XFWM_FLAG_HAS_BORDER)
 208              && !FLAG_TEST (c->flags, CLIENT_FLAG_FULLSCREEN))
 209     {
 210         return c->height + frameTop (c) + frameBottom (c);
 211     }
 212     return c->height;
 213 }
 214
 215 static int
 216 frameTopLeftWidth (Client * c, int state)
 217 {
 218     TRACE ("entering frameTopLeftWidth");
 219
 220     g_return_val_if_fail (c != NULL, 0);
 221     if (FLAG_TEST_ALL (c->flags, CLIENT_FLAG_MAXIMIZED)
 222         && c->screen_info->params->borderless_maximize)
 223     {
 224         return 0;
 225     }
 226     return c->screen_info->corners[CORNER_TOP_LEFT][state].width;
 227
 228 }
 229
 230 static int
 231 frameTopRightWidth (Client * c, int state)
 232 {
 233     TRACE ("entering frameTopRightWidth");
 234
 235     g_return_val_if_fail (c != NULL, 0);
 236     if (FLAG_TEST_ALL (c->flags, CLIENT_FLAG_MAXIMIZED)
 237         && c->screen_info->params->borderless_maximize)
 238     {
 239         return 0;
 240     }
 241     return c->screen_info->corners[CORNER_TOP_RIGHT][state].width;
 242 }
 243
 244 static int
 245 frameButtonOffset (Client *c)
 246 {
 247     TRACE ("entering frameButtonOffset");
 248
 249     g_return_val_if_fail (c != NULL, 0);
 250     if (FLAG_TEST_ALL (c->flags, CLIENT_FLAG_MAXIMIZED)
 251         && c->screen_info->params->borderless_maximize)
 252     {
 253         return MAX (0, c->screen_info->params->maximized_offset);
 254     }
 255     return c->screen_info->params->button_offset;
 256 }
 257
 258 static void
 259 frameFillTitlePixmap (Client * c, int state, int part, int x, int w, int h, xfwmPixmap * title_pm, xfwmPixmap * top_pm)
 260 {
 261     ScreenInfo *screen_info;
 262
 263     TRACE ("entering frameFillTitlePixmap");
 264
 265     g_return_if_fail (c);
 266     g_return_if_fail (title_pm);
 267     g_return_if_fail (top_pm);
 268
 269     screen_info = c->screen_info;
 270
 271     if (!xfwmPixmapNone(&screen_info->top[part][state]))
 272     {
 273         xfwmPixmapFill (&screen_info->top[part][state], top_pm, x, 0, w, h);
 274     }
 275     else
 276     {
 277         xfwmPixmapFill (&screen_info->title[part][state], top_pm, x, 0, w, h);
 278     }
 279     xfwmPixmapFill (&screen_info->title[part][state], title_pm, x, 0, w, frameTop (c));
 280 }
 281
 282 static void
 283 frameCreateTitlePixmap (Client * c, int state, int left, int right, xfwmPixmap * title_pm, xfwmPixmap * top_pm)
 284 {
 285     ScreenInfo *screen_info;
 286     DisplayInfo *display_info;
 287     GdkPixmap *gpixmap;
 288     GdkGCValues values;
 289     GdkGC *gc;
 290     PangoLayout *layout;
 291     PangoRectangle logical_rect;
 292     int width, x, hoffset, w1, w2, w3, w4, w5, temp;
 293     int voffset, title_x, title_y;
 294     int top_height;
 295
 296     TRACE ("entering frameCreateTitlePixmap");
 297
 298     g_return_if_fail (c);
 299     g_return_if_fail (title_pm);
 300     g_return_if_fail (top_pm);
 301
 302     screen_info = c->screen_info;
 303     display_info = screen_info->display_info;
 304
 305     if (left > right)
 306     {
 307         temp = left;
 308         left = right;
 309         right = temp;
 310     }
 311
 312     width = frameWidth (c) - frameTopLeftWidth (c, state) - frameTopRightWidth (c, state);
 313     if (width < 1)
 314     {
 315         return;
 316     }
 317
 318     layout = gtk_widget_create_pango_layout (myScreenGetGtkWidget (screen_info), c->name);
 319     pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
 320
 321     if (left < frameTopLeftWidth (c, state))
 322     {
 323         left = frameTopLeftWidth (c, state);
 324     }
 325     if (right > frameWidth (c) - frameTopRightWidth (c, state))
 326     {
 327         right = frameWidth (c) - frameTopRightWidth (c, state);
 328     }
 329     if (right < frameTopLeftWidth (c, state))
 330     {
 331         right = frameTopLeftWidth (c, state);
 332     }
 333
 334     left = left - frameTopLeftWidth (c, state);
 335     right = right - frameTopLeftWidth (c, state);
 336
 337     x = 0;
 338     hoffset = 0;
 339
 340     if (state == ACTIVE)
 341     {
 342         voffset = screen_info->params->title_vertical_offset_active;
 343     }
 344     else
 345     {
 346         voffset = screen_info->params->title_vertical_offset_inactive;
 347     }
 348
 349     title_y = voffset + (frameTop (c) - logical_rect.height) / 2;
 350     if (title_y + logical_rect.height > frameTop (c))
 351     {
 352         title_y = MAX (0, frameTop (c) - logical_rect.height);
 353     }
 354
 355     if (!xfwmPixmapNone(&screen_info->top[3][ACTIVE]))
 356     {
 357         top_height = screen_info->top[3][ACTIVE].height;
 358     }
 359     else
 360     {
 361         top_height = frameTop (c) / 10 + 1;
 362         if (top_height > title_y - 1)
 363         {
 364              top_height = MAX (title_y - 1, 0);
 365         }
 366     }
 367
 368     w1 = 0;
 369     w2 = screen_info->title[TITLE_2][state].width;
 370     w4 = screen_info->title[TITLE_4][state].width;
 371
 372     if (screen_info->params->full_width_title)
 373     {
 374         w1 = left;
 375         w5 = width - right;
 376         w3 = width - w1 - w2 - w4 - w5;
 377         if (w3 < 0)
 378         {
 379             w3 = 0;
 380         }
 381         switch (screen_info->params->title_alignment)
 382         {
 383             case ALIGN_LEFT:
 384                 hoffset = screen_info->params->title_horizontal_offset;
 385                 break;
 386             case ALIGN_RIGHT:
 387                 hoffset = w3 - logical_rect.width - screen_info->params->title_horizontal_offset;
 388                 break;
 389             case ALIGN_CENTER:
 390                 hoffset = (w3 / 2) - (logical_rect.width / 2);
 391                 break;
 392         }
 393         if (hoffset < screen_info->params->title_horizontal_offset)
 394         {
 395             hoffset = screen_info->params->title_horizontal_offset;
 396         }
 397     }
 398     else
 399     {
 400         w3 = logical_rect.width;
 401         w5 = width;
 402         if (w3 > width - w2 - w4)
 403         {
 404             w3 = width - w2 - w4;
 405         }
 406         if (w3 < 0)
 407         {
 408             w3 = 0;
 409         }
 410         switch (screen_info->params->title_alignment)
 411         {
 412             case ALIGN_LEFT:
 413                 w1 = left + screen_info->params->title_horizontal_offset;
 414                 break;
 415             case ALIGN_RIGHT:
 416                 w1 = right - w2 - w3 - w4 - screen_info->params->title_horizontal_offset;
 417                 break;
 418             case ALIGN_CENTER:
 419                 w1 = left + ((right - left) / 2) - (w3 / 2) - w2;
 420                 break;
 421         }
 422         if (w1 < left)
 423         {
 424             w1 = left;
 425         }
 426     }
 427
 428     xfwmPixmapCreate (screen_info, top_pm, width, top_height);
 429     xfwmPixmapCreate (screen_info, title_pm, width, frameTop (c));
 430     gpixmap = gdk_pixmap_foreign_new (title_pm->pixmap);
 431     gdk_drawable_set_colormap (gpixmap, gdk_screen_get_rgb_colormap (screen_info->gscr));
 432     gc = gdk_gc_new (gpixmap);
 433
 434     if (w1 > 0)
 435     {
 436         frameFillTitlePixmap (c, state, TITLE_1, x, w1, top_height, title_pm, top_pm);
 437         x = x + w1;
 438     }
 439
 440     frameFillTitlePixmap (c, state, TITLE_2, x, w2, top_height, title_pm, top_pm);
 441     x = x + w2;
 442
 443     if (w3 > 0)
 444     {
 445         frameFillTitlePixmap (c, state, TITLE_3, x, w3, top_height, title_pm, top_pm);
 446         title_x = hoffset + x;
 447         if (screen_info->params->title_shadow[state])
 448         {
 449             gdk_gc_get_values (screen_info->title_shadow_colors[state].gc, &values);
 450             gdk_gc_set_values (gc, &values, GDK_GC_FOREGROUND);
 451             if (screen_info->params->title_shadow[state] == TITLE_SHADOW_UNDER)
 452             {
 453                 gdk_draw_layout (gpixmap, gc, title_x + 1, title_y + 1, layout);
 454             }
 455             else
 456             {
 457                 gdk_draw_layout (gpixmap, gc, title_x - 1, title_y, layout);
 458                 gdk_draw_layout (gpixmap, gc, title_x, title_y - 1, layout);
 459                 gdk_draw_layout (gpixmap, gc, title_x + 1, title_y, layout);
 460                 gdk_draw_layout (gpixmap, gc, title_x, title_y + 1, layout);
 461             }
 462         }
 463         gdk_gc_get_values (screen_info->title_colors[state].gc, &values);
 464         gdk_gc_set_values (gc, &values, GDK_GC_FOREGROUND);
 465         gdk_draw_layout (gpixmap, gc, title_x, title_y, layout);
 466         x = x + w3;
 467     }
 468
 469     if (x > right - w4)
 470     {
 471         x = right - w4;
 472     }
 473     frameFillTitlePixmap (c, state, TITLE_4, x, w4, top_height, title_pm, top_pm);
 474     x = x + w4;
 475
 476     if (w5 > 0)
 477     {
 478         frameFillTitlePixmap (c, state, TITLE_5, x, w5, top_height, title_pm, top_pm);
 479     }
 480     g_object_unref (G_OBJECT (gc));
 481     g_object_unref (G_OBJECT (gpixmap));
 482     g_object_unref (G_OBJECT (layout));
 483 }
 484
 485 static int
 486 getButtonFromLetter (char chr, Client * c)
 487 {
 488     int b;
 489
 490     TRACE ("entering getButtonFromLetter");
 491
 492     b = -1;
 493     switch (chr)
 494     {
 495         case 'H':
 496             if (CLIENT_CAN_HIDE_WINDOW (c))
 497             {
 498                 b = HIDE_BUTTON;
 499             }
 500             break;
 501         case 'C':
 502             if (FLAG_TEST (c->xfwm_flags, XFWM_FLAG_HAS_CLOSE))
 503             {
 504                 b = CLOSE_BUTTON;
 505             }
 506             break;
 507         case 'M':
 508             if (CLIENT_CAN_MAXIMIZE_WINDOW (c))
 509             {
 510                 b = MAXIMIZE_BUTTON;
 511             }
 512             break;
 513         case 'S':
 514             b = SHADE_BUTTON;
 515             break;
 516         case 'T':
 517             if (FLAG_TEST_ALL (c->xfwm_flags, XFWM_FLAG_HAS_STICK | XFWM_FLAG_HAS_MENU))
 518             {
 519                 b = STICK_BUTTON;
 520             }
 521             break;
 522         case 'O':
 523             if (FLAG_TEST (c->xfwm_flags, XFWM_FLAG_HAS_MENU))
 524             {
 525                 b = MENU_BUTTON;
 526             }
 527             break;
 528         case '|':
 529             b = TITLE_SEPARATOR;
 530             break;
 531         default:
 532             b = -1;
 533     }
 534     return b;
 535 }
 536
 537 static char
 538 getLetterFromButton (int i, Client * c)
 539 {
 540     char chr;
 541
 542     TRACE ("entering getLetterFromButton");
 543
 544     chr = 0;
 545     switch (i)
 546     {
 547         case HIDE_BUTTON:
 548             if (CLIENT_CAN_HIDE_WINDOW (c))
 549             {
 550                 chr = 'H';
 551             }
 552             break;
 553         case CLOSE_BUTTON:
 554             if (FLAG_TEST (c->xfwm_flags, XFWM_FLAG_HAS_CLOSE))
 555             {
 556                 chr = 'C';
 557             }
 558             break;
 559         case MAXIMIZE_BUTTON:
 560             if (CLIENT_CAN_MAXIMIZE_WINDOW (c))
 561             {
 562                 chr = 'M';
 563             }
 564             break;
 565         case SHADE_BUTTON:
 566             chr = 'S';
 567             break;
 568         case STICK_BUTTON:
 569             if (FLAG_TEST_ALL (c->xfwm_flags, XFWM_FLAG_HAS_STICK | XFWM_FLAG_HAS_MENU))
 570             {
 571                 chr = 'T';
 572             }
 573             break;
 574         case MENU_BUTTON:
 575             if (FLAG_TEST (c->xfwm_flags, XFWM_FLAG_HAS_MENU))
 576             {
 577                 chr = 'O';
 578             }
 579             break;
 580         default:
 581             chr = 0;
 582     }
 583     return chr;
 584 }
 585
 586 static void
 587 frameSetShape (Client * c, int state, FramePixmap * frame_pix, int button_x[BUTTON_COUNT])
 588 {
 589     ScreenInfo *screen_info;
 590     DisplayInfo *display_info;
 591     Window shape_win;
 592     XRectangle rect;
 593     xfwmPixmap *my_pixmap;
 594     int i;
 595
 596     TRACE ("entering frameSetShape");
 597     TRACE ("setting shape for client (0x%lx)", c->window);
 598
 599     screen_info = c->screen_info;
 600     display_info = screen_info->display_info;
 601
 602     if (!display_info->have_shape)
 603     {
 604         return;
 605     }
 606
 607     shape_win = XCreateSimpleWindow (display_info->dpy, c->frame, 0, 0, frameWidth (c), frameHeight (c), 0, 0, 0);
 608
 609     if (FLAG_TEST (c->flags, CLIENT_FLAG_SHADED))
 610     {
 611         rect.x = 0;
 612         rect.y = 0;
 613         rect.width  = frameWidth (c);
 614         rect.height = frameHeight (c);
 615         XShapeCombineRectangles (display_info->dpy, shape_win, ShapeBounding, 0, 0, &rect, 1, ShapeSubtract, Unsorted);
 616     }
 617     else if (!FLAG_TEST (c->flags, CLIENT_FLAG_HAS_SHAPE))
 618     {
 619         rect.x = frameLeft (c);
 620         rect.y = frameTop (c);
 621         rect.width  = c->width;
 622         rect.height = c->height;
 623         XShapeCombineRectangles (display_info->dpy, shape_win, ShapeBounding, 0, 0, &rect, 1, ShapeSet, Unsorted);
 624     }
 625     else
 626     {
 627         XShapeCombineShape (display_info->dpy, shape_win, ShapeBounding, frameLeft (c),
 628                             frameTop (c), c->window, ShapeBounding, ShapeSet);
 629     }
 630     if (frame_pix)
 631     {
 632         XShapeCombineMask (display_info->dpy, MYWINDOW_XWINDOW (c->title), ShapeBounding,
 633                            0, 0, frame_pix->pm_title.mask, ShapeSet);
 634         if (!FLAG_TEST (c->flags, CLIENT_FLAG_SHADED))
 635         {
 636             if (xfwmWindowVisible (&c->sides[SIDE_LEFT]))
 637             {
 638                 XShapeCombineMask (display_info->dpy, MYWINDOW_XWINDOW (c->sides[SIDE_LEFT]),
 639                                    ShapeBounding, 0, 0, frame_pix->pm_sides[SIDE_LEFT].mask, ShapeSet);
 640             }
 641
 642             if (xfwmWindowVisible (&c->sides[SIDE_RIGHT]))
 643             {
 644                 XShapeCombineMask (display_info->dpy, MYWINDOW_XWINDOW (c->sides[SIDE_RIGHT]),
 645                                    ShapeBounding, 0, 0, frame_pix->pm_sides[SIDE_RIGHT].mask, ShapeSet);
 646             }
 647         }
 648
 649         if (xfwmWindowVisible (&c->sides[SIDE_BOTTOM]))
 650         {
 651             XShapeCombineMask (display_info->dpy, MYWINDOW_XWINDOW (c->sides[SIDE_BOTTOM]),
 652                                ShapeBounding, 0, 0, frame_pix->pm_sides[SIDE_BOTTOM].mask, ShapeSet);
 653         }
 654
 655         if (xfwmWindowVisible (&c->sides[SIDE_TOP]))
 656         {
 657             XShapeCombineMask (display_info->dpy, MYWINDOW_XWINDOW (c->sides[SIDE_TOP]),
 658                                ShapeBounding, 0, 0, frame_pix->pm_sides[SIDE_TOP].mask, ShapeSet);
 659         }
 660
 661         if (xfwmWindowVisible (&c->corners[CORNER_BOTTOM_LEFT]))
 662         {
 663             XShapeCombineMask (display_info->dpy, MYWINDOW_XWINDOW (c->corners[CORNER_BOTTOM_LEFT]),
 664                                ShapeBounding, 0, 0, screen_info->corners[CORNER_BOTTOM_LEFT][state].mask, ShapeSet);
 665         }
 666
 667         if (xfwmWindowVisible (&c->corners[CORNER_BOTTOM_RIGHT]))
 668         {
 669             XShapeCombineMask (display_info->dpy, MYWINDOW_XWINDOW (c->corners[CORNER_BOTTOM_RIGHT]),
 670                                ShapeBounding, 0, 0, screen_info->corners[CORNER_BOTTOM_RIGHT][state].mask, ShapeSet);
 671         }
 672
 673         if (xfwmWindowVisible (&c->corners[CORNER_TOP_LEFT]))
 674         {
 675             XShapeCombineMask (display_info->dpy, MYWINDOW_XWINDOW (c->corners[CORNER_TOP_LEFT]),
 676                                ShapeBounding, 0, 0, screen_info->corners[CORNER_TOP_LEFT][state].mask, ShapeSet);
 677         }
 678
 679         if (xfwmWindowVisible (&c->corners[CORNER_TOP_RIGHT]))
 680         {
 681             XShapeCombineMask (display_info->dpy, MYWINDOW_XWINDOW (c->corners[CORNER_TOP_RIGHT]),
 682                                ShapeBounding, 0, 0, screen_info->corners[CORNER_TOP_RIGHT][state].mask, ShapeSet);
 683         }
 684
 685         for (i = 0; i < BUTTON_COUNT; i++)
 686         {
 687             if (xfwmWindowVisible (&c->buttons[i]))
 688             {
 689                 my_pixmap = clientGetButtonPixmap (c, i, clientGetButtonState (c, i, state));
 690                 XShapeCombineMask (display_info->dpy, MYWINDOW_XWINDOW (c->buttons[i]),
 691                                    ShapeBounding, 0, 0, my_pixmap->mask, ShapeSet);
 692             }
 693         }
 694
 695         if (xfwmWindowVisible (&c->corners[CORNER_TOP_LEFT]) &&
 696             (screen_info->corners[CORNER_TOP_LEFT][state].height > frameHeight (c) - frameBottom (c) + 1))
 697         {
 698             rect.x      = 0;
 699             rect.y      = frameHeight (c) - frameBottom (c) + 1;
 700             rect.width  = frameTopLeftWidth (c, state);
 701             rect.height = screen_info->corners[CORNER_TOP_LEFT][state].height
 702                            - (frameHeight (c) - frameBottom (c) + 1);
 703             XShapeCombineRectangles (display_info->dpy, MYWINDOW_XWINDOW (c->corners[CORNER_TOP_LEFT]),
 704                                      ShapeBounding, 0, 0, &rect, 1, ShapeSubtract, 0);
 705         }
 706
 707         if (xfwmWindowVisible (&c->corners[CORNER_TOP_RIGHT]) &&
 708             (screen_info->corners[CORNER_TOP_RIGHT][state].height > frameHeight (c) - frameBottom (c) + 1))
 709         {
 710             rect.x      = 0;
 711             rect.y      = frameHeight (c) - frameBottom (c) + 1;
 712             rect.width  = frameTopRightWidth (c, state);
 713             rect.height = screen_info->corners[CORNER_TOP_RIGHT][state].height
 714                            - (frameHeight (c) - frameBottom (c) + 1);
 715             XShapeCombineRectangles (display_info->dpy, MYWINDOW_XWINDOW (c->corners[CORNER_TOP_RIGHT]),
 716                                      ShapeBounding, 0, 0, &rect, 1, ShapeSubtract, 0);
 717         }
 718
 719         if (xfwmWindowVisible (&c->corners[CORNER_BOTTOM_LEFT]) &&
 720             (screen_info->corners[CORNER_BOTTOM_LEFT][state].height > frameHeight (c) - frameTop (c) + 1))
 721         {
 722             rect.x      = 0;
 723             rect.y      = 0;
 724             rect.width  = screen_info->corners[CORNER_BOTTOM_LEFT][state].width;
 725             rect.height = screen_info->corners[CORNER_BOTTOM_LEFT][state].height
 726                            - (frameHeight (c) - frameTop (c) + 1);
 727             XShapeCombineRectangles (display_info->dpy, MYWINDOW_XWINDOW (c->corners[CORNER_BOTTOM_LEFT]),
 728                                      ShapeBounding, 0, 0, &rect, 1, ShapeSubtract, 0);
 729         }
 730
 731         if (xfwmWindowVisible (&c->corners[CORNER_BOTTOM_RIGHT]) &&
 732             (screen_info->corners[CORNER_BOTTOM_RIGHT][state].height > frameHeight (c) - frameTop (c) + 1))
 733         {
 734             rect.x      = 0;
 735             rect.y      = 0;
 736             rect.width  = screen_info->corners[CORNER_BOTTOM_RIGHT][state].width;
 737             rect.height = screen_info->corners[CORNER_BOTTOM_RIGHT][state].height
 738                            - (frameHeight (c) - frameTop (c) + 1);
 739             XShapeCombineRectangles (display_info->dpy, MYWINDOW_XWINDOW (c->corners[CORNER_BOTTOM_RIGHT]),
 740                                      ShapeBounding, 0, 0, &rect, 1, ShapeSubtract, 0);
 741         }
 742
 743         if (!FLAG_TEST (c->flags, CLIENT_FLAG_SHADED))
 744         {
 745             if (xfwmWindowVisible (&c->sides[SIDE_LEFT]))
 746             {
 747                 XShapeCombineShape (display_info->dpy, shape_win, ShapeBounding, 0, frameTop (c),
 748                                     MYWINDOW_XWINDOW (c->sides[SIDE_LEFT]), ShapeBounding, ShapeUnion);
 749             }
 750
 751             if (xfwmWindowVisible (&c->sides[SIDE_RIGHT]))
 752             {
 753                 XShapeCombineShape (display_info->dpy, shape_win, ShapeBounding, frameWidth (c) - frameRight (c), frameTop (c),
 754                                     MYWINDOW_XWINDOW (c->sides[SIDE_RIGHT]), ShapeBounding, ShapeUnion);
 755             }
 756         }
 757
 758         if (xfwmWindowVisible (&c->title))
 759         {
 760             XShapeCombineShape (display_info->dpy, shape_win, ShapeBounding,
 761                                 frameTopLeftWidth (c, state), 0,
 762                                 MYWINDOW_XWINDOW (c->title), ShapeBounding, ShapeUnion);
 763         }
 764
 765         if (xfwmWindowVisible (&c->corners[CORNER_TOP_LEFT]))
 766         {
 767
 768             XShapeCombineShape (display_info->dpy, shape_win, ShapeBounding, 0, 0,
 769                                 MYWINDOW_XWINDOW (c->corners[CORNER_TOP_LEFT]), ShapeBounding, ShapeUnion);
 770         }
 771
 772         if (xfwmWindowVisible (&c->sides[SIDE_BOTTOM]))
 773         {
 774             XShapeCombineShape (display_info->dpy, shape_win, ShapeBounding,
 775                                 screen_info->corners[CORNER_BOTTOM_LEFT][state].width,
 776                                 frameHeight (c) - frameBottom (c),
 777                                 MYWINDOW_XWINDOW (c->sides[SIDE_BOTTOM]), ShapeBounding, ShapeUnion);
 778         }
 779
 780         if (xfwmWindowVisible (&c->sides[SIDE_TOP]))
 781         {
 782             XShapeCombineShape (display_info->dpy, shape_win, ShapeBounding,
 783                                 screen_info->corners[CORNER_BOTTOM_LEFT][state].width,
 784                                 frameTop (c) - frameBottom (c),
 785                                 MYWINDOW_XWINDOW (c->sides[SIDE_TOP]), ShapeBounding, ShapeUnion);
 786         }
 787
 788         if (xfwmWindowVisible (&c->corners[CORNER_BOTTOM_LEFT]))
 789         {
 790             XShapeCombineShape (display_info->dpy, shape_win, ShapeBounding, 0,
 791                                 frameHeight (c) - screen_info->corners[CORNER_BOTTOM_LEFT][state].height,
 792                                 MYWINDOW_XWINDOW (c->corners[CORNER_BOTTOM_LEFT]), ShapeBounding, ShapeUnion);
 793         }
 794
 795         if (xfwmWindowVisible (&c->corners[CORNER_BOTTOM_RIGHT]))
 796         {
 797             XShapeCombineShape (display_info->dpy, shape_win, ShapeBounding,
 798                                 frameWidth (c) - screen_info->corners[CORNER_BOTTOM_RIGHT][state].width,
 799                                 frameHeight (c) - screen_info->corners[CORNER_BOTTOM_RIGHT][state].height,
 800                                 MYWINDOW_XWINDOW (c->corners[CORNER_BOTTOM_RIGHT]), ShapeBounding, ShapeUnion);
 801         }
 802
 803         if (xfwmWindowVisible (&c->corners[CORNER_TOP_RIGHT]))
 804         {
 805             XShapeCombineShape (display_info->dpy, shape_win, ShapeBounding,
 806                                 frameWidth (c) - frameTopRightWidth (c, state),
 807                                 0, MYWINDOW_XWINDOW (c->corners[CORNER_TOP_RIGHT]), ShapeBounding, ShapeUnion);
 808         }
 809
 810         for (i = 0; i < BUTTON_COUNT; i++)
 811         {
 812             if (xfwmWindowVisible (&c->buttons[i]))
 813             {
 814                 XShapeCombineShape (display_info->dpy, shape_win, ShapeBounding, button_x[i],
 815                                     (frameTop (c) - screen_info->buttons[i][state].height + 1) / 2,
 816                                     MYWINDOW_XWINDOW (c->buttons[i]), ShapeBounding, ShapeUnion);
 817             }
 818         }
 819     }
 820     rect.x = 0;
 821     rect.y = 0;
 822     rect.width  = frameWidth (c);
 823     rect.height = frameHeight (c);
 824     XShapeCombineRectangles (display_info->dpy, shape_win, ShapeBounding, 0, 0, &rect, 1, ShapeIntersect, Unsorted);
 825     XShapeCombineShape (display_info->dpy, c->frame, ShapeBounding, 0, 0, shape_win, ShapeBounding, ShapeSet);
 826
 827     /* Set Input shape when using XShape extension 1.1 and later */
 828     if (display_info->shape_version >= 1001)
 829     {
 830         XShapeCombineShape (display_info->dpy, shape_win, ShapeInput, frameLeft (c), frameTop (c), c->window, ShapeBounding, ShapeSubtract);
 831         XShapeCombineShape (display_info->dpy, shape_win, ShapeInput, frameLeft (c), frameTop (c), c->window, ShapeInput, ShapeUnion);
 832         XShapeCombineShape (display_info->dpy, c->frame, ShapeInput, 0, 0, shape_win, ShapeInput, ShapeSet);
 833     }
 834     XDestroyWindow (display_info->dpy, shape_win);
 835 }
 836
 837 void
 838 frameDraw (Client * c, gboolean clear_all)
 839 {
 840     ScreenInfo *screen_info;
 841     FramePixmap frame_pix;
 842     xfwmPixmap *my_pixmap;
 843     int state, i, j, x, button, left, right;
 844     int top_width, bottom_width, left_height, right_height;
 845     int button_x[BUTTON_COUNT];
 846     gboolean requires_clearing;
 847     gboolean width_changed;
 848     gboolean height_changed;
 849
 850     TRACE ("entering frameDraw");
 851     TRACE ("drawing frame for \"%s\" (0x%lx)", c->name, c->window);
 852
 853     g_return_if_fail (c != NULL);
 854
 855     screen_info = c->screen_info;
 856     requires_clearing = FALSE;
 857     width_changed = FALSE;
 858     height_changed = FALSE;
 859     state = ACTIVE;
 860
 861     if (c != clientGetFocus ())
 862     {
 863         TRACE ("\"%s\" is not the active window", c->name);
 864         if (FLAG_TEST (c->wm_flags, WM_FLAG_URGENT))
 865         {
 866             if (FLAG_TEST (c->xfwm_flags, XFWM_FLAG_SEEN_ACTIVE))
 867             {
 868                 state = ACTIVE;
 869             }
 870             else
 871             {
 872                 state = INACTIVE;
 873             }
 874         }
 875         else
 876         {
 877             state = INACTIVE;
 878         }
 879     }
 880
 881     if ((state == INACTIVE)
 882         && FLAG_TEST(c->xfwm_flags, XFWM_FLAG_DRAW_ACTIVE | XFWM_FLAG_FIRST_MAP))
 883     {
 884         requires_clearing = TRUE;
 885         FLAG_UNSET (c->xfwm_flags,  XFWM_FLAG_DRAW_ACTIVE);
 886     }
 887     else if ((state == ACTIVE)
 888              && (!FLAG_TEST (c->xfwm_flags, XFWM_FLAG_DRAW_ACTIVE)
 889                  || FLAG_TEST (c->xfwm_flags, XFWM_FLAG_FIRST_MAP)))
 890     {
 891         requires_clearing = TRUE;
 892         FLAG_SET (c->xfwm_flags,  XFWM_FLAG_DRAW_ACTIVE);
 893     }
 894     /* Flag clearance */
 895     FLAG_UNSET (c->xfwm_flags,  XFWM_FLAG_FIRST_MAP);
 896
 897     /* Cache mgmt */
 898     if (clear_all)
 899     {
 900         width_changed = TRUE;
 901         height_changed = TRUE;
 902         requires_clearing = TRUE;
 903         frameClearQueueDraw (c);
 904         if (c->frame_timeout_id)
 905         {
 906             g_source_remove (c->frame_timeout_id);
 907             c->frame_timeout_id = 0;
 908         }
 909
 910     }
 911     else
 912     {
 913         if (c->previous_width != c->width)
 914         {
 915             width_changed = TRUE;
 916             c->previous_width = c->width;
 917         }
 918         if (c->previous_height != c->height)
 919         {
 920             height_changed = TRUE;
 921             c->previous_height = c->height;
 922         }
 923     }
 924
 925     if (FLAG_TEST (c->xfwm_flags, XFWM_FLAG_HAS_BORDER)
 926         && !FLAG_TEST (c->flags, CLIENT_FLAG_FULLSCREEN))
 927     {
 928         /* First, hide the buttons that we don't have... */
 929         for (i = 0; i < BUTTON_COUNT; i++)
 930         {
 931             char b = getLetterFromButton (i, c);
 932             if ((!b) || !strchr (screen_info->params->button_layout, b))
 933             {
 934                 xfwmWindowHide (&c->buttons[i]);
 935             }
 936         }
 937
 938         /* Then, show the ones that we do have on left... */
 939         x = frameLeft (c) + frameButtonOffset (c);
 940         if (x < 0)
 941         {
 942             x = 0;
 943         }
 944         right = frameWidth (c) - frameRight (c) - frameButtonOffset (c);
 945         for (i = 0; i < strlen (screen_info->params->button_layout); i++)
 946         {
 947             button = getButtonFromLetter (screen_info->params->button_layout[i], c);
 948             if (button == TITLE_SEPARATOR)
 949             {
 950                 break;
 951             }
 952             else if (button >= 0)
 953             {
 954                 if (x + screen_info->buttons[button][state].width + screen_info->params->button_spacing < right)
 955                 {
 956                     my_pixmap = clientGetButtonPixmap (c, button, clientGetButtonState (c, button, state));
 957                     if (!xfwmPixmapNone(my_pixmap))
 958                     {
 959                         xfwmWindowSetBG (&c->buttons[button], my_pixmap);
 960                     }
 961                     xfwmWindowShow (&c->buttons[button], x,
 962                         (frameTop (c) - screen_info->buttons[button][state].height + 1) / 2,
 963                         screen_info->buttons[button][state].width,
 964                         screen_info->buttons[button][state].height, TRUE);
 965                     button_x[button] = x;
 966                     x = x + screen_info->buttons[button][state].width +
 967                         screen_info->params->button_spacing;
 968                 }
 969                 else
 970                 {
 971                     xfwmWindowHide (&c->buttons[button]);
 972                 }
 973             }
 974         }
 975         left = x + screen_info->params->button_spacing;
 976
 977         /* and those that we do have on right... */
 978         x = frameWidth (c) - frameRight (c) + screen_info->params->button_spacing -
 979             frameButtonOffset (c);
 980         for (j = strlen (screen_info->params->button_layout) - 1; j >= i; j--)
 981         {
 982             button = getButtonFromLetter (screen_info->params->button_layout[j], c);
 983             if (button == TITLE_SEPARATOR)
 984             {
 985                 break;
 986             }
 987             else if (button >= 0)
 988             {
 989                 if (x - screen_info->buttons[button][state].width - screen_info->params->button_spacing > left)
 990                 {
 991                     my_pixmap = clientGetButtonPixmap (c, button, clientGetButtonState (c, button, state));
 992                     if (!xfwmPixmapNone(my_pixmap))
 993                     {
 994                         xfwmWindowSetBG (&c->buttons[button], my_pixmap);
 995                     }
 996                     x = x - screen_info->buttons[button][state].width -
 997                         screen_info->params->button_spacing;
 998                     xfwmWindowShow (&c->buttons[button], x,
 999                         (frameTop (c) - screen_info->buttons[button][state].height + 1) / 2,
1000                         screen_info->buttons[button][state].width,
1001                         screen_info->buttons[button][state].height, TRUE);
1002                     button_x[button] = x;
1003                 }
1004                 else
1005                 {
1006                     xfwmWindowHide (&c->buttons[button]);
1007                 }
1008             }
1009         }
1010         left = left - 2 * screen_info->params->button_spacing;
1011         right = x;
1012
1013         top_width = frameWidth (c) - frameTopLeftWidth (c, state) - frameTopRightWidth (c, state);
1014         bottom_width = frameWidth (c) -
1015             screen_info->corners[CORNER_BOTTOM_LEFT][state].width -
1016             screen_info->corners[CORNER_BOTTOM_RIGHT][state].width;
1017         left_height = frameHeight (c) - frameTop (c) -
1018             screen_info->corners[CORNER_BOTTOM_LEFT][state].height;
1019         right_height = frameHeight (c) - frameTop (c) -
1020             screen_info->corners[CORNER_BOTTOM_RIGHT][state].height;
1021
1022         xfwmPixmapInit (screen_info, &frame_pix.pm_title);
1023         xfwmPixmapInit (screen_info, &frame_pix.pm_sides[SIDE_TOP]);
1024         xfwmPixmapInit (screen_info, &frame_pix.pm_sides[SIDE_BOTTOM]);
1025         xfwmPixmapInit (screen_info, &frame_pix.pm_sides[SIDE_LEFT]);
1026         xfwmPixmapInit (screen_info, &frame_pix.pm_sides[SIDE_RIGHT]);
1027
1028         /* The title is always visible */
1029         frameCreateTitlePixmap (c, state, left, right, &frame_pix.pm_title, &frame_pix.pm_sides[SIDE_TOP]);
1030         xfwmWindowSetBG (&c->title, &frame_pix.pm_title);
1031         xfwmWindowShow (&c->title,
1032             frameTopLeftWidth (c, state), 0, top_width,
1033             frameTop (c), (requires_clearing | width_changed));
1034
1035         /* Corners are never resized, we need to update them separately */
1036         if (requires_clearing)
1037         {
1038             xfwmWindowSetBG (&c->corners[CORNER_TOP_LEFT],
1039                 &screen_info->corners[CORNER_TOP_LEFT][state]);
1040             xfwmWindowSetBG (&c->corners[CORNER_TOP_RIGHT],
1041                 &screen_info->corners[CORNER_TOP_RIGHT][state]);
1042             xfwmWindowSetBG (&c->corners[CORNER_BOTTOM_LEFT],
1043                 &screen_info->corners[CORNER_BOTTOM_LEFT][state]);
1044             xfwmWindowSetBG (&c->corners[CORNER_BOTTOM_RIGHT],
1045                 &screen_info->corners[CORNER_BOTTOM_RIGHT][state]);
1046         }
1047
1048         if (FLAG_TEST_ALL (c->flags, CLIENT_FLAG_MAXIMIZED)
1049             && (c->screen_info->params->borderless_maximize))
1050         {
1051             xfwmWindowHide (&c->sides[SIDE_LEFT]);
1052             xfwmWindowHide (&c->sides[SIDE_RIGHT]);
1053             xfwmWindowHide (&c->sides[SIDE_BOTTOM]);
1054             xfwmWindowHide (&c->sides[SIDE_TOP]);
1055             xfwmWindowHide (&c->corners[CORNER_TOP_LEFT]);
1056             xfwmWindowHide (&c->corners[CORNER_TOP_RIGHT]);
1057             xfwmWindowHide (&c->corners[CORNER_BOTTOM_LEFT]);
1058             xfwmWindowHide (&c->corners[CORNER_BOTTOM_RIGHT]);
1059         }
1060         else
1061         {
1062             if (FLAG_TEST (c->flags, CLIENT_FLAG_SHADED))
1063             {
1064                 xfwmWindowHide (&c->sides[SIDE_LEFT]);
1065                 xfwmWindowHide (&c->sides[SIDE_RIGHT]);
1066             }
1067             else
1068             {
1069                 xfwmPixmapCreate (screen_info, &frame_pix.pm_sides[SIDE_LEFT],
1070                     frameLeft (c), left_height);
1071                 xfwmPixmapFill (&screen_info->sides[SIDE_LEFT][state],
1072                     &frame_pix.pm_sides[SIDE_LEFT],
1073                     0, 0, frameLeft (c), left_height);
1074                 xfwmWindowSetBG (&c->sides[SIDE_LEFT],
1075                     &frame_pix.pm_sides[SIDE_LEFT]);
1076                 xfwmWindowShow (&c->sides[SIDE_LEFT], 0, frameTop (c),
1077                     frameLeft (c), left_height, (requires_clearing | height_changed));
1078
1079                 xfwmPixmapCreate (screen_info, &frame_pix.pm_sides[SIDE_RIGHT],
1080                     frameRight (c), right_height);
1081                 xfwmPixmapFill (&screen_info->sides[SIDE_RIGHT][state],
1082                     &frame_pix.pm_sides[SIDE_RIGHT],
1083                     0, 0, frameRight (c), right_height);
1084                 xfwmWindowSetBG (&c->sides[SIDE_RIGHT],
1085                     &frame_pix.pm_sides[SIDE_RIGHT]);
1086                 xfwmWindowShow (&c->sides[SIDE_RIGHT],
1087                     frameWidth (c) - frameRight (c), frameTop (c), frameRight (c),
1088                     right_height, (requires_clearing | height_changed));
1089             }
1090
1091             xfwmPixmapCreate (screen_info, &frame_pix.pm_sides[SIDE_BOTTOM],
1092                 bottom_width, frameBottom (c));
1093             xfwmPixmapFill (&screen_info->sides[SIDE_BOTTOM][state],
1094                 &frame_pix.pm_sides[SIDE_BOTTOM],
1095                 0, 0, bottom_width, frameBottom (c));
1096             xfwmWindowSetBG (&c->sides[SIDE_BOTTOM],
1097                 &frame_pix.pm_sides[SIDE_BOTTOM]);
1098             xfwmWindowShow (&c->sides[SIDE_BOTTOM],
1099                 screen_info->corners[CORNER_BOTTOM_LEFT][state].width,
1100                 frameHeight (c) - frameBottom (c), bottom_width, frameBottom (c),
1101                 (requires_clearing | width_changed));
1102
1103             if (!xfwmPixmapNone(&frame_pix.pm_sides[SIDE_TOP]))
1104             {
1105                 xfwmWindowSetBG (&c->sides[SIDE_TOP], &frame_pix.pm_sides[SIDE_TOP]);
1106                 xfwmWindowShow (&c->sides[SIDE_TOP],
1107                     screen_info->corners[CORNER_TOP_LEFT][state].width,
1108                     0, top_width, frame_pix.pm_sides[SIDE_TOP].height,
1109                     (requires_clearing | width_changed));
1110             }
1111             else
1112             {
1113                 xfwmWindowHide (&c->sides[SIDE_TOP]);
1114             }
1115
1116             xfwmWindowShow (&c->corners[CORNER_TOP_LEFT], 0, 0,
1117                 frameTopLeftWidth (c, state),
1118                 screen_info->corners[CORNER_TOP_LEFT][state].height,
1119                 requires_clearing);
1120
1121             xfwmWindowShow (&c->corners[CORNER_TOP_RIGHT],
1122                 frameWidth (c) - frameTopRightWidth (c, state),
1123                 0, frameTopRightWidth (c, state),
1124                 screen_info->corners[CORNER_TOP_RIGHT][state].height,
1125                 requires_clearing);
1126
1127             xfwmWindowShow (&c->corners[CORNER_BOTTOM_LEFT], 0,
1128                 frameHeight (c) -
1129                 screen_info->corners[CORNER_BOTTOM_LEFT][state].height,
1130                 screen_info->corners[CORNER_BOTTOM_LEFT][state].width,
1131                 screen_info->corners[CORNER_BOTTOM_LEFT][state].height,
1132                 requires_clearing);
1133
1134             xfwmWindowShow (&c->corners[CORNER_BOTTOM_RIGHT],
1135                 frameWidth (c) -
1136                 screen_info->corners[CORNER_BOTTOM_RIGHT][state].width,
1137                 frameHeight (c) -
1138                 screen_info->corners[CORNER_BOTTOM_RIGHT][state].height,
1139                 screen_info->corners[CORNER_BOTTOM_RIGHT][state].width,
1140                 screen_info->corners[CORNER_BOTTOM_RIGHT][state].height,
1141                 requires_clearing);
1142         }
1143         frameSetShape (c, state, &frame_pix, button_x);
1144
1145         xfwmPixmapFree (&frame_pix.pm_title);
1146         xfwmPixmapFree (&frame_pix.pm_sides[SIDE_TOP]);
1147         xfwmPixmapFree (&frame_pix.pm_sides[SIDE_BOTTOM]);
1148         xfwmPixmapFree (&frame_pix.pm_sides[SIDE_LEFT]);
1149         xfwmPixmapFree (&frame_pix.pm_sides[SIDE_RIGHT]);
1150     }
1151     else
1152     {
1153         if (xfwmWindowVisible (&c->title))
1154         {
1155             xfwmWindowHide (&c->title);
1156         }
1157         for (i = 0; i < 4; i++)
1158         {
1159             if (MYWINDOW_XWINDOW (c->sides[i]) && xfwmWindowVisible (&c->sides[i]))
1160             {
1161                 xfwmWindowHide (&c->sides[i]);
1162             }
1163         }
1164         for (i = 0; i < 4; i++)
1165         {
1166             if (MYWINDOW_XWINDOW (c->corners[i]) && xfwmWindowVisible (&c->corners[i]))
1167             {
1168                 xfwmWindowHide (&c->corners[i]);
1169             }
1170         }
1171         for (i = 0; i < BUTTON_COUNT; i++)
1172         {
1173             if (MYWINDOW_XWINDOW (c->buttons[i]) && xfwmWindowVisible (&c->buttons[i]))
1174             {
1175                 xfwmWindowHide (&c->buttons[i]);
1176             }
1177         }
1178         frameSetShape (c, 0, NULL, 0);
1179     }
1180 }
1181
1182 static gboolean
1183 update_frame_idle_cb (gpointer data)
1184 {
1185     Client *c;
1186
1187     TRACE ("entering update_frame_idle_cb");
1188
1189     c = (Client *) data;
1190     g_return_val_if_fail (c, FALSE);
1191
1192     frameDraw (c, TRUE);
1193     c->frame_timeout_id = 0;
1194
1195     return FALSE;
1196 }
1197
1198 void
1199 frameClearQueueDraw (Client * c)
1200 {
1201     g_return_if_fail (c);
1202
1203     TRACE ("entering frameClearQueueDraw for \"%s\" (0x%lx)", c->name, c->window);
1204
1205     if (c->frame_timeout_id)
1206     {
1207         g_source_remove (c->frame_timeout_id);
1208         c->frame_timeout_id = 0;
1209     }
1210 }
1211
1212 void
1213 frameQueueDraw (Client * c)
1214 {
1215     g_return_if_fail (c);
1216
1217     TRACE ("entering frameQueueDraw for \"%s\" (0x%lx)", c->name, c->window);
1218
1219     if (c->frame_timeout_id == 0)
1220     {
1221         c->frame_timeout_id = g_idle_add_full (G_PRIORITY_DEFAULT_IDLE,
1222                                               update_frame_idle_cb, c, NULL);
1223     }
1224 }
1225