src/framewin.c

   1 /*
   2  *  Window Maker window manager
   3  *
   4  *  Copyright (c) 1997, 1998 Alfredo K. Kojima
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  19  *  USA.
  20  */
  21
  22 #include "wconfig.h"
  23
  24 #include <X11/Xlib.h>
  25 #include <X11/Xutil.h>
  26 #ifdef KEEP_XKB_LOCK_STATUS
  27 #include <X11/XKBlib.h>
  28 #endif /* KEEP_XKB_LOCK_STATUS */
  29
  30 #include <stdlib.h>
  31 #include <string.h>
  32
  33 #include <wraster.h>
  34
  35 #include "WindowMaker.h"
  36 #include "GNUstep.h"
  37 #include "texture.h"
  38 #include "screen.h"
  39 #include "wcore.h"
  40 #include "framewin.h"
  41 #include "stacking.h"
  42 #include "funcs.h"
  43
  44 #define DBLCLICK_TIME wPreferences.dblclick_time
  45
  46 extern WPreferences wPreferences;
  47
  48 static void handleExpose(WObjDescriptor *desc, XEvent *event);
  49 static void handleButtonExpose(WObjDescriptor *desc, XEvent *event);
  50
  51 static void buttonMouseDown(WObjDescriptor *desc, XEvent *event);
  52 static void titlebarMouseDown(WObjDescriptor *desc, XEvent *event);
  53 static void resizebarMouseDown(WObjDescriptor *desc, XEvent *event);
  54
  55 static void checkTitleSize(WFrameWindow *fwin);
  56
  57
  58 static void paintButton(WCoreWindow *button, WTexture *texture,
  59                         unsigned long color,  WPixmap *image, int pushed);
  60
  61 static void updateTitlebar(WFrameWindow *fwin);
  62
  63
  64 WFrameWindow*
  65 wFrameWindowCreate(WScreen *scr, int wlevel, int x, int y,
  66                    int width, int height, int *clearance, int flags,
  67                    WTexture **title_texture, WTexture **resize_texture,
  68                    unsigned long *color,
  69            GC *gc, WMFont **font)
  70 {
  71     WFrameWindow *fwin;
  72
  73     fwin = wmalloc(sizeof(WFrameWindow));
  74     memset(fwin, 0, sizeof(WFrameWindow));
  75
  76     fwin->screen_ptr = scr;
  77
  78     fwin->flags.single_texture = (flags & WFF_SINGLE_STATE) ? 1 : 0;
  79
  80     fwin->title_texture = title_texture;
  81     fwin->resizebar_texture = resize_texture;
  82     fwin->title_pixel = color;
  83     fwin->title_clearance = clearance;
  84     fwin->title_gc = gc;
  85     fwin->font = font;
  86 #ifdef KEEP_XKB_LOCK_STATUS
  87     fwin->languagemode = XkbGroup1Index;
  88     fwin->last_languagemode = XkbGroup2Index;
  89 #endif
  90
  91     fwin->core = wCoreCreateTopLevel(scr, x, y, width, height,
  92                                      (flags & WFF_BORDER)
  93                                      ? FRAME_BORDER_WIDTH : 0);
  94     if (wPreferences.use_saveunders) {
  95         unsigned long vmask;
  96         XSetWindowAttributes attribs;
  97
  98         vmask = CWSaveUnder;
  99         attribs.save_under = True;
 100         XChangeWindowAttributes(dpy, fwin->core->window, vmask, &attribs);
 101     }
 102
 103     /* setup stacking information */
 104     fwin->core->stacking = wmalloc(sizeof(WStacking));
 105     fwin->core->stacking->above = NULL;
 106     fwin->core->stacking->under = NULL;
 107     fwin->core->stacking->child_of = NULL;
 108     fwin->core->stacking->window_level = wlevel;
 109
 110     AddToStackList(fwin->core);
 111
 112     wFrameWindowUpdateBorders(fwin, flags);
 113
 114     return fwin;
 115 }
 116
 117
 118
 119 void
 120 wFrameWindowUpdateBorders(WFrameWindow *fwin, int flags)
 121 {
 122     int theight;
 123     int bsize;
 124     int width, height;
 125     int i;
 126     WScreen *scr = fwin->screen_ptr;
 127
 128     width = fwin->core->width;
 129     if (flags & WFF_IS_SHADED)
 130         height = -1;
 131     else
 132         height = fwin->core->height - fwin->top_width - fwin->bottom_width;
 133
 134     if (flags & WFF_TITLEBAR)
 135         theight = WMFontHeight(*fwin->font) + (*fwin->title_clearance + TITLEBAR_EXTEND_SPACE) * 2;
 136     else
 137         theight = 0;
 138
 139     if (wPreferences.new_style) {
 140         bsize = theight;
 141     } else {
 142         bsize = theight - 7;
 143     }
 144
 145     if (fwin->titlebar) {
 146         /* if we had a titlebar and is requesting for one,
 147          * check if the size has changed and resize it */
 148         if (flags & WFF_TITLEBAR) {
 149             fwin->top_width = theight;
 150
 151             fwin->flags.need_texture_remake = 1;
 152
 153             if (wPreferences.new_style) {
 154                 if (fwin->left_button) {
 155                     wCoreConfigure(fwin->left_button, 0, 0, bsize, bsize);
 156                 }
 157 #ifdef XKB_BUTTON_HINT
 158                 if (fwin->language_button)
 159                     if (fwin->flags.hide_left_button || !fwin->left_button
 160                         || fwin->flags.lbutton_dont_fit) {
 161                         wCoreConfigure(fwin->language_button, 0, 0, bsize, bsize);
 162                     } else {
 163                         wCoreConfigure(fwin->language_button, bsize, 0, bsize, bsize);
 164                     }
 165 #endif
 166
 167
 168                 if (fwin->right_button) {
 169                     wCoreConfigure(fwin->right_button, width-bsize+1,
 170                                    0, bsize, bsize);
 171                 }
 172             } else { /* !new_style */
 173                 if (fwin->left_button) {
 174                     wCoreConfigure(fwin->left_button, 3, (theight-bsize)/2,
 175                                    bsize, bsize);
 176                 }
 177
 178 #ifdef XKB_BUTTON_HINT
 179                 if (fwin->language_button) {
 180                     wCoreConfigure(fwin->language_button, 6 + bsize, (theight-bsize)/2,
 181                                    bsize, bsize);
 182                 }
 183 #endif
 184
 185                 if (fwin->right_button) {
 186                     wCoreConfigure(fwin->right_button, width-bsize-3,
 187                                    (theight-bsize)/2, bsize, bsize);
 188                 }
 189             }
 190             updateTitlebar(fwin);
 191         } else {
 192             /* we had a titlebar, but now we don't need it anymore */
 193             for (i=0; i < (fwin->flags.single_texture ? 1 : 3); i++) {
 194                 FREE_PIXMAP(fwin->title_back[i]);
 195                 if (wPreferences.new_style) {
 196                     FREE_PIXMAP(fwin->lbutton_back[i]);
 197                     FREE_PIXMAP(fwin->rbutton_back[i]);
 198 #ifdef XKB_BUTTON_HINT
 199                     FREE_PIXMAP(fwin->languagebutton_back[i]);
 200 #endif
 201                 }
 202             }
 203             if (fwin->left_button)
 204                 wCoreDestroy(fwin->left_button);
 205             fwin->left_button = NULL;
 206
 207 #ifdef XKB_BUTTON_HINT
 208             if (fwin->language_button)
 209                 wCoreDestroy(fwin->language_button);
 210             fwin->language_button = NULL;
 211 #endif
 212
 213             if (fwin->right_button)
 214                 wCoreDestroy(fwin->right_button);
 215             fwin->right_button = NULL;
 216
 217             wCoreDestroy(fwin->titlebar);
 218             fwin->titlebar = NULL;
 219
 220             fwin->top_width = 0;
 221         }
 222     } else {
 223         /* if we didn't have a titlebar and are being requested for
 224          * one, create it */
 225         if (flags & WFF_TITLEBAR) {
 226             fwin->top_width = theight;
 227
 228             fwin->flags.titlebar = 1;
 229             fwin->titlebar = wCoreCreate(fwin->core, 0, 0, width+1, theight);
 230
 231             if (flags & WFF_LEFT_BUTTON) {
 232                 fwin->flags.left_button = 1;
 233                 if (wPreferences.new_style) {
 234                     fwin->left_button = wCoreCreate(fwin->core, 0, 0,
 235                                                     bsize, bsize);
 236                     if (width < theight*4) {
 237                         fwin->flags.lbutton_dont_fit = 1;
 238                     } else {
 239                         XMapRaised(dpy, fwin->left_button->window);
 240                     }
 241                 } else {
 242                     fwin->left_button =
 243                         wCoreCreate(fwin->titlebar, 3, (theight-bsize)/2,
 244                                     bsize, bsize);
 245
 246                     XSetWindowBackground(dpy, fwin->left_button->window,
 247                                          scr->widget_texture->normal.pixel);
 248
 249                     if (width < theight*3) {
 250                         fwin->flags.lbutton_dont_fit = 1;
 251                     } else {
 252                         XMapRaised(dpy, fwin->left_button->window);
 253                     }
 254                 }
 255             }
 256
 257 #ifdef XKB_BUTTON_HINT
 258             if (flags & WFF_LANGUAGE_BUTTON) {
 259                 fwin->flags.language_button = 1;
 260                 if (wPreferences.new_style) {
 261                     fwin->language_button = wCoreCreate(fwin->core,
 262                                                         bsize, 0, bsize, bsize);
 263
 264                     if (width < theight*4) {
 265                         fwin->flags.languagebutton_dont_fit = 1;
 266                     } else {
 267                         XMapRaised(dpy, fwin->language_button->window);
 268                     }
 269                 } else {
 270                     fwin->language_button =
 271                         wCoreCreate(fwin->titlebar, bsize + 6, (theight-bsize)/2,
 272                                     bsize, bsize);
 273
 274                     XSetWindowBackground(dpy, fwin->language_button->window,
 275                                          scr->widget_texture->normal.pixel);
 276
 277                     if (width < theight*3) {
 278                         fwin->flags.languagebutton_dont_fit = 1;
 279                     } else {
 280                         XMapRaised(dpy, fwin->language_button->window);
 281                     }
 282                 }
 283             }
 284 #endif
 285
 286             if (flags & WFF_RIGHT_BUTTON) {
 287                 fwin->flags.right_button = 1;
 288                 if (wPreferences.new_style) {
 289                     fwin->right_button =
 290                         wCoreCreate(fwin->core, width-bsize+1, 0,
 291                                     bsize, bsize);
 292                 } else {
 293                     fwin->right_button =
 294                         wCoreCreate(fwin->titlebar, width-bsize-3,
 295                                     (theight-bsize)/2, bsize, bsize);
 296                     XSetWindowBackground(dpy, fwin->right_button->window,
 297                                          scr->widget_texture->normal.pixel);
 298                 }
 299
 300                 if (width < theight*2) {
 301                     fwin->flags.rbutton_dont_fit = 1;
 302                 } else {
 303                     XMapRaised(dpy, fwin->right_button->window);
 304                 }
 305             }
 306
 307             if (wPreferences.new_style)
 308                 updateTitlebar(fwin);
 309
 310             XMapRaised(dpy, fwin->titlebar->window);
 311
 312             fwin->flags.need_texture_remake = 1;
 313         }
 314     }
 315     checkTitleSize(fwin);
 316
 317     if (flags & WFF_RESIZEBAR) {
 318         fwin->bottom_width = RESIZEBAR_HEIGHT;
 319
 320         if (!fwin->resizebar) {
 321             fwin->flags.resizebar = 1;
 322             fwin->resizebar = wCoreCreate(fwin->core, 0,
 323                                           height + fwin->top_width,
 324                                           width, RESIZEBAR_HEIGHT);
 325             fwin->resizebar_corner_width = RESIZEBAR_CORNER_WIDTH;
 326             if (width < RESIZEBAR_CORNER_WIDTH*2 + RESIZEBAR_MIN_WIDTH) {
 327                 fwin->resizebar_corner_width = (width - RESIZEBAR_MIN_WIDTH)/2;
 328                 if (fwin->resizebar_corner_width < 0)
 329                     fwin->resizebar_corner_width = 0;
 330             }
 331
 332             XMapWindow(dpy, fwin->resizebar->window);
 333             XLowerWindow(dpy, fwin->resizebar->window);
 334
 335             fwin->flags.need_texture_remake = 1;
 336         } else {
 337             if (height+fwin->top_width+fwin->bottom_width != fwin->core->height) {
 338                 wCoreConfigure(fwin->resizebar, 0, height + fwin->top_width,
 339                                width, RESIZEBAR_HEIGHT);
 340             }
 341         }
 342     } else {
 343         fwin->bottom_width = 0;
 344
 345         if (fwin->resizebar) {
 346             fwin->bottom_width = 0;
 347             wCoreDestroy(fwin->resizebar);
 348             fwin->resizebar = NULL;
 349         }
 350     }
 351
 352     if (height + fwin->top_width + fwin->bottom_width != fwin->core->height
 353         && !(flags & WFF_IS_SHADED)) {
 354         wFrameWindowResize(fwin, width,
 355                            height + fwin->top_width + fwin->bottom_width);
 356     }
 357
 358
 359     if (flags & WFF_BORDER) {
 360         XSetWindowBorderWidth(dpy, fwin->core->window, FRAME_BORDER_WIDTH);
 361     } else {
 362         XSetWindowBorderWidth(dpy, fwin->core->window, 0);
 363     }
 364
 365     /* setup object descriptors */
 366
 367     if (fwin->titlebar) {
 368         fwin->titlebar->descriptor.handle_expose = handleExpose;
 369         fwin->titlebar->descriptor.parent = fwin;
 370         fwin->titlebar->descriptor.parent_type = WCLASS_FRAME;
 371         fwin->titlebar->descriptor.handle_mousedown = titlebarMouseDown;
 372     }
 373
 374     if (fwin->resizebar) {
 375         fwin->resizebar->descriptor.handle_expose = handleExpose;
 376         fwin->resizebar->descriptor.parent = fwin;
 377         fwin->resizebar->descriptor.parent_type = WCLASS_FRAME;
 378         fwin->resizebar->descriptor.handle_mousedown = resizebarMouseDown;
 379     }
 380
 381     if (fwin->left_button) {
 382         fwin->left_button->descriptor.handle_expose = handleButtonExpose;
 383         fwin->left_button->descriptor.parent = fwin;
 384         fwin->left_button->descriptor.parent_type = WCLASS_FRAME;
 385         fwin->left_button->descriptor.handle_mousedown = buttonMouseDown;
 386     }
 387
 388 #ifdef XKB_BUTTON_HINT
 389     if (fwin->language_button) {
 390         fwin->language_button->descriptor.handle_expose = handleButtonExpose;
 391         fwin->language_button->descriptor.parent = fwin;
 392         fwin->language_button->descriptor.parent_type = WCLASS_FRAME;
 393         fwin->language_button->descriptor.handle_mousedown = buttonMouseDown;
 394     }
 395 #endif
 396
 397
 398     if (fwin->right_button) {
 399         fwin->right_button->descriptor.parent = fwin;
 400         fwin->right_button->descriptor.parent_type = WCLASS_FRAME;
 401         fwin->right_button->descriptor.handle_expose = handleButtonExpose;
 402         fwin->right_button->descriptor.handle_mousedown = buttonMouseDown;
 403     }
 404
 405     checkTitleSize(fwin);
 406 }
 407
 408
 409
 410 void
 411 wFrameWindowDestroy(WFrameWindow *fwin)
 412 {
 413     int i;
 414
 415     if (fwin->left_button)
 416         wCoreDestroy(fwin->left_button);
 417
 418 #ifdef XKB_BUTTON_HINT
 419     if (fwin->language_button)
 420     wCoreDestroy(fwin->language_button);
 421 #endif
 422
 423     if (fwin->right_button)
 424         wCoreDestroy(fwin->right_button);
 425
 426     if (fwin->resizebar)
 427         wCoreDestroy(fwin->resizebar);
 428
 429     if (fwin->titlebar)
 430         wCoreDestroy(fwin->titlebar);
 431
 432     RemoveFromStackList(fwin->core);
 433
 434     wCoreDestroy(fwin->core);
 435
 436     if (fwin->title)
 437         wfree(fwin->title);
 438
 439     for (i=0; i < (fwin->flags.single_texture ? 1 : 3); i++) {
 440         FREE_PIXMAP(fwin->title_back[i]);
 441         if (wPreferences.new_style) {
 442             FREE_PIXMAP(fwin->lbutton_back[i]);
 443 #ifdef XKB_BUTTON_HINT
 444             FREE_PIXMAP(fwin->languagebutton_back[i]);
 445 #endif
 446             FREE_PIXMAP(fwin->rbutton_back[i]);
 447         }
 448     }
 449
 450     wfree(fwin);
 451 }
 452
 453
 454 void
 455 wFrameWindowChangeState(WFrameWindow *fwin, int state)
 456 {
 457     if (fwin->flags.state==state)
 458         return;
 459
 460     fwin->flags.state = state;
 461     fwin->flags.need_texture_change = 1;
 462
 463     wFrameWindowPaint(fwin);
 464 }
 465
 466
 467 static void
 468 updateTitlebar(WFrameWindow *fwin)
 469 {
 470     int x, w;
 471     int theight;
 472
 473         theight = WMFontHeight(*fwin->font) + (*fwin->title_clearance + TITLEBAR_EXTEND_SPACE) * 2;
 474
 475     x = 0;
 476     w = fwin->core->width + 1;
 477
 478     if (wPreferences.new_style) {
 479         if (fwin->flags.hide_left_button || !fwin->left_button
 480             || fwin->flags.lbutton_dont_fit) {
 481             x = 0;
 482 #ifdef XKB_BUTTON_HINT
 483         if(fwin->language_button)
 484             wCoreConfigure(fwin->language_button, 0, 0,
 485                     fwin->language_button->width,
 486                     fwin->language_button->width);
 487 #endif
 488         } else {
 489 #ifdef XKB_BUTTON_HINT
 490         if(fwin->language_button)
 491             wCoreConfigure(fwin->language_button, fwin->left_button->width, 0,
 492                     fwin->language_button->width,
 493                     fwin->language_button->width);
 494 #endif
 495             x = fwin->left_button->width;
 496             w -= fwin->left_button->width;
 497         }
 498 #ifdef XKB_BUTTON_HINT
 499         if (fwin->flags.hide_language_button || !fwin->language_button
 500             || fwin->flags.languagebutton_dont_fit) {
 501     } else {
 502             x += fwin->language_button->width;
 503             w -= fwin->language_button->width;
 504     }
 505 #endif
 506     }
 507 #ifdef XKB_BUTTON_HINT
 508     else {
 509         int bsize = theight - 7;
 510         if (fwin->flags.hide_left_button || !fwin->left_button
 511             || fwin->flags.lbutton_dont_fit) {
 512             if(fwin->language_button)
 513                 wCoreConfigure(fwin->language_button, 3, (theight-bsize)/2,
 514                         fwin->language_button->width,
 515                         fwin->language_button->width);
 516         }
 517         else {
 518             if(fwin->language_button)
 519                 wCoreConfigure(fwin->language_button,
 520                         6 + fwin->left_button->width, (theight-bsize)/2,
 521                         fwin->language_button->width,
 522                         fwin->language_button->width);
 523         }
 524     }
 525 #endif
 526
 527     if (wPreferences.new_style) {
 528         if (!fwin->flags.hide_right_button && fwin->right_button
 529             && !fwin->flags.rbutton_dont_fit) {
 530             w -= fwin->right_button->width;
 531         }
 532     }
 533
 534     if (wPreferences.new_style || fwin->titlebar->width!=w)
 535         fwin->flags.need_texture_remake = 1;
 536
 537     wCoreConfigure(fwin->titlebar, x, 0, w, theight);
 538 }
 539
 540
 541 void
 542 wFrameWindowHideButton(WFrameWindow *fwin, int flags)
 543 {
 544     if ((flags & WFF_RIGHT_BUTTON) && fwin->right_button) {
 545         XUnmapWindow(dpy, fwin->right_button->window);
 546         fwin->flags.hide_right_button = 1;
 547     }
 548
 549     if ((flags & WFF_LEFT_BUTTON) && fwin->left_button) {
 550         XUnmapWindow(dpy, fwin->left_button->window);
 551         fwin->flags.hide_left_button = 1;
 552     }
 553
 554 #ifdef XKB_BUTTON_HINT
 555     if ((flags & WFF_LANGUAGE_BUTTON) && fwin->language_button) {
 556         XUnmapWindow(dpy, fwin->language_button->window);
 557     fwin->flags.hide_language_button = 1;
 558     }
 559 #endif
 560
 561     if (fwin->titlebar) {
 562         if (wPreferences.new_style) {
 563             updateTitlebar(fwin);
 564         } else {
 565 #ifdef XKB_BUTTON_HINT
 566             updateTitlebar(fwin);
 567 #else
 568             XClearWindow(dpy, fwin->titlebar->window);
 569             wFrameWindowPaint(fwin);
 570 #endif
 571         }
 572         checkTitleSize(fwin);
 573     }
 574 }
 575
 576
 577 void
 578 wFrameWindowShowButton(WFrameWindow *fwin, int flags)
 579 {
 580     if ((flags & WFF_RIGHT_BUTTON) && fwin->right_button
 581         && fwin->flags.hide_right_button) {
 582
 583         if (!fwin->flags.rbutton_dont_fit)
 584             XMapWindow(dpy, fwin->right_button->window);
 585
 586         fwin->flags.hide_right_button = 0;
 587     }
 588
 589 #ifdef XKB_BUTTON_HINT
 590     if ((flags & WFF_LANGUAGE_BUTTON) && fwin->language_button
 591         && fwin->flags.hide_language_button) {
 592
 593         if (!fwin->flags.languagebutton_dont_fit)
 594             XMapWindow(dpy, fwin->language_button->window);
 595
 596         fwin->flags.hide_language_button = 0;
 597     }
 598 #endif
 599
 600     if ((flags & WFF_LEFT_BUTTON) && fwin->left_button
 601         && fwin->flags.hide_left_button) {
 602
 603         if (!fwin->flags.lbutton_dont_fit)
 604             XMapWindow(dpy, fwin->left_button->window);
 605
 606         fwin->flags.hide_left_button = 0;
 607     }
 608
 609
 610     if (fwin->titlebar) {
 611         if (wPreferences.new_style) {
 612             updateTitlebar(fwin);
 613         } else {
 614             XClearWindow(dpy, fwin->titlebar->window);
 615             wFrameWindowPaint(fwin);
 616         }
 617         checkTitleSize(fwin);
 618     }
 619 }
 620
 621
 622 static void
 623 #ifdef XKB_BUTTON_HINT
 624 renderTexture(WScreen *scr, WTexture *texture, int width, int height,
 625               int bwidth, int bheight, int left, int language, int right,
 626               Pixmap *title, Pixmap *lbutton, Pixmap *languagebutton, Pixmap *rbutton)
 627 #else
 628 renderTexture(WScreen *scr, WTexture *texture, int width, int height,
 629               int bwidth, int bheight, int left, int right,
 630               Pixmap *title, Pixmap *lbutton, Pixmap *rbutton)
 631 #endif
 632 {
 633     RImage *img;
 634     RImage *limg, *rimg, *mimg;
 635 #ifdef XKB_BUTTON_HINT
 636     RImage *timg;
 637 #endif
 638     int x, w;
 639
 640     *title = None;
 641     *lbutton = None;
 642     *rbutton = None;
 643 #ifdef XKB_BUTTON_HINT
 644     *languagebutton = None;
 645 #endif
 646
 647     img = wTextureRenderImage(texture, width, height, WREL_FLAT);
 648     if (!img) {
 649         wwarning(_("could not render texture: %s"), RMessageForError(RErrorCode));
 650         return;
 651     }
 652
 653     if (wPreferences.new_style) {
 654         if (left) {
 655             limg = RGetSubImage(img, 0, 0, bwidth, bheight);
 656         } else
 657             limg = NULL;
 658
 659         x = 0;
 660         w = img->width;
 661
 662 #ifdef XKB_BUTTON_HINT
 663     if (language) {
 664             timg = RGetSubImage(img, bwidth * left, 0, bwidth, bheight);
 665         } else
 666             timg = NULL;
 667 #endif
 668
 669         if (limg) {
 670             RBevelImage(limg, RBEV_RAISED2);
 671             if (!RConvertImage(scr->rcontext, limg, lbutton)) {
 672                 wwarning(_("error rendering image:%s"), RMessageForError(RErrorCode));
 673             }
 674             x += limg->width;
 675             w -= limg->width;
 676             RDestroyImage(limg);
 677         }
 678
 679 #ifdef XKB_BUTTON_HINT
 680     if (timg) {
 681             RBevelImage(timg, RBEV_RAISED2);
 682             if (!RConvertImage(scr->rcontext, timg, languagebutton)) {
 683                 wwarning(_("error rendering image:%s"), RMessageForError(RErrorCode));
 684             }
 685             x += timg->width;
 686             w -= timg->width;
 687             RDestroyImage(timg);
 688     }
 689 #endif
 690
 691         if (right) {
 692             rimg = RGetSubImage(img, width - bwidth, 0, bwidth, bheight);
 693         } else
 694             rimg = NULL;
 695
 696         if (rimg) {
 697             RBevelImage(rimg, RBEV_RAISED2);
 698             if (!RConvertImage(scr->rcontext, rimg, rbutton)) {
 699                 wwarning(_("error rendering image:%s"), RMessageForError(RErrorCode));
 700             }
 701             w -= rimg->width;
 702             RDestroyImage(rimg);
 703         }
 704
 705         if (w!=width) {
 706             mimg = RGetSubImage(img, x, 0, w, img->height);
 707             RBevelImage(mimg, RBEV_RAISED2);
 708
 709             if (!RConvertImage(scr->rcontext, mimg, title)) {
 710                 wwarning(_("error rendering image:%s"), RMessageForError(RErrorCode));
 711             }
 712             RDestroyImage(mimg);
 713         } else {
 714             RBevelImage(img, RBEV_RAISED2);
 715
 716             if (!RConvertImage(scr->rcontext, img, title)) {
 717                 wwarning(_("error rendering image:%s"), RMessageForError(RErrorCode));
 718             }
 719         }
 720     } else {
 721         RBevelImage(img, RBEV_RAISED2);
 722
 723         if (!RConvertImage(scr->rcontext, img, title)) {
 724             wwarning(_("error rendering image:%s"), RMessageForError(RErrorCode));
 725         }
 726     }
 727
 728     RDestroyImage(img);
 729 }
 730
 731
 732 static void
 733 renderResizebarTexture(WScreen *scr, WTexture *texture, int width, int height,
 734                        int cwidth, Pixmap *pmap)
 735 {
 736     RImage *img;
 737     RColor light;
 738     RColor dark;
 739
 740     *pmap = None;
 741
 742     img = wTextureRenderImage(texture, width, height, WREL_FLAT);
 743     if (!img) {
 744         wwarning(_("could not render texture: %s"),
 745                  RMessageForError(RErrorCode));
 746         return;
 747     }
 748
 749     light.alpha = 0;
 750     light.red = light.green = light.blue = 80;
 751
 752     dark.alpha = 0;
 753     dark.red = dark.green = dark.blue = 40;
 754
 755     ROperateLine(img, RSubtractOperation, 0, 0, width-1, 0, &dark);
 756     ROperateLine(img, RAddOperation, 0, 1, width-1, 1, &light);
 757
 758     ROperateLine(img, RSubtractOperation, cwidth, 2, cwidth, height-1, &dark);
 759     ROperateLine(img, RAddOperation, cwidth+1, 2, cwidth+1, height-1, &light);
 760
 761     if (width > 1)
 762         ROperateLine(img, RSubtractOperation, width-cwidth-2, 2,
 763                      width-cwidth-2, height-1, &dark);
 764     ROperateLine(img, RAddOperation, width-cwidth-1, 2, width-cwidth-1,
 765                  height-1, &light);
 766
 767 #ifdef SHADOW_RESIZEBAR
 768     ROperateLine(img, RAddOperation, 0, 1, 0, height-1, &light);
 769     ROperateLine(img, RSubtractOperation, width-1, 1, width-1, height-1,
 770                  &dark);
 771     ROperateLine(img, RSubtractOperation, 0, height-1, width-1, height-1,
 772                  &dark);
 773 #endif /* SHADOW_RESIZEBAR */
 774
 775
 776     if (!RConvertImage(scr->rcontext, img, pmap)) {
 777         wwarning(_("error rendering image: %s"), RMessageForError(RErrorCode));
 778     }
 779
 780     RDestroyImage(img);
 781 }
 782
 783
 784
 785 static void
 786 updateTexture(WFrameWindow *fwin)
 787 {
 788     int i;
 789     unsigned long pixel;
 790
 791     i = fwin->flags.state;
 792     if (fwin->titlebar) {
 793         if (fwin->title_texture[i]->any.type!=WTEX_SOLID) {
 794             XSetWindowBackgroundPixmap(dpy, fwin->titlebar->window,
 795                                        fwin->title_back[i]);
 796             if (wPreferences.new_style) {
 797                 if (fwin->left_button && fwin->lbutton_back[i])
 798                     XSetWindowBackgroundPixmap(dpy, fwin->left_button->window,
 799                                                fwin->lbutton_back[i]);
 800
 801 #ifdef XKB_BUTTON_HINT
 802                 if (fwin->language_button && fwin->languagebutton_back[i]) {
 803                     XSetWindowBackgroundPixmap(dpy, fwin->language_button->window,
 804                                                fwin->languagebutton_back[i]);
 805         }
 806 #endif
 807
 808                 if (fwin->right_button && fwin->rbutton_back[i])
 809                     XSetWindowBackgroundPixmap(dpy, fwin->right_button->window,
 810                                                fwin->rbutton_back[i]);
 811             }
 812         } else {
 813             pixel = fwin->title_texture[i]->solid.normal.pixel;
 814             XSetWindowBackground(dpy, fwin->titlebar->window, pixel);
 815             if (wPreferences.new_style) {
 816                 if (fwin->left_button)
 817                     XSetWindowBackground(dpy, fwin->left_button->window,
 818                                          pixel);
 819 #ifdef XKB_BUTTON_HINT
 820                 if (fwin->language_button)
 821                     XSetWindowBackground(dpy, fwin->language_button->window,
 822                                          pixel);
 823 #endif
 824                 if (fwin->right_button)
 825                     XSetWindowBackground(dpy, fwin->right_button->window,
 826                                          pixel);
 827             }
 828         }
 829         XClearWindow(dpy, fwin->titlebar->window);
 830
 831         if (fwin->left_button) {
 832             XClearWindow(dpy, fwin->left_button->window);
 833             handleButtonExpose(&fwin->left_button->descriptor, NULL);
 834         }
 835 #ifdef XKB_BUTTON_HINT
 836        if (fwin->language_button) {
 837            XClearWindow(dpy, fwin->language_button->window);
 838            handleButtonExpose(&fwin->language_button->descriptor, NULL);
 839        }
 840 #endif
 841         if (fwin->right_button) {
 842             XClearWindow(dpy, fwin->right_button->window);
 843             handleButtonExpose(&fwin->right_button->descriptor, NULL);
 844         }
 845     }
 846 }
 847
 848
 849
 850 static void
 851 remakeTexture(WFrameWindow *fwin, int state)
 852 {
 853     Pixmap pmap, lpmap, rpmap;
 854 #ifdef XKB_BUTTON_HINT
 855     Pixmap tpmap;
 856 #endif
 857
 858     if (fwin->title_texture[state] && fwin->titlebar) {
 859         FREE_PIXMAP(fwin->title_back[state]);
 860         if (wPreferences.new_style) {
 861             FREE_PIXMAP(fwin->lbutton_back[state]);
 862             FREE_PIXMAP(fwin->rbutton_back[state]);
 863 #ifdef XKB_BUTTON_HINT
 864             FREE_PIXMAP(fwin->languagebutton_back[state]);
 865 #endif
 866         }
 867
 868         if (fwin->title_texture[state]->any.type!=WTEX_SOLID) {
 869             int left, right;
 870 #ifdef XKB_BUTTON_HINT
 871         int language;
 872 #endif
 873             int width;
 874
 875             /* eventually surrounded by if new_style */
 876             left = fwin->left_button && !fwin->flags.hide_left_button
 877                 && !fwin->flags.lbutton_dont_fit;
 878 #ifdef XKB_BUTTON_HINT
 879             language = fwin->language_button && !fwin->flags.hide_language_button
 880                 && !fwin->flags.languagebutton_dont_fit;
 881 #endif
 882             right = fwin->right_button && !fwin->flags.hide_right_button
 883                 && !fwin->flags.rbutton_dont_fit;
 884
 885             width = fwin->core->width+1;
 886
 887 #ifdef XKB_BUTTON_HINT
 888             renderTexture(fwin->screen_ptr, fwin->title_texture[state],
 889                           width, fwin->titlebar->height,
 890                           fwin->titlebar->height, fwin->titlebar->height,
 891                           left, language, right, &pmap, &lpmap, &tpmap, &rpmap);
 892 #else
 893             renderTexture(fwin->screen_ptr, fwin->title_texture[state],
 894                           width, fwin->titlebar->height,
 895                           fwin->titlebar->height, fwin->titlebar->height,
 896                           left, right, &pmap, &lpmap, &rpmap);
 897 #endif
 898
 899             fwin->title_back[state] = pmap;
 900             if (wPreferences.new_style) {
 901                 fwin->lbutton_back[state] = lpmap;
 902                 fwin->rbutton_back[state] = rpmap;
 903 #ifdef XKB_BUTTON_HINT
 904                 fwin->languagebutton_back[state] = tpmap;
 905 #endif
 906             }
 907         }
 908     }
 909     if (fwin->resizebar_texture && fwin->resizebar_texture[0]
 910         && fwin->resizebar && state == 0) {
 911
 912         FREE_PIXMAP(fwin->resizebar_back[0]);
 913
 914         if (fwin->resizebar_texture[0]->any.type!=WTEX_SOLID) {
 915
 916             renderResizebarTexture(fwin->screen_ptr,
 917                                    fwin->resizebar_texture[0],
 918                                    fwin->resizebar->width,
 919                                    fwin->resizebar->height,
 920                                    fwin->resizebar_corner_width,
 921                                    &pmap);
 922
 923             fwin->resizebar_back[0] = pmap;
 924         }
 925
 926         /* this part should be in updateTexture() */
 927         if (fwin->resizebar_texture[0]->any.type!=WTEX_SOLID) {
 928             XSetWindowBackgroundPixmap(dpy, fwin->resizebar->window,
 929                                        fwin->resizebar_back[0]);
 930         } else {
 931             XSetWindowBackground(dpy, fwin->resizebar->window,
 932                                  fwin->resizebar_texture[0]->solid.normal.pixel);
 933         }
 934         XClearWindow(dpy, fwin->resizebar->window);
 935     }
 936 }
 937
 938
 939 void
 940 wFrameWindowPaint(WFrameWindow *fwin)
 941 {
 942     WScreen *scr = fwin->screen_ptr;
 943
 944     if (fwin->flags.is_client_window_frame)
 945         fwin->flags.justification = wPreferences.title_justification;
 946
 947     if (fwin->flags.need_texture_remake) {
 948         int i;
 949
 950         fwin->flags.need_texture_remake = 0;
 951         fwin->flags.need_texture_change = 0;
 952
 953         if (fwin->flags.single_texture) {
 954             remakeTexture(fwin, 0);
 955             updateTexture(fwin);
 956         } else {
 957             /* first render the texture for the current state... */
 958             remakeTexture(fwin, fwin->flags.state);
 959             /* ... and paint it */
 960             updateTexture(fwin);
 961
 962             for (i=0; i < 3; i++) {
 963                 if (i!=fwin->flags.state)
 964                     remakeTexture(fwin, i);
 965             }
 966         }
 967     }
 968
 969     if (fwin->flags.need_texture_change) {
 970         fwin->flags.need_texture_change = 0;
 971
 972         updateTexture(fwin);
 973     }
 974
 975     if (fwin->titlebar && !fwin->flags.repaint_only_resizebar
 976         && fwin->title_texture[fwin->flags.state]->any.type==WTEX_SOLID) {
 977         wDrawBevel(fwin->titlebar->window, fwin->titlebar->width,
 978                 fwin->titlebar->height,
 979                 (WTexSolid*)fwin->title_texture[fwin->flags.state],
 980                 WREL_RAISED);
 981     }
 982
 983     if (fwin->resizebar && !fwin->flags.repaint_only_titlebar
 984         && fwin->resizebar_texture[0]->any.type == WTEX_SOLID) {
 985         Window win;
 986         int w, h;
 987         int cw;
 988         GC light_gc, dim_gc;
 989         WTexSolid *texture = (WTexSolid*)fwin->resizebar_texture[0];
 990
 991         w = fwin->resizebar->width;
 992         h = fwin->resizebar->height;
 993         cw = fwin->resizebar_corner_width;
 994         light_gc = texture->light_gc;
 995         dim_gc = texture->dim_gc;
 996         win = fwin->resizebar->window;
 997
 998         XDrawLine(dpy, win, dim_gc, 0, 0, w, 0);
 999         XDrawLine(dpy, win, light_gc, 0, 1, w, 1);
1000
1001         XDrawLine(dpy, win, dim_gc, cw, 2, cw, h);
1002         XDrawLine(dpy, win, light_gc, cw+1, 2, cw+1, h);
1003
1004         XDrawLine(dpy, win, dim_gc, w-cw-2, 2, w-cw-2, h);
1005         XDrawLine(dpy, win, light_gc, w-cw-1, 2, w-cw-1, h);
1006
1007 #ifdef SHADOW_RESIZEBAR
1008         XDrawLine(dpy, win, light_gc, 0, 1, 0, h-1);
1009         XDrawLine(dpy, win, dim_gc, w-1, 2, w-1, h-1);
1010         XDrawLine(dpy, win, dim_gc, 1, h-1, cw, h-1);
1011         XDrawLine(dpy, win, dim_gc, cw+2, h-1, w-cw-2, h-1);
1012         XDrawLine(dpy, win, dim_gc, w-cw, h-1, w-1, h-1);
1013 #endif /* SHADOW_RESIZEBAR */
1014     }
1015
1016
1017     if (fwin->title && fwin->titlebar && !fwin->flags.repaint_only_resizebar) {
1018         int x, w;
1019         int lofs = 6, rofs = 6;
1020         int titlelen;
1021         char *title;
1022         int allButtons = 1;
1023
1024
1025         if (!wPreferences.new_style) {
1026             if (fwin->left_button && !fwin->flags.hide_left_button
1027                 && !fwin->flags.lbutton_dont_fit)
1028                 lofs += fwin->left_button->width + 3;
1029             else
1030                 allButtons = 0;
1031
1032 #ifdef XKB_BUTTON_HINT
1033             if (fwin->language_button && !fwin->flags.hide_language_button
1034                 && !fwin->flags.languagebutton_dont_fit)
1035                 lofs += fwin->language_button->width;
1036             else
1037                 allButtons = 0;
1038 #endif
1039
1040             if (fwin->right_button && !fwin->flags.hide_right_button
1041                 && !fwin->flags.rbutton_dont_fit)
1042                 rofs += fwin->right_button->width + 3;
1043             else
1044                 allButtons = 0;
1045         }
1046
1047 #ifdef XKB_BUTTON_HINT
1048         fwin->languagebutton_image =
1049             scr->b_pixmaps[WBUT_XKBGROUP1 + fwin->languagemode];
1050 #endif
1051
1052         title = ShrinkString(*fwin->font, fwin->title,
1053                              fwin->titlebar->width - lofs - rofs);
1054         titlelen = strlen(title);
1055         w = WMWidthOfString(*fwin->font, title, titlelen);
1056
1057         switch (fwin->flags.justification) {
1058          case WTJ_LEFT:
1059             x = lofs;
1060             break;
1061
1062          case WTJ_RIGHT:
1063             x = fwin->titlebar->width - w - rofs;
1064             break;
1065
1066          default:
1067             if (!allButtons)
1068                 x = lofs + (fwin->titlebar->width - w - lofs - rofs) / 2;
1069             else
1070                 x = (fwin->titlebar->width - w) / 2;
1071             break;
1072         }
1073
1074         XSetForeground(dpy, *fwin->title_gc,
1075                        fwin->title_pixel[fwin->flags.state]);
1076
1077     WMDrawString(scr->wmscreen, fwin->titlebar->window,
1078             *fwin->title_gc, *fwin->font, x, *fwin->title_clearance + TITLEBAR_EXTEND_SPACE,
1079             title, titlelen);
1080
1081         wfree(title);
1082
1083         if (fwin->left_button)
1084             handleButtonExpose(&fwin->left_button->descriptor, NULL);
1085         if (fwin->right_button)
1086             handleButtonExpose(&fwin->right_button->descriptor, NULL);
1087 #ifdef XKB_BUTTON_HINT
1088         if (fwin->language_button)
1089             handleButtonExpose(&fwin->language_button->descriptor, NULL);
1090 #endif
1091     }
1092 }
1093
1094
1095 static void
1096 reconfigure(WFrameWindow *fwin, int x, int y, int width, int height,
1097             Bool dontMove)
1098 {
1099     int k = (wPreferences.new_style ? 4 : 3);
1100     int resizedHorizontally = 0;
1101
1102     if (dontMove)
1103         XResizeWindow(dpy, fwin->core->window, width, height);
1104     else
1105         XMoveResizeWindow(dpy, fwin->core->window, x, y, width, height);
1106
1107     /*
1108      if (fwin->core->height != height && fwin->resizebar)
1109      XMoveWindow(dpy, fwin->resizebar->window, 0,
1110                  height - fwin->resizebar->height);
1111      */
1112     if (fwin->core->width != width) {
1113         fwin->flags.need_texture_remake = 1;
1114         resizedHorizontally = 1;
1115     }
1116
1117     fwin->core->width = width;
1118     fwin->core->height = height;
1119
1120     if (fwin->titlebar && resizedHorizontally) {
1121         /* Check if the titlebar is wide enough to hold the buttons.
1122          * Temporarily remove them if can't
1123          */
1124         if (fwin->left_button) {
1125             if (width < fwin->top_width*k && !fwin->flags.lbutton_dont_fit) {
1126
1127                 if (!fwin->flags.hide_left_button) {
1128                     XUnmapWindow(dpy, fwin->left_button->window);
1129                 }
1130                 fwin->flags.lbutton_dont_fit = 1;
1131             } else if (width >= fwin->top_width*k && fwin->flags.lbutton_dont_fit) {
1132
1133                 if (!fwin->flags.hide_left_button) {
1134                     XMapWindow(dpy, fwin->left_button->window);
1135                 }
1136                 fwin->flags.lbutton_dont_fit = 0;
1137             }
1138         }
1139
1140 #ifdef XKB_BUTTON_HINT
1141         if (fwin->language_button) {
1142             if (width < fwin->top_width*k && !fwin->flags.languagebutton_dont_fit) {
1143
1144                 if (!fwin->flags.hide_language_button) {
1145                     XUnmapWindow(dpy, fwin->language_button->window);
1146                 }
1147                 fwin->flags.languagebutton_dont_fit = 1;
1148             } else if (width >= fwin->top_width*k && fwin->flags.languagebutton_dont_fit) {
1149
1150                 if (!fwin->flags.hide_language_button) {
1151                     XMapWindow(dpy, fwin->language_button->window);
1152                 }
1153                 fwin->flags.languagebutton_dont_fit = 0;
1154             }
1155         }
1156 #endif
1157
1158         if (fwin->right_button) {
1159             if (width < fwin->top_width*2 && !fwin->flags.rbutton_dont_fit) {
1160
1161                 if (!fwin->flags.hide_right_button) {
1162                     XUnmapWindow(dpy, fwin->right_button->window);
1163                 }
1164                 fwin->flags.rbutton_dont_fit = 1;
1165             } else if (width >= fwin->top_width*2 && fwin->flags.rbutton_dont_fit) {
1166
1167                 if (!fwin->flags.hide_right_button) {
1168                     XMapWindow(dpy, fwin->right_button->window);
1169                 }
1170                 fwin->flags.rbutton_dont_fit = 0;
1171             }
1172         }
1173
1174         if (wPreferences.new_style) {
1175             if (fwin->right_button)
1176                 XMoveWindow(dpy, fwin->right_button->window,
1177                             width - fwin->right_button->width + 1, 0);
1178         } else {
1179             if (fwin->right_button)
1180                 XMoveWindow(dpy, fwin->right_button->window,
1181                             width - fwin->right_button->width - 3,
1182                             (fwin->titlebar->height - fwin->right_button->height)/2);
1183         }
1184         updateTitlebar(fwin);
1185         checkTitleSize(fwin);
1186     }
1187
1188     if (fwin->resizebar) {
1189         wCoreConfigure(fwin->resizebar, 0,
1190                        fwin->core->height - fwin->resizebar->height,
1191                        fwin->core->width, fwin->resizebar->height);
1192
1193         fwin->resizebar_corner_width = RESIZEBAR_CORNER_WIDTH;
1194         if (fwin->core->width < RESIZEBAR_CORNER_WIDTH*2 + RESIZEBAR_MIN_WIDTH) {
1195             fwin->resizebar_corner_width = fwin->core->width/2;
1196         }
1197     }
1198 }
1199
1200 void
1201 wFrameWindowConfigure(WFrameWindow *fwin, int x, int y, int width, int height)
1202 {
1203     reconfigure(fwin, x, y, width, height, False);
1204 }
1205
1206 void
1207 wFrameWindowResize(WFrameWindow *fwin, int width, int height)
1208 {
1209     reconfigure(fwin, 0, 0, width, height, True);
1210 }
1211
1212
1213
1214 int
1215 wFrameWindowChangeTitle(WFrameWindow *fwin, char *new_title)
1216 {
1217     /* check if the title is the same as before */
1218     if (fwin->title) {
1219         if (new_title && (strcmp(fwin->title, new_title) == 0)) {
1220             return 0;
1221         }
1222     } else {
1223         if (!new_title)
1224            return 0;
1225     }
1226
1227     if (fwin->title)
1228         wfree(fwin->title);
1229
1230     fwin->title = wstrdup(new_title);
1231
1232     if (fwin->titlebar) {
1233         XClearWindow(dpy, fwin->titlebar->window);
1234
1235         wFrameWindowPaint(fwin);
1236     }
1237     checkTitleSize(fwin);
1238
1239     return 1;
1240 }
1241
1242
1243 #ifdef OLWM_HINTS
1244 void
1245 wFrameWindowUpdatePushButton(WFrameWindow *fwin, Bool pushed)
1246 {
1247     fwin->flags.right_button_pushed_in = pushed;
1248
1249     paintButton(fwin->right_button, fwin->title_texture[fwin->flags.state],
1250                 fwin->title_pixel[fwin->flags.state],
1251                 fwin->rbutton_image, pushed);
1252 }
1253 #endif /* OLWM_HINTS */
1254
1255
1256 #ifdef XKB_BUTTON_HINT
1257 void
1258 wFrameWindowUpdateLanguageButton(WFrameWindow *fwin)
1259 {
1260     paintButton(fwin->language_button, fwin->title_texture[fwin->flags.state],
1261                 fwin->title_pixel[fwin->flags.state],
1262                 fwin->languagebutton_image, True);
1263 }
1264 #endif /* XKB_BUTTON_HINT */
1265
1266
1267 /*********************************************************************/
1268
1269 static void
1270 handleExpose(WObjDescriptor *desc, XEvent *event)
1271 {
1272     WFrameWindow *fwin = (WFrameWindow*)desc->parent;
1273
1274
1275     if (fwin->titlebar && fwin->titlebar->window == event->xexpose.window)
1276         fwin->flags.repaint_only_titlebar = 1;
1277     if (fwin->resizebar && fwin->resizebar->window == event->xexpose.window)
1278         fwin->flags.repaint_only_resizebar = 1;
1279     wFrameWindowPaint(fwin);
1280     fwin->flags.repaint_only_titlebar = 0;
1281     fwin->flags.repaint_only_resizebar = 0;
1282 }
1283
1284
1285 static void
1286 checkTitleSize(WFrameWindow *fwin)
1287 {
1288     int width;
1289
1290     if (!fwin->title) {
1291         fwin->flags.incomplete_title = 0;
1292         return;
1293     }
1294
1295     if (!fwin->titlebar) {
1296         fwin->flags.incomplete_title = 1;
1297         return;
1298     } else {
1299         width = fwin->titlebar->width - 6 - 6;
1300     }
1301
1302     if (!wPreferences.new_style) {
1303         if (fwin->left_button && !fwin->flags.hide_left_button
1304             && !fwin->flags.lbutton_dont_fit)
1305             width -= fwin->left_button->width + 3;
1306
1307 #ifdef XKB_BUTTON_HINT
1308         if (fwin->language_button && !fwin->flags.hide_language_button
1309             && !fwin->flags.languagebutton_dont_fit)
1310             width -= fwin->language_button->width + 3;
1311 #endif
1312
1313         if (fwin->right_button && !fwin->flags.hide_right_button
1314             && !fwin->flags.rbutton_dont_fit)
1315             width -= fwin->right_button->width + 3;
1316     }
1317     if (WMWidthOfString(*fwin->font, fwin->title, strlen(fwin->title)) > width) {
1318         fwin->flags.incomplete_title = 1;
1319     } else {
1320         fwin->flags.incomplete_title = 0;
1321     }
1322 }
1323
1324
1325 static void
1326 paintButton(WCoreWindow *button, WTexture *texture, unsigned long color,
1327             WPixmap *image, int pushed)
1328 {
1329     WScreen *scr = button->screen_ptr;
1330     GC copy_gc = scr->copy_gc;
1331     int x=0, y=0, d=0;
1332     int left=0, width=0;
1333
1334     /* setup stuff according to the state */
1335     if (pushed) {
1336         if (image) {
1337             if (image->width>=image->height*2) {
1338                 /* the image contains 2 pictures: the second is for the
1339                  * pushed state */
1340                 width = image->width/2;
1341                 left = image->width/2;
1342             } else {
1343                 width = image->width;
1344             }
1345         }
1346         XSetClipMask(dpy, copy_gc, None);
1347         XSetForeground(dpy, copy_gc, scr->white_pixel);
1348         d=1;
1349         if (wPreferences.new_style) {
1350             XFillRectangle(dpy, button->window, copy_gc, 0, 0,
1351                            button->width-1, button->height-1);
1352             XSetForeground(dpy, copy_gc, scr->black_pixel);
1353             XDrawRectangle(dpy, button->window, copy_gc, 0, 0,
1354                            button->width-1, button->height-1);
1355         } else {
1356             XFillRectangle(dpy, button->window, copy_gc, 0, 0,
1357                            button->width, button->height);
1358             XSetForeground(dpy, copy_gc, scr->black_pixel);
1359             XDrawRectangle(dpy, button->window, copy_gc, 0, 0,
1360                            button->width, button->height);
1361         }
1362     } else {
1363         XClearWindow(dpy, button->window);
1364
1365         if (image) {
1366             if (image->width>=image->height*2)
1367                 width = image->width/2;
1368             else
1369                 width = image->width;
1370         }
1371         d=0;
1372
1373         if (wPreferences.new_style) {
1374             if (texture->any.type==WTEX_SOLID || pushed) {
1375                 wDrawBevel(button->window, button->width, button->height,
1376                            (WTexSolid*)texture, WREL_RAISED);
1377             }
1378         } else {
1379             wDrawBevel(button->window, button->width, button->height,
1380                        scr->widget_texture, WREL_RAISED);
1381         }
1382     }
1383
1384     if (image) {
1385         /* display image */
1386         XSetClipMask(dpy, copy_gc, image->mask);
1387         x = (button->width - width)/2 + d;
1388         y = (button->height - image->height)/2 + d;
1389         XSetClipOrigin(dpy, copy_gc, x-left, y);
1390         if (!wPreferences.new_style) {
1391             XSetForeground(dpy, copy_gc, scr->black_pixel);
1392             if (!pushed) {
1393                 if (image->depth==1)
1394                     XCopyPlane(dpy, image->image, button->window, copy_gc,
1395                                left, 0, width, image->height, x, y, 1);
1396                 else
1397                     XCopyArea(dpy, image->image, button->window, copy_gc,
1398                               left, 0, width, image->height, x, y);
1399             } else {
1400                 XSetForeground(dpy, copy_gc, scr->dark_pixel);
1401                 XFillRectangle(dpy, button->window, copy_gc, 0, 0,
1402                                button->width, button->height);
1403             }
1404         } else {
1405             if (pushed) {
1406                 XSetForeground(dpy, copy_gc, scr->black_pixel);
1407             } else {
1408                 XSetForeground(dpy, copy_gc, color);
1409                 XSetBackground(dpy, copy_gc, texture->any.color.pixel);
1410             }
1411             XFillRectangle(dpy, button->window, copy_gc, 0, 0,
1412                            button->width, button->height);
1413         }
1414     }
1415 }
1416
1417
1418 static void
1419 handleButtonExpose(WObjDescriptor *desc, XEvent *event)
1420 {
1421     WFrameWindow *fwin = (WFrameWindow*)desc->parent;
1422     WCoreWindow *button = (WCoreWindow*)desc->self;
1423
1424 #ifdef XKB_BUTTON_HINT
1425     if (button == fwin->language_button) {
1426         if (wPreferences.modelock){
1427             paintButton(button, fwin->title_texture[fwin->flags.state],
1428                     fwin->title_pixel[fwin->flags.state],
1429                     fwin->languagebutton_image, False);
1430         }
1431     } else
1432 #endif
1433     if (button == fwin->left_button) {
1434         paintButton(button, fwin->title_texture[fwin->flags.state],
1435                 fwin->title_pixel[fwin->flags.state],
1436                 fwin->lbutton_image, False);
1437     } else {
1438         Bool pushed = False;
1439
1440 #ifdef OLWM_HINTS
1441         if (fwin->flags.right_button_pushed_in)
1442             pushed = True;
1443 #endif
1444         /* emulate the olwm pushpin in the "out" state */
1445         paintButton(button, fwin->title_texture[fwin->flags.state],
1446                     fwin->title_pixel[fwin->flags.state],
1447                     fwin->rbutton_image, pushed);
1448     }
1449 }
1450
1451
1452 static void
1453 titlebarMouseDown(WObjDescriptor *desc, XEvent *event)
1454 {
1455     WFrameWindow *fwin = desc->parent;
1456     WCoreWindow *titlebar = desc->self;
1457
1458     if (IsDoubleClick(fwin->core->screen_ptr, event)) {
1459         if (fwin->on_dblclick_titlebar)
1460             (*fwin->on_dblclick_titlebar)(titlebar, fwin->child, event);
1461     } else {
1462         if (fwin->on_mousedown_titlebar)
1463             (*fwin->on_mousedown_titlebar)(titlebar, fwin->child, event);
1464     }
1465 }
1466
1467
1468 static void
1469 resizebarMouseDown(WObjDescriptor *desc, XEvent *event)
1470 {
1471     WFrameWindow *fwin = desc->parent;
1472     WCoreWindow *resizebar = desc->self;
1473
1474     if (fwin->on_mousedown_resizebar)
1475         (*fwin->on_mousedown_resizebar)(resizebar, fwin->child, event);
1476 }
1477
1478
1479 static void
1480 buttonMouseDown(WObjDescriptor *desc, XEvent *event)
1481 {
1482     WFrameWindow *fwin = desc->parent;
1483     WCoreWindow *button = desc->self;
1484     WPixmap *image;
1485     XEvent ev;
1486     int done=0, execute=1;
1487     WTexture *texture;
1488     unsigned long pixel;
1489     int clickButton = event->xbutton.button;
1490
1491     if (IsDoubleClick(fwin->core->screen_ptr, event)) {
1492         if (button == fwin->right_button && fwin->on_dblclick_right) {
1493             (*fwin->on_dblclick_right)(button, fwin->child, event);
1494         }
1495         return;
1496     }
1497
1498     if (button == fwin->left_button) {
1499         image = fwin->lbutton_image;
1500     } else {
1501         image = fwin->rbutton_image;
1502     }
1503 #ifdef XKB_BUTTON_HINT
1504     if (button == fwin->language_button) {
1505     if (!wPreferences.modelock) return;
1506         image = fwin->languagebutton_image;
1507     }
1508 #endif
1509
1510     pixel = fwin->title_pixel[fwin->flags.state];
1511     texture = fwin->title_texture[fwin->flags.state];
1512     paintButton(button, texture, pixel, image, True);
1513
1514     while (!done) {
1515         WMMaskEvent(dpy, LeaveWindowMask|EnterWindowMask|ButtonReleaseMask
1516                     |ButtonPressMask|ExposureMask, &ev);
1517         switch (ev.type) {
1518          case LeaveNotify:
1519             execute = 0;
1520             paintButton(button, texture, pixel, image, False);
1521             break;
1522
1523          case EnterNotify:
1524             execute = 1;
1525             paintButton(button, texture, pixel, image, True);
1526             break;
1527
1528          case ButtonPress:
1529             break;
1530
1531          case ButtonRelease:
1532             if (ev.xbutton.button == clickButton)
1533                 done = 1;
1534             break;
1535
1536          default:
1537             WMHandleEvent(&ev);
1538         }
1539     }
1540     paintButton(button, texture, pixel, image, False);
1541
1542     if (execute) {
1543         if (button == fwin->left_button) {
1544             if (fwin->on_click_left)
1545                 (*fwin->on_click_left)(button, fwin->child, &ev);
1546         } else if (button == fwin->right_button) {
1547             if (fwin->on_click_right)
1548                 (*fwin->on_click_right)(button, fwin->child, &ev);
1549         }
1550 #ifdef XKB_BUTTON_HINT
1551         else if (button == fwin->language_button) {
1552             if (fwin->on_click_language)
1553                 (*fwin->on_click_language)(button, fwin->child, &ev);
1554         }
1555 #endif
1556
1557     }
1558 }
1559