src/framewin.c

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