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             RReleaseImage(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             RReleaseImage(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             RReleaseImage(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             RReleaseImage(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     RReleaseImage(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     RReleaseImage(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->titlebar && !fwin->flags.repaint_only_resizebar) {
1018         int x, w;
1019         int lofs = 6, rofs = 6;
1020         int titlelen;
1021         int allButtons = 1;
1022
1023
1024         if (!wPreferences.new_style) {
1025             if (fwin->left_button && !fwin->flags.hide_left_button
1026                 && !fwin->flags.lbutton_dont_fit)
1027                 lofs += fwin->left_button->width + 3;
1028             else
1029                 allButtons = 0;
1030
1031 #ifdef XKB_BUTTON_HINT
1032             if (fwin->language_button && !fwin->flags.hide_language_button
1033                 && !fwin->flags.languagebutton_dont_fit)
1034                 lofs += fwin->language_button->width;
1035             else
1036                 allButtons = 0;
1037 #endif
1038
1039             if (fwin->right_button && !fwin->flags.hide_right_button
1040                 && !fwin->flags.rbutton_dont_fit)
1041                 rofs += fwin->right_button->width + 3;
1042             else
1043                 allButtons = 0;
1044         }
1045
1046 #ifdef XKB_BUTTON_HINT
1047         fwin->languagebutton_image =
1048             scr->b_pixmaps[WBUT_XKBGROUP1 + fwin->languagemode];
1049 #endif
1050
1051         if (fwin->title) {
1052             char *title;
1053
1054             title = ShrinkString(*fwin->font, fwin->title,
1055                                  fwin->titlebar->width - lofs - rofs);
1056             titlelen = strlen(title);
1057             w = WMWidthOfString(*fwin->font, title, titlelen);
1058
1059             switch (fwin->flags.justification) {
1060              case WTJ_LEFT:
1061                 x = lofs;
1062                 break;
1063
1064              case WTJ_RIGHT:
1065                 x = fwin->titlebar->width - w - rofs;
1066                 break;
1067
1068              default:
1069                 if (!allButtons)
1070                     x = lofs + (fwin->titlebar->width - w - lofs - rofs) / 2;
1071                 else
1072                     x = (fwin->titlebar->width - w) / 2;
1073                 break;
1074             }
1075
1076             XSetForeground(dpy, *fwin->title_gc,
1077                            fwin->title_pixel[fwin->flags.state]);
1078
1079             WMDrawString(scr->wmscreen, fwin->titlebar->window,
1080                          *fwin->title_gc, *fwin->font, x, *fwin->title_clearance + TITLEBAR_EXTEND_SPACE,
1081                          title, titlelen);
1082
1083             wfree(title);
1084         }
1085
1086         if (fwin->left_button)
1087             handleButtonExpose(&fwin->left_button->descriptor, NULL);
1088         if (fwin->right_button)
1089             handleButtonExpose(&fwin->right_button->descriptor, NULL);
1090 #ifdef XKB_BUTTON_HINT
1091         if (fwin->language_button)
1092             handleButtonExpose(&fwin->language_button->descriptor, NULL);
1093 #endif
1094     }
1095 }
1096
1097
1098 static void
1099 reconfigure(WFrameWindow *fwin, int x, int y, int width, int height,
1100             Bool dontMove)
1101 {
1102     int k = (wPreferences.new_style ? 4 : 3);
1103     int resizedHorizontally = 0;
1104
1105     if (dontMove)
1106         XResizeWindow(dpy, fwin->core->window, width, height);
1107     else
1108         XMoveResizeWindow(dpy, fwin->core->window, x, y, width, height);
1109
1110     /*
1111      if (fwin->core->height != height && fwin->resizebar)
1112      XMoveWindow(dpy, fwin->resizebar->window, 0,
1113                  height - fwin->resizebar->height);
1114      */
1115     if (fwin->core->width != width) {
1116         fwin->flags.need_texture_remake = 1;
1117         resizedHorizontally = 1;
1118     }
1119
1120     fwin->core->width = width;
1121     fwin->core->height = height;
1122
1123     if (fwin->titlebar && resizedHorizontally) {
1124         /* Check if the titlebar is wide enough to hold the buttons.
1125          * Temporarily remove them if can't
1126          */
1127         if (fwin->left_button) {
1128             if (width < fwin->top_width*k && !fwin->flags.lbutton_dont_fit) {
1129
1130                 if (!fwin->flags.hide_left_button) {
1131                     XUnmapWindow(dpy, fwin->left_button->window);
1132                 }
1133                 fwin->flags.lbutton_dont_fit = 1;
1134             } else if (width >= fwin->top_width*k && fwin->flags.lbutton_dont_fit) {
1135
1136                 if (!fwin->flags.hide_left_button) {
1137                     XMapWindow(dpy, fwin->left_button->window);
1138                 }
1139                 fwin->flags.lbutton_dont_fit = 0;
1140             }
1141         }
1142
1143 #ifdef XKB_BUTTON_HINT
1144         if (fwin->language_button) {
1145             if (width < fwin->top_width*k && !fwin->flags.languagebutton_dont_fit) {
1146
1147                 if (!fwin->flags.hide_language_button) {
1148                     XUnmapWindow(dpy, fwin->language_button->window);
1149                 }
1150                 fwin->flags.languagebutton_dont_fit = 1;
1151             } else if (width >= fwin->top_width*k && fwin->flags.languagebutton_dont_fit) {
1152
1153                 if (!fwin->flags.hide_language_button) {
1154                     XMapWindow(dpy, fwin->language_button->window);
1155                 }
1156                 fwin->flags.languagebutton_dont_fit = 0;
1157             }
1158         }
1159 #endif
1160
1161         if (fwin->right_button) {
1162             if (width < fwin->top_width*2 && !fwin->flags.rbutton_dont_fit) {
1163
1164                 if (!fwin->flags.hide_right_button) {
1165                     XUnmapWindow(dpy, fwin->right_button->window);
1166                 }
1167                 fwin->flags.rbutton_dont_fit = 1;
1168             } else if (width >= fwin->top_width*2 && fwin->flags.rbutton_dont_fit) {
1169
1170                 if (!fwin->flags.hide_right_button) {
1171                     XMapWindow(dpy, fwin->right_button->window);
1172                 }
1173                 fwin->flags.rbutton_dont_fit = 0;
1174             }
1175         }
1176
1177         if (wPreferences.new_style) {
1178             if (fwin->right_button)
1179                 XMoveWindow(dpy, fwin->right_button->window,
1180                             width - fwin->right_button->width + 1, 0);
1181         } else {
1182             if (fwin->right_button)
1183                 XMoveWindow(dpy, fwin->right_button->window,
1184                             width - fwin->right_button->width - 3,
1185                             (fwin->titlebar->height - fwin->right_button->height)/2);
1186         }
1187         updateTitlebar(fwin);
1188         checkTitleSize(fwin);
1189     }
1190
1191     if (fwin->resizebar) {
1192         wCoreConfigure(fwin->resizebar, 0,
1193                        fwin->core->height - fwin->resizebar->height,
1194                        fwin->core->width, fwin->resizebar->height);
1195
1196         fwin->resizebar_corner_width = RESIZEBAR_CORNER_WIDTH;
1197         if (fwin->core->width < RESIZEBAR_CORNER_WIDTH*2 + RESIZEBAR_MIN_WIDTH) {
1198             fwin->resizebar_corner_width = fwin->core->width/2;
1199         }
1200     }
1201 }
1202
1203 void
1204 wFrameWindowConfigure(WFrameWindow *fwin, int x, int y, int width, int height)
1205 {
1206     reconfigure(fwin, x, y, width, height, False);
1207 }
1208
1209 void
1210 wFrameWindowResize(WFrameWindow *fwin, int width, int height)
1211 {
1212     reconfigure(fwin, 0, 0, width, height, True);
1213 }
1214
1215
1216
1217 int
1218 wFrameWindowChangeTitle(WFrameWindow *fwin, char *new_title)
1219 {
1220     /* check if the title is the same as before */
1221     if (fwin->title) {
1222         if (new_title && (strcmp(fwin->title, new_title) == 0)) {
1223             return 0;
1224         }
1225     } else {
1226         if (!new_title)
1227            return 0;
1228     }
1229
1230     if (fwin->title)
1231         wfree(fwin->title);
1232
1233     fwin->title = wstrdup(new_title);
1234
1235     if (fwin->titlebar) {
1236         XClearWindow(dpy, fwin->titlebar->window);
1237
1238         wFrameWindowPaint(fwin);
1239     }
1240     checkTitleSize(fwin);
1241
1242     return 1;
1243 }
1244
1245
1246 #ifdef OLWM_HINTS
1247 void
1248 wFrameWindowUpdatePushButton(WFrameWindow *fwin, Bool pushed)
1249 {
1250     fwin->flags.right_button_pushed_in = pushed;
1251
1252     paintButton(fwin->right_button, fwin->title_texture[fwin->flags.state],
1253                 fwin->title_pixel[fwin->flags.state],
1254                 fwin->rbutton_image, pushed);
1255 }
1256 #endif /* OLWM_HINTS */
1257
1258
1259 #ifdef XKB_BUTTON_HINT
1260 void
1261 wFrameWindowUpdateLanguageButton(WFrameWindow *fwin)
1262 {
1263     paintButton(fwin->language_button, fwin->title_texture[fwin->flags.state],
1264                 fwin->title_pixel[fwin->flags.state],
1265                 fwin->languagebutton_image, True);
1266 }
1267 #endif /* XKB_BUTTON_HINT */
1268
1269
1270 /*********************************************************************/
1271
1272 static void
1273 handleExpose(WObjDescriptor *desc, XEvent *event)
1274 {
1275     WFrameWindow *fwin = (WFrameWindow*)desc->parent;
1276
1277
1278     if (fwin->titlebar && fwin->titlebar->window == event->xexpose.window)
1279         fwin->flags.repaint_only_titlebar = 1;
1280     if (fwin->resizebar && fwin->resizebar->window == event->xexpose.window)
1281         fwin->flags.repaint_only_resizebar = 1;
1282     wFrameWindowPaint(fwin);
1283     fwin->flags.repaint_only_titlebar = 0;
1284     fwin->flags.repaint_only_resizebar = 0;
1285 }
1286
1287
1288 static void
1289 checkTitleSize(WFrameWindow *fwin)
1290 {
1291     int width;
1292
1293     if (!fwin->title) {
1294         fwin->flags.incomplete_title = 0;
1295         return;
1296     }
1297
1298     if (!fwin->titlebar) {
1299         fwin->flags.incomplete_title = 1;
1300         return;
1301     } else {
1302         width = fwin->titlebar->width - 6 - 6;
1303     }
1304
1305     if (!wPreferences.new_style) {
1306         if (fwin->left_button && !fwin->flags.hide_left_button
1307             && !fwin->flags.lbutton_dont_fit)
1308             width -= fwin->left_button->width + 3;
1309
1310 #ifdef XKB_BUTTON_HINT
1311         if (fwin->language_button && !fwin->flags.hide_language_button
1312             && !fwin->flags.languagebutton_dont_fit)
1313             width -= fwin->language_button->width + 3;
1314 #endif
1315
1316         if (fwin->right_button && !fwin->flags.hide_right_button
1317             && !fwin->flags.rbutton_dont_fit)
1318             width -= fwin->right_button->width + 3;
1319     }
1320     if (WMWidthOfString(*fwin->font, fwin->title, strlen(fwin->title)) > width) {
1321         fwin->flags.incomplete_title = 1;
1322     } else {
1323         fwin->flags.incomplete_title = 0;
1324     }
1325 }
1326
1327
1328 static void
1329 paintButton(WCoreWindow *button, WTexture *texture, unsigned long color,
1330             WPixmap *image, int pushed)
1331 {
1332     WScreen *scr = button->screen_ptr;
1333     GC copy_gc = scr->copy_gc;
1334     int x=0, y=0, d=0;
1335     int left=0, width=0;
1336
1337     /* setup stuff according to the state */
1338     if (pushed) {
1339         if (image) {
1340             if (image->width>=image->height*2) {
1341                 /* the image contains 2 pictures: the second is for the
1342                  * pushed state */
1343                 width = image->width/2;
1344                 left = image->width/2;
1345             } else {
1346                 width = image->width;
1347             }
1348         }
1349         XSetClipMask(dpy, copy_gc, None);
1350         XSetForeground(dpy, copy_gc, scr->white_pixel);
1351         d=1;
1352         if (wPreferences.new_style) {
1353             XFillRectangle(dpy, button->window, copy_gc, 0, 0,
1354                            button->width-1, button->height-1);
1355             XSetForeground(dpy, copy_gc, scr->black_pixel);
1356             XDrawRectangle(dpy, button->window, copy_gc, 0, 0,
1357                            button->width-1, button->height-1);
1358         } else {
1359             XFillRectangle(dpy, button->window, copy_gc, 0, 0,
1360                            button->width, button->height);
1361             XSetForeground(dpy, copy_gc, scr->black_pixel);
1362             XDrawRectangle(dpy, button->window, copy_gc, 0, 0,
1363                            button->width, button->height);
1364         }
1365     } else {
1366         XClearWindow(dpy, button->window);
1367
1368         if (image) {
1369             if (image->width>=image->height*2)
1370                 width = image->width/2;
1371             else
1372                 width = image->width;
1373         }
1374         d=0;
1375
1376         if (wPreferences.new_style) {
1377             if (texture->any.type==WTEX_SOLID || pushed) {
1378                 wDrawBevel(button->window, button->width, button->height,
1379                            (WTexSolid*)texture, WREL_RAISED);
1380             }
1381         } else {
1382             wDrawBevel(button->window, button->width, button->height,
1383                        scr->widget_texture, WREL_RAISED);
1384         }
1385     }
1386
1387     if (image) {
1388         /* display image */
1389         XSetClipMask(dpy, copy_gc, image->mask);
1390         x = (button->width - width)/2 + d;
1391         y = (button->height - image->height)/2 + d;
1392         XSetClipOrigin(dpy, copy_gc, x-left, y);
1393         if (!wPreferences.new_style) {
1394             XSetForeground(dpy, copy_gc, scr->black_pixel);
1395             if (!pushed) {
1396                 if (image->depth==1)
1397                     XCopyPlane(dpy, image->image, button->window, copy_gc,
1398                                left, 0, width, image->height, x, y, 1);
1399                 else
1400                     XCopyArea(dpy, image->image, button->window, copy_gc,
1401                               left, 0, width, image->height, x, y);
1402             } else {
1403                 XSetForeground(dpy, copy_gc, scr->dark_pixel);
1404                 XFillRectangle(dpy, button->window, copy_gc, 0, 0,
1405                                button->width, button->height);
1406             }
1407         } else {
1408             if (pushed) {
1409                 XSetForeground(dpy, copy_gc, scr->black_pixel);
1410             } else {
1411                 XSetForeground(dpy, copy_gc, color);
1412                 XSetBackground(dpy, copy_gc, texture->any.color.pixel);
1413             }
1414             XFillRectangle(dpy, button->window, copy_gc, 0, 0,
1415                            button->width, button->height);
1416         }
1417     }
1418 }
1419
1420
1421 static void
1422 handleButtonExpose(WObjDescriptor *desc, XEvent *event)
1423 {
1424     WFrameWindow *fwin = (WFrameWindow*)desc->parent;
1425     WCoreWindow *button = (WCoreWindow*)desc->self;
1426
1427 #ifdef XKB_BUTTON_HINT
1428     if (button == fwin->language_button) {
1429         if (wPreferences.modelock){
1430             paintButton(button, fwin->title_texture[fwin->flags.state],
1431                     fwin->title_pixel[fwin->flags.state],
1432                     fwin->languagebutton_image, False);
1433         }
1434     } else
1435 #endif
1436     if (button == fwin->left_button) {
1437         paintButton(button, fwin->title_texture[fwin->flags.state],
1438                 fwin->title_pixel[fwin->flags.state],
1439                 fwin->lbutton_image, False);
1440     } else {
1441         Bool pushed = False;
1442
1443 #ifdef OLWM_HINTS
1444         if (fwin->flags.right_button_pushed_in)
1445             pushed = True;
1446 #endif
1447         /* emulate the olwm pushpin in the "out" state */
1448         paintButton(button, fwin->title_texture[fwin->flags.state],
1449                     fwin->title_pixel[fwin->flags.state],
1450                     fwin->rbutton_image, pushed);
1451     }
1452 }
1453
1454
1455 static void
1456 titlebarMouseDown(WObjDescriptor *desc, XEvent *event)
1457 {
1458     WFrameWindow *fwin = desc->parent;
1459     WCoreWindow *titlebar = desc->self;
1460
1461     if (IsDoubleClick(fwin->core->screen_ptr, event)) {
1462         if (fwin->on_dblclick_titlebar)
1463             (*fwin->on_dblclick_titlebar)(titlebar, fwin->child, event);
1464     } else {
1465         if (fwin->on_mousedown_titlebar)
1466             (*fwin->on_mousedown_titlebar)(titlebar, fwin->child, event);
1467     }
1468 }
1469
1470
1471 static void
1472 resizebarMouseDown(WObjDescriptor *desc, XEvent *event)
1473 {
1474     WFrameWindow *fwin = desc->parent;
1475     WCoreWindow *resizebar = desc->self;
1476
1477     if (fwin->on_mousedown_resizebar)
1478         (*fwin->on_mousedown_resizebar)(resizebar, fwin->child, event);
1479 }
1480
1481
1482 static void
1483 buttonMouseDown(WObjDescriptor *desc, XEvent *event)
1484 {
1485     WFrameWindow *fwin = desc->parent;
1486     WCoreWindow *button = desc->self;
1487     WPixmap *image;
1488     XEvent ev;
1489     int done=0, execute=1;
1490     WTexture *texture;
1491     unsigned long pixel;
1492     int clickButton = event->xbutton.button;
1493
1494     if (IsDoubleClick(fwin->core->screen_ptr, event)) {
1495         if (button == fwin->right_button && fwin->on_dblclick_right) {
1496             (*fwin->on_dblclick_right)(button, fwin->child, event);
1497         }
1498         return;
1499     }
1500
1501     if (button == fwin->left_button) {
1502         image = fwin->lbutton_image;
1503     } else {
1504         image = fwin->rbutton_image;
1505     }
1506 #ifdef XKB_BUTTON_HINT
1507     if (button == fwin->language_button) {
1508     if (!wPreferences.modelock) return;
1509         image = fwin->languagebutton_image;
1510     }
1511 #endif
1512
1513     pixel = fwin->title_pixel[fwin->flags.state];
1514     texture = fwin->title_texture[fwin->flags.state];
1515     paintButton(button, texture, pixel, image, True);
1516
1517     while (!done) {
1518         WMMaskEvent(dpy, LeaveWindowMask|EnterWindowMask|ButtonReleaseMask
1519                     |ButtonPressMask|ExposureMask, &ev);
1520         switch (ev.type) {
1521          case LeaveNotify:
1522             execute = 0;
1523             paintButton(button, texture, pixel, image, False);
1524             break;
1525
1526          case EnterNotify:
1527             execute = 1;
1528             paintButton(button, texture, pixel, image, True);
1529             break;
1530
1531          case ButtonPress:
1532             break;
1533
1534          case ButtonRelease:
1535             if (ev.xbutton.button == clickButton)
1536                 done = 1;
1537             break;
1538
1539          default:
1540             WMHandleEvent(&ev);
1541         }
1542     }
1543     paintButton(button, texture, pixel, image, False);
1544
1545     if (execute) {
1546         if (button == fwin->left_button) {
1547             if (fwin->on_click_left)
1548                 (*fwin->on_click_left)(button, fwin->child, &ev);
1549         } else if (button == fwin->right_button) {
1550             if (fwin->on_click_right)
1551                 (*fwin->on_click_right)(button, fwin->child, &ev);
1552         }
1553 #ifdef XKB_BUTTON_HINT
1554         else if (button == fwin->language_button) {
1555             if (fwin->on_click_language)
1556                 (*fwin->on_click_language)(button, fwin->child, &ev);
1557         }
1558 #endif
1559
1560     }
1561 }
1562