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
  27 #include <stdlib.h>
  28 #include <string.h>
  29
  30 #include <wraster.h>
  31
  32 #include "WindowMaker.h"
  33 #include "GNUstep.h"
  34 #include "texture.h"
  35 #include "screen.h"
  36 #include "wcore.h"
  37 #include "framewin.h"
  38 #include "stacking.h"
  39 #include "funcs.h"
  40
  41 #define DBLCLICK_TIME wPreferences.dblclick_time
  42
  43 extern WPreferences wPreferences;
  44
  45 static void handleExpose(WObjDescriptor *desc, XEvent *event);
  46 static void handleButtonExpose(WObjDescriptor *desc, XEvent *event);
  47
  48 static void buttonMouseDown(WObjDescriptor *desc, XEvent *event);
  49 static void titlebarMouseDown(WObjDescriptor *desc, XEvent *event);
  50 static void resizebarMouseDown(WObjDescriptor *desc, XEvent *event);
  51
  52 static void checkTitleSize(WFrameWindow *fwin);
  53
  54
  55 static void paintButton(WCoreWindow *button, WTexture *texture,
  56                         unsigned long color,  WPixmap *image, int pushed);
  57
  58 static void updateTitlebar(WFrameWindow *fwin);
  59
  60
  61 WFrameWindow*
  62 wFrameWindowCreate(WScreen *scr, int wlevel, int x, int y,
  63                    int width, int height, int flags,
  64                    WTexture **title_texture, WTexture **resize_texture,
  65                    unsigned long *color, GC *gc, WFont **font)
  66 {
  67     WFrameWindow *fwin;
  68
  69     fwin = wmalloc(sizeof(WFrameWindow));
  70     memset(fwin, 0, sizeof(WFrameWindow));
  71
  72     fwin->screen_ptr = scr;
  73
  74     fwin->flags.single_texture = (flags & WFF_SINGLE_STATE) ? 1 : 0;
  75
  76     fwin->title_texture = title_texture;
  77     fwin->resizebar_texture = resize_texture;
  78     fwin->title_pixel = color;
  79     fwin->title_gc = gc;
  80     fwin->font = font;
  81
  82     fwin->core = wCoreCreateTopLevel(scr, x, y, width, height,
  83                                      FRAME_BORDER_WIDTH);
  84     if (wPreferences.use_saveunders) {
  85         unsigned long vmask;
  86         XSetWindowAttributes attribs;
  87
  88         vmask = CWSaveUnder;
  89         attribs.save_under = True;
  90         XChangeWindowAttributes(dpy, fwin->core->window, vmask, &attribs);
  91     }
  92
  93     /* setup stacking information */
  94     fwin->core->stacking = wmalloc(sizeof(WStacking));
  95     fwin->core->stacking->above = NULL;
  96     fwin->core->stacking->under = NULL;
  97     fwin->core->stacking->child_of = NULL;
  98     fwin->core->stacking->window_level = wlevel;
  99
 100     AddToStackList(fwin->core);
 101
 102     wFrameWindowUpdateBorders(fwin, flags);
 103
 104     return fwin;
 105 }
 106
 107
 108
 109 void
 110 wFrameWindowUpdateBorders(WFrameWindow *fwin, int flags)
 111 {
 112     int theight;
 113     int bsize;
 114     int width, height;
 115     int i;
 116     WScreen *scr = fwin->screen_ptr;
 117
 118     width = fwin->core->width;
 119     if (flags & WFF_IS_SHADED)
 120         height = -1;
 121     else
 122         height = fwin->core->height - fwin->top_width - fwin->bottom_width;
 123
 124     if (flags & WFF_TITLEBAR)
 125         theight = (*fwin->font)->height + TITLEBAR_EXTRA_HEIGHT;
 126     else
 127         theight = 0;
 128
 129     if (wPreferences.new_style) {
 130         bsize = theight;
 131     } else {
 132         bsize = theight - 7;
 133     }
 134
 135     if (fwin->titlebar) {
 136         /* if we had a titlebar and is requesting for one,
 137          * check if the size has changed and resize it */
 138         if (flags & WFF_TITLEBAR) {
 139             fwin->top_width = theight;
 140
 141             fwin->flags.need_texture_remake = 1;
 142
 143             if (wPreferences.new_style) {
 144                 if (fwin->left_button) {
 145                     wCoreConfigure(fwin->left_button, 0, 0, bsize, bsize);
 146                 }
 147
 148                 if (fwin->right_button) {
 149                     wCoreConfigure(fwin->right_button, width-bsize+1,
 150                                    0, bsize, bsize);
 151                 }
 152             } else { /* !new_style */
 153                 if (fwin->left_button) {
 154                     wCoreConfigure(fwin->left_button, 3, (theight-bsize)/2,
 155                                    bsize, bsize);
 156                 }
 157
 158                 if (fwin->right_button) {
 159                     wCoreConfigure(fwin->right_button, width-bsize-3,
 160                                    (theight-bsize)/2, bsize, bsize);
 161                 }
 162             }
 163             updateTitlebar(fwin);
 164         } else {
 165             /* we had a titlebar, but now we don't need it anymore */
 166             for (i=0; i < (fwin->flags.single_texture ? 1 : 3); i++) {
 167                 FREE_PIXMAP(fwin->title_back[i]);
 168                 if (wPreferences.new_style) {
 169                     FREE_PIXMAP(fwin->lbutton_back[i]);
 170                     FREE_PIXMAP(fwin->rbutton_back[i]);
 171                 }
 172             }
 173             if (fwin->left_button)
 174                 wCoreDestroy(fwin->left_button);
 175             fwin->left_button = NULL;
 176
 177             if (fwin->right_button)
 178                 wCoreDestroy(fwin->right_button);
 179             fwin->right_button = NULL;
 180
 181             wCoreDestroy(fwin->titlebar);
 182             fwin->titlebar = NULL;
 183
 184             fwin->top_width = 0;
 185         }
 186     } else {
 187         /* if we didn't have a titlebar and are being requested for
 188          * one, create it */
 189         if (flags & WFF_TITLEBAR) {
 190             fwin->top_width = theight;
 191
 192             fwin->flags.titlebar = 1;
 193             fwin->titlebar = wCoreCreate(fwin->core, 0, 0, width+1, theight);
 194
 195             if (flags & WFF_LEFT_BUTTON) {
 196                 fwin->flags.left_button = 1;
 197                 if (wPreferences.new_style) {
 198                     fwin->left_button = wCoreCreate(fwin->core, 0, 0,
 199                                                     bsize, bsize);
 200                     if (width < theight*4) {
 201                         fwin->flags.lbutton_dont_fit = 1;
 202                     } else {
 203                         XMapRaised(dpy, fwin->left_button->window);
 204                     }
 205                 } else {
 206                     fwin->left_button =
 207                         wCoreCreate(fwin->titlebar, 3, (theight-bsize)/2,
 208                                     bsize, bsize);
 209
 210                     XSetWindowBackground(dpy, fwin->left_button->window,
 211                                          scr->widget_texture->normal.pixel);
 212
 213                     if (width < theight*3) {
 214                         fwin->flags.lbutton_dont_fit = 1;
 215                     } else {
 216                         XMapRaised(dpy, fwin->left_button->window);
 217                     }
 218                 }
 219             }
 220
 221
 222             if (flags & WFF_RIGHT_BUTTON) {
 223                 fwin->flags.right_button = 1;
 224                 if (wPreferences.new_style) {
 225                     fwin->right_button =
 226                         wCoreCreate(fwin->core, width-bsize+1, 0,
 227                                     bsize, bsize);
 228                 } else {
 229                     fwin->right_button =
 230                         wCoreCreate(fwin->titlebar, width-bsize-3,
 231                                     (theight-bsize)/2, bsize, bsize);
 232                     XSetWindowBackground(dpy, fwin->right_button->window,
 233                                          scr->widget_texture->normal.pixel);
 234                 }
 235
 236                 if (width < theight*2) {
 237                     fwin->flags.rbutton_dont_fit = 1;
 238                 } else {
 239                     XMapRaised(dpy, fwin->right_button->window);
 240                 }
 241             }
 242
 243             if (wPreferences.new_style)
 244                 updateTitlebar(fwin);
 245
 246             XMapRaised(dpy, fwin->titlebar->window);
 247
 248             fwin->flags.need_texture_remake = 1;
 249         }
 250     }
 251     checkTitleSize(fwin);
 252
 253     if (flags & WFF_RESIZEBAR) {
 254         fwin->bottom_width = RESIZEBAR_HEIGHT;
 255     } else {
 256         fwin->bottom_width = 0;
 257     }
 258
 259     if (flags & WFF_RESIZEBAR) {
 260         if (!fwin->resizebar) {
 261             fwin->flags.resizebar = 1;
 262             fwin->resizebar = wCoreCreate(fwin->core, 0,
 263                                           height + fwin->top_width,
 264                                           width, RESIZEBAR_HEIGHT);
 265             fwin->resizebar_corner_width = RESIZEBAR_CORNER_WIDTH;
 266             if (width < RESIZEBAR_CORNER_WIDTH*2 + RESIZEBAR_MIN_WIDTH) {
 267                 fwin->resizebar_corner_width = (width - RESIZEBAR_MIN_WIDTH)/2;
 268                 if (fwin->resizebar_corner_width < 0)
 269                     fwin->resizebar_corner_width = 0;
 270             }
 271
 272             XMapWindow(dpy, fwin->resizebar->window);
 273             XLowerWindow(dpy, fwin->resizebar->window);
 274
 275             fwin->flags.need_texture_remake = 1;
 276         } else {
 277             if (height+fwin->top_width+fwin->bottom_width != fwin->core->height) {
 278                 wCoreConfigure(fwin->resizebar, 0, height + fwin->top_width,
 279                                width, RESIZEBAR_HEIGHT);
 280             }
 281         }
 282     } else {
 283         if (fwin->resizebar) {
 284             fwin->bottom_width = 0;
 285             wCoreDestroy(fwin->resizebar);
 286             fwin->resizebar = NULL;
 287         }
 288     }
 289
 290     if (height + fwin->top_width + fwin->bottom_width != fwin->core->height
 291         && !(flags & WFF_IS_SHADED)) {
 292         wFrameWindowResize(fwin, width,
 293                            height + fwin->top_width + fwin->bottom_width);
 294     }
 295
 296     /* setup object descriptors */
 297
 298     if (fwin->titlebar) {
 299         fwin->titlebar->descriptor.handle_expose = handleExpose;
 300         fwin->titlebar->descriptor.parent = fwin;
 301         fwin->titlebar->descriptor.parent_type = WCLASS_FRAME;
 302         fwin->titlebar->descriptor.handle_mousedown = titlebarMouseDown;
 303     }
 304
 305     if (fwin->resizebar) {
 306         fwin->resizebar->descriptor.handle_expose = handleExpose;
 307         fwin->resizebar->descriptor.parent = fwin;
 308         fwin->resizebar->descriptor.parent_type = WCLASS_FRAME;
 309         fwin->resizebar->descriptor.handle_mousedown = resizebarMouseDown;
 310     }
 311
 312     if (fwin->left_button) {
 313         fwin->left_button->descriptor.handle_expose = handleButtonExpose;
 314         fwin->left_button->descriptor.parent = fwin;
 315         fwin->left_button->descriptor.parent_type = WCLASS_FRAME;
 316         fwin->left_button->descriptor.handle_mousedown = buttonMouseDown;
 317     }
 318
 319     if (fwin->right_button) {
 320         fwin->right_button->descriptor.parent = fwin;
 321         fwin->right_button->descriptor.parent_type = WCLASS_FRAME;
 322         fwin->right_button->descriptor.handle_expose = handleButtonExpose;
 323         fwin->right_button->descriptor.handle_mousedown = buttonMouseDown;
 324     }
 325
 326     checkTitleSize(fwin);
 327 }
 328
 329
 330
 331 void
 332 wFrameWindowDestroy(WFrameWindow *fwin)
 333 {
 334     int i;
 335
 336     if (fwin->left_button)
 337         wCoreDestroy(fwin->left_button);
 338
 339     if (fwin->right_button)
 340         wCoreDestroy(fwin->right_button);
 341
 342     if (fwin->resizebar)
 343         wCoreDestroy(fwin->resizebar);
 344
 345     if (fwin->titlebar)
 346         wCoreDestroy(fwin->titlebar);
 347
 348     RemoveFromStackList(fwin->core);
 349
 350     wCoreDestroy(fwin->core);
 351
 352     if (fwin->title)
 353         free(fwin->title);
 354
 355     for (i=0; i < (fwin->flags.single_texture ? 1 : 3); i++) {
 356         FREE_PIXMAP(fwin->title_back[i]);
 357         if (wPreferences.new_style) {
 358             FREE_PIXMAP(fwin->lbutton_back[i]);
 359             FREE_PIXMAP(fwin->rbutton_back[i]);
 360         }
 361     }
 362
 363     free(fwin);
 364 }
 365
 366
 367 void
 368 wFrameWindowChangeState(WFrameWindow *fwin, int state)
 369 {
 370     if (fwin->flags.state==state)
 371         return;
 372
 373     fwin->flags.state = state;
 374     fwin->flags.need_texture_change = 1;
 375
 376     wFrameWindowPaint(fwin);
 377 }
 378
 379
 380 static void
 381 updateTitlebar(WFrameWindow *fwin)
 382 {
 383     int x, w;
 384     int theight;
 385
 386     theight = (*fwin->font)->height + TITLEBAR_EXTRA_HEIGHT;
 387
 388     x = 0;
 389     w = fwin->core->width + 1;
 390
 391     if (wPreferences.new_style) {
 392         if (fwin->flags.hide_left_button || !fwin->left_button
 393             || fwin->flags.lbutton_dont_fit) {
 394             x = 0;
 395         } else {
 396             x = fwin->left_button->width;
 397             w -= fwin->left_button->width;
 398         }
 399     }
 400
 401     if (wPreferences.new_style) {
 402         if (!fwin->flags.hide_right_button && fwin->right_button
 403             && !fwin->flags.rbutton_dont_fit) {
 404             w -= fwin->right_button->width;
 405         }
 406     }
 407
 408     if (wPreferences.new_style || fwin->titlebar->width!=w)
 409         fwin->flags.need_texture_remake = 1;
 410
 411     wCoreConfigure(fwin->titlebar, x, 0, w, theight);
 412 }
 413
 414
 415 void
 416 wFrameWindowHideButton(WFrameWindow *fwin, int flags)
 417 {
 418     if ((flags & WFF_RIGHT_BUTTON) && fwin->right_button) {
 419         XUnmapWindow(dpy, fwin->right_button->window);
 420         fwin->flags.hide_right_button = 1;
 421     }
 422
 423     if ((flags & WFF_LEFT_BUTTON) && fwin->left_button) {
 424         XUnmapWindow(dpy, fwin->left_button->window);
 425         fwin->flags.hide_left_button = 1;
 426     }
 427
 428     if (fwin->titlebar) {
 429         if (wPreferences.new_style) {
 430             updateTitlebar(fwin);
 431         } else {
 432             XClearWindow(dpy, fwin->titlebar->window);
 433             wFrameWindowPaint(fwin);
 434         }
 435         checkTitleSize(fwin);
 436     }
 437 }
 438
 439
 440 void
 441 wFrameWindowShowButton(WFrameWindow *fwin, int flags)
 442 {
 443     if ((flags & WFF_RIGHT_BUTTON) && fwin->right_button
 444         && fwin->flags.hide_right_button) {
 445
 446         if (!fwin->flags.rbutton_dont_fit)
 447             XMapWindow(dpy, fwin->right_button->window);
 448
 449         fwin->flags.hide_right_button = 0;
 450     }
 451
 452     if ((flags & WFF_LEFT_BUTTON) && fwin->left_button
 453         && fwin->flags.hide_left_button) {
 454
 455         if (!fwin->flags.lbutton_dont_fit)
 456             XMapWindow(dpy, fwin->left_button->window);
 457
 458         fwin->flags.hide_left_button = 0;
 459     }
 460
 461
 462     if (fwin->titlebar) {
 463         if (wPreferences.new_style) {
 464             updateTitlebar(fwin);
 465         } else {
 466             XClearWindow(dpy, fwin->titlebar->window);
 467             wFrameWindowPaint(fwin);
 468         }
 469         checkTitleSize(fwin);
 470     }
 471 }
 472
 473
 474 static void
 475 renderTexture(WScreen *scr, WTexture *texture, int width, int height,
 476               int bwidth, int bheight, int left, int right,
 477               Pixmap *title, Pixmap *lbutton, Pixmap *rbutton)
 478 {
 479     RImage *img;
 480     RImage *limg, *rimg, *mimg;
 481     int x, w;
 482
 483     *title = None;
 484     *lbutton = None;
 485     *rbutton = None;
 486
 487     img = wTextureRenderImage(texture, width, height, WREL_FLAT);
 488     if (!img) {
 489         wwarning(_("could not render gradient: %s"), RMessageForError(RErrorCode));
 490         return;
 491     }
 492
 493     if (wPreferences.new_style) {
 494         if (left) {
 495             limg = RGetSubImage(img, 0, 0, bwidth, bheight);
 496         } else
 497             limg = NULL;
 498
 499         x = 0;
 500         w = img->width;
 501
 502         if (limg) {
 503             RBevelImage(limg, RBEV_RAISED2);
 504             if (!RConvertImage(scr->rcontext, limg, lbutton)) {
 505                 wwarning(_("error rendering image:%s"), RMessageForError(RErrorCode));
 506             }
 507             x += limg->width;
 508             w -= limg->width;
 509             RDestroyImage(limg);
 510         }
 511
 512         if (right) {
 513             rimg = RGetSubImage(img, width - bwidth, 0, bwidth, bheight);
 514         } else
 515             rimg = NULL;
 516
 517         if (rimg) {
 518             RBevelImage(rimg, RBEV_RAISED2);
 519             if (!RConvertImage(scr->rcontext, rimg, rbutton)) {
 520                 wwarning(_("error rendering image:%s"), RMessageForError(RErrorCode));
 521             }
 522             w -= rimg->width;
 523             RDestroyImage(rimg);
 524         }
 525
 526         if (w!=width) {
 527             mimg = RGetSubImage(img, x, 0, w, img->height);
 528             RBevelImage(mimg, RBEV_RAISED2);
 529
 530             if (!RConvertImage(scr->rcontext, mimg, title)) {
 531                 wwarning(_("error rendering image:%s"), RMessageForError(RErrorCode));
 532             }
 533             RDestroyImage(mimg);
 534         } else {
 535             RBevelImage(img, RBEV_RAISED2);
 536
 537             if (!RConvertImage(scr->rcontext, img, title)) {
 538                 wwarning(_("error rendering image:%s"), RMessageForError(RErrorCode));
 539             }
 540         }
 541     } else {
 542         RBevelImage(img, RBEV_RAISED2);
 543
 544         if (!RConvertImage(scr->rcontext, img, title)) {
 545             wwarning(_("error rendering image:%s"), RMessageForError(RErrorCode));
 546         }
 547     }
 548
 549     RDestroyImage(img);
 550 }
 551
 552
 553 static void
 554 updateTexture(WFrameWindow *fwin)
 555 {
 556     int i;
 557     unsigned long pixel;
 558
 559     i = fwin->flags.state;
 560     if (fwin->titlebar) {
 561         if (fwin->title_texture[i]->any.type!=WTEX_SOLID) {
 562             XSetWindowBackgroundPixmap(dpy, fwin->titlebar->window,
 563                                        fwin->title_back[i]);
 564             if (wPreferences.new_style) {
 565                 if (fwin->left_button && fwin->lbutton_back[i])
 566                     XSetWindowBackgroundPixmap(dpy, fwin->left_button->window,
 567                                                fwin->lbutton_back[i]);
 568
 569                 if (fwin->right_button && fwin->rbutton_back[i])
 570                     XSetWindowBackgroundPixmap(dpy, fwin->right_button->window,
 571                                                fwin->rbutton_back[i]);
 572             }
 573         } else {
 574             pixel = fwin->title_texture[i]->solid.normal.pixel;
 575             XSetWindowBackground(dpy, fwin->titlebar->window, pixel);
 576             if (wPreferences.new_style) {
 577                 if (fwin->left_button)
 578                     XSetWindowBackground(dpy, fwin->left_button->window,
 579                                          pixel);
 580                 if (fwin->right_button)
 581                     XSetWindowBackground(dpy, fwin->right_button->window,
 582                                          pixel);
 583             }
 584         }
 585         XClearWindow(dpy, fwin->titlebar->window);
 586
 587         if (fwin->left_button) {
 588             XClearWindow(dpy, fwin->left_button->window);
 589             handleButtonExpose(&fwin->left_button->descriptor, NULL);
 590         }
 591         if (fwin->right_button) {
 592             XClearWindow(dpy, fwin->right_button->window);
 593             handleButtonExpose(&fwin->right_button->descriptor, NULL);
 594         }
 595     }
 596
 597     if (fwin->resizebar) {
 598         XSetWindowBackground(dpy, fwin->resizebar->window,
 599                              fwin->resizebar_texture[0]->solid.normal.pixel);
 600         XClearWindow(dpy, fwin->resizebar->window);
 601     }
 602 }
 603
 604
 605
 606 static void
 607 remakeTexture(WFrameWindow *fwin, int state)
 608 {
 609     Pixmap pmap, lpmap, rpmap;
 610
 611     if (fwin->title_texture[state] && fwin->titlebar) {
 612         FREE_PIXMAP(fwin->title_back[state]);
 613         if (wPreferences.new_style) {
 614             FREE_PIXMAP(fwin->lbutton_back[state]);
 615             FREE_PIXMAP(fwin->rbutton_back[state]);
 616         }
 617
 618         if (fwin->title_texture[state]->any.type!=WTEX_SOLID) {
 619             int left, right;
 620             int width;
 621
 622             /* eventually surrounded by if new_style */
 623             left = fwin->left_button && !fwin->flags.hide_left_button
 624                 && !fwin->flags.lbutton_dont_fit;
 625             right = fwin->right_button && !fwin->flags.hide_right_button
 626                 && !fwin->flags.rbutton_dont_fit;
 627
 628             width = fwin->core->width+1;
 629
 630             renderTexture(fwin->screen_ptr, fwin->title_texture[state],
 631                           width, fwin->titlebar->height,
 632                           fwin->titlebar->height, fwin->titlebar->height,
 633                           left, right, &pmap, &lpmap, &rpmap);
 634
 635             fwin->title_back[state] = pmap;
 636             if (wPreferences.new_style) {
 637                 fwin->lbutton_back[state] = lpmap;
 638                 fwin->rbutton_back[state] = rpmap;
 639             }
 640         }
 641     }
 642 }
 643
 644
 645 void
 646 wFrameWindowPaint(WFrameWindow *fwin)
 647 {
 648
 649     if (fwin->flags.is_client_window_frame)
 650         fwin->flags.justification = wPreferences.title_justification;
 651
 652     if (fwin->flags.need_texture_remake) {
 653         int i;
 654
 655         fwin->flags.need_texture_remake = 0;
 656         fwin->flags.need_texture_change = 0;
 657
 658         if (fwin->flags.single_texture) {
 659             remakeTexture(fwin, 0);
 660             updateTexture(fwin);
 661         } else {
 662             /* first render the texture for the current state... */
 663             remakeTexture(fwin, fwin->flags.state);
 664             /* ... and paint it */
 665             updateTexture(fwin);
 666
 667             for (i=0; i < 3; i++) {
 668                 if (i!=fwin->flags.state)
 669                     remakeTexture(fwin, i);
 670             }
 671         }
 672     }
 673
 674     if (fwin->flags.need_texture_change) {
 675         fwin->flags.need_texture_change = 0;
 676
 677         updateTexture(fwin);
 678     }
 679
 680     if (fwin->titlebar && !fwin->flags.repaint_only_resizebar
 681         && fwin->title_texture[fwin->flags.state]->any.type==WTEX_SOLID) {
 682         wDrawBevel(fwin->titlebar->window, fwin->titlebar->width,
 683                    fwin->titlebar->height,
 684                    (WTexSolid*)fwin->title_texture[fwin->flags.state],
 685                    WREL_RAISED);
 686     }
 687
 688     if (fwin->resizebar && !fwin->flags.repaint_only_titlebar) {
 689         Window win;
 690         int w, h;
 691         int cw;
 692         GC light_gc, dim_gc;
 693         WTexSolid *texture = (WTexSolid*)fwin->resizebar_texture[0];
 694
 695         w = fwin->resizebar->width;
 696         h = fwin->resizebar->height;
 697         cw = fwin->resizebar_corner_width;
 698         light_gc = texture->light_gc;
 699         dim_gc = texture->dim_gc;
 700         win = fwin->resizebar->window;
 701
 702         XDrawLine(dpy, win, dim_gc, 0, 0, w, 0);
 703         XDrawLine(dpy, win, light_gc, 0, 1, w, 1);
 704
 705         XDrawLine(dpy, win, dim_gc, cw, 2, cw, h);
 706         XDrawLine(dpy, win, light_gc, cw+1, 2, cw+1, h);
 707
 708         XDrawLine(dpy, win, dim_gc, w-cw-2, 2, w-cw-2, h);
 709         XDrawLine(dpy, win, light_gc, w-cw-1, 2, w-cw-1, h);
 710
 711 #ifdef SHADOW_RESIZEBAR
 712         XDrawLine(dpy, win, light_gc, 0, 1, 0, h-1);
 713         XDrawLine(dpy, win, dim_gc, w-1, 2, w-1, h-1);
 714         XDrawLine(dpy, win, dim_gc, 1, h-1, cw, h-1);
 715         XDrawLine(dpy, win, dim_gc, cw+2, h-1, w-cw-2, h-1);
 716         XDrawLine(dpy, win, dim_gc, w-cw, h-1, w-1, h-1);
 717 #endif /* SHADOW_RESIZEBAR */
 718     }
 719
 720
 721     if (fwin->title && fwin->titlebar && !fwin->flags.repaint_only_resizebar) {
 722         int x, w;
 723         int lofs = 6, rofs = 6;
 724         int titlelen;
 725         char *title;
 726         int allButtons = 1;
 727
 728
 729         if (!wPreferences.new_style) {
 730             if (fwin->left_button && !fwin->flags.hide_left_button
 731                 && !fwin->flags.lbutton_dont_fit)
 732                 lofs += fwin->left_button->width + 3;
 733             else
 734                 allButtons = 0;
 735
 736             if (fwin->right_button && !fwin->flags.hide_right_button
 737                 && !fwin->flags.rbutton_dont_fit)
 738                 rofs += fwin->right_button->width + 3;
 739             else
 740                 allButtons = 0;
 741         }
 742
 743 #ifdef XKB_TITLE_HINT
 744         if(fwin->flags.is_client_window_frame) {
 745             char * freebuff;
 746             freebuff = (char *)wmalloc((strlen(fwin->title)+6)*sizeof(char));
 747             if (fwin->flags.justification == WTJ_RIGHT)
 748                sprintf(freebuff,"%s %s",fwin->title,fwin->languagemode?XKB_ON:XKB_OFF);
 749             else
 750                sprintf(freebuff,"%s %s",fwin->languagemode?XKB_ON:XKB_OFF,fwin->title);
 751             title = ShrinkString(*fwin->font, freebuff,
 752                              fwin->titlebar->width - lofs - rofs);
 753             free(freebuff);
 754         }
 755         else title = ShrinkString(*fwin->font, fwin->title,
 756                              fwin->titlebar->width - lofs - rofs);
 757 #else
 758         title = ShrinkString(*fwin->font, fwin->title,
 759                              fwin->titlebar->width - lofs - rofs);
 760 #endif /* XKB_TITLE_HINT */
 761         titlelen = strlen(title);
 762         w = wTextWidth((*fwin->font)->font, title, titlelen);
 763
 764         switch (fwin->flags.justification) {
 765          case WTJ_LEFT:
 766             x = lofs;
 767             break;
 768
 769          case WTJ_RIGHT:
 770             x = fwin->titlebar->width - w - rofs;
 771             break;
 772
 773          default:
 774             if (!allButtons)
 775                 x = lofs + (fwin->titlebar->width - w - lofs - rofs) / 2;
 776             else
 777                 x = (fwin->titlebar->width - w) / 2;
 778             break;
 779         }
 780
 781 #ifdef TITLE_TEXT_SHADOW
 782        if(wPreferences.title_shadow){
 783           int shadowx,shadowy;
 784           XSetForeground(dpy, *fwin->title_gc,
 785               fwin->title_pixel[fwin->flags.state+3]);
 786            for(shadowx=0;shadowx<TITLE_TEXT_SHADOW_WIDTH;shadowx++)
 787            for(shadowy=0;shadowy<TITLE_TEXT_SHADOW_HEIGHT;shadowy++)
 788                wDrawString(fwin->titlebar->window, *fwin->font,
 789                        *fwin->title_gc,
 790                        x + shadowx + TITLE_TEXT_SHADOW_X_OFFSET,
 791                        (*fwin->font)->y + TITLEBAR_EXTRA_HEIGHT/2
 792                         + shadowy + TITLE_TEXT_SHADOW_Y_OFFSET, title,
 793                        titlelen);
 794        }
 795 #endif /* TITLE_TEXT_SHADOW */
 796
 797         XSetForeground(dpy, *fwin->title_gc,
 798                        fwin->title_pixel[fwin->flags.state]);
 799
 800         wDrawString(fwin->titlebar->window, *fwin->font,
 801                     *fwin->title_gc, x,
 802                     (*fwin->font)->y + TITLEBAR_EXTRA_HEIGHT/2, title,
 803                     titlelen);
 804
 805         free(title);
 806
 807         if (fwin->left_button)
 808             handleButtonExpose(&fwin->left_button->descriptor, NULL);
 809         if (fwin->right_button)
 810             handleButtonExpose(&fwin->right_button->descriptor, NULL);
 811     }
 812 }
 813
 814
 815 static void
 816 reconfigure(WFrameWindow *fwin, int x, int y, int width, int height,
 817             Bool dontMove)
 818 {
 819     int k = (wPreferences.new_style ? 4 : 3);
 820     int resizedHorizontally = 0;
 821
 822     if (dontMove)
 823         XResizeWindow(dpy, fwin->core->window, width, height);
 824     else
 825         XMoveResizeWindow(dpy, fwin->core->window, x, y, width, height);
 826
 827     /*
 828      if (fwin->core->height != height && fwin->resizebar)
 829      XMoveWindow(dpy, fwin->resizebar->window, 0,
 830                  height - fwin->resizebar->height);
 831      */
 832     if (fwin->core->width != width) {
 833         fwin->flags.need_texture_remake = 1;
 834         resizedHorizontally = 1;
 835     }
 836
 837     fwin->core->width = width;
 838     fwin->core->height = height;
 839
 840     if (fwin->titlebar && resizedHorizontally) {
 841         /* Check if the titlebar is wide enough to hold the buttons.
 842          * Temporarily remove them if can't
 843          */
 844         if (fwin->left_button) {
 845             if (width < fwin->top_width*k && !fwin->flags.lbutton_dont_fit) {
 846
 847                 if (!fwin->flags.hide_left_button) {
 848                     XUnmapWindow(dpy, fwin->left_button->window);
 849                 }
 850                 fwin->flags.lbutton_dont_fit = 1;
 851             } else if (width >= fwin->top_width*k && fwin->flags.lbutton_dont_fit) {
 852
 853                 if (!fwin->flags.hide_left_button) {
 854                     XMapWindow(dpy, fwin->left_button->window);
 855                 }
 856                 fwin->flags.lbutton_dont_fit = 0;
 857             }
 858         }
 859
 860         if (fwin->right_button) {
 861             if (width < fwin->top_width*2 && !fwin->flags.rbutton_dont_fit) {
 862
 863                 if (!fwin->flags.hide_right_button) {
 864                     XUnmapWindow(dpy, fwin->right_button->window);
 865                 }
 866                 fwin->flags.rbutton_dont_fit = 1;
 867             } else if (width >= fwin->top_width*2 && fwin->flags.rbutton_dont_fit) {
 868
 869                 if (!fwin->flags.hide_right_button) {
 870                     XMapWindow(dpy, fwin->right_button->window);
 871                 }
 872                 fwin->flags.rbutton_dont_fit = 0;
 873             }
 874         }
 875
 876         if (wPreferences.new_style) {
 877             if (fwin->right_button)
 878                 XMoveWindow(dpy, fwin->right_button->window,
 879                             width - fwin->right_button->width + 1, 0);
 880         } else {
 881             if (fwin->right_button)
 882                 XMoveWindow(dpy, fwin->right_button->window,
 883                             width - fwin->right_button->width - 3,
 884                             (fwin->titlebar->height - fwin->right_button->height)/2);
 885         }
 886         updateTitlebar(fwin);
 887         checkTitleSize(fwin);
 888     }
 889
 890     if (fwin->resizebar) {
 891         wCoreConfigure(fwin->resizebar, 0,
 892                        fwin->core->height - fwin->resizebar->height,
 893                        fwin->core->width, fwin->resizebar->height);
 894
 895         fwin->resizebar_corner_width = RESIZEBAR_CORNER_WIDTH;
 896         if (fwin->core->width < RESIZEBAR_CORNER_WIDTH*2 + RESIZEBAR_MIN_WIDTH) {
 897             fwin->resizebar_corner_width = fwin->core->width/2;
 898         }
 899     }
 900 }
 901
 902 void
 903 wFrameWindowConfigure(WFrameWindow *fwin, int x, int y, int width, int height)
 904 {
 905     reconfigure(fwin, x, y, width, height, False);
 906 }
 907
 908 void
 909 wFrameWindowResize(WFrameWindow *fwin, int width, int height)
 910 {
 911     reconfigure(fwin, 0, 0, width, height, True);
 912 }
 913
 914
 915
 916 int
 917 wFrameWindowChangeTitle(WFrameWindow *fwin, char *new_title)
 918 {
 919     /* check if the title is the same as before */
 920     if (fwin->title) {
 921         if (new_title && (strcmp(fwin->title, new_title) == 0)) {
 922             return 0;
 923         }
 924     } else {
 925         if (!new_title)
 926            return 0;
 927     }
 928
 929     if (fwin->title)
 930         free(fwin->title);
 931
 932     fwin->title = wstrdup(new_title);
 933
 934     if (fwin->titlebar) {
 935         XClearWindow(dpy, fwin->titlebar->window);
 936
 937         wFrameWindowPaint(fwin);
 938     }
 939     checkTitleSize(fwin);
 940
 941     return 1;
 942 }
 943
 944
 945 #ifdef OLWM_HINTS
 946 void
 947 wFrameWindowUpdatePushButton(WFrameWindow *fwin, Bool pushed)
 948 {
 949     fwin->flags.right_button_pushed_in = pushed;
 950
 951     paintButton(fwin->right_button, fwin->title_texture[fwin->flags.state],
 952                 fwin->title_pixel[fwin->flags.state],
 953                 fwin->rbutton_image, pushed);
 954 }
 955 #endif /* OLWM_HINTS */
 956
 957
 958
 959 /*********************************************************************/
 960
 961 static void
 962 handleExpose(WObjDescriptor *desc, XEvent *event)
 963 {
 964     WFrameWindow *fwin = (WFrameWindow*)desc->parent;
 965
 966
 967     if (fwin->titlebar && fwin->titlebar->window == event->xexpose.window)
 968         fwin->flags.repaint_only_titlebar = 1;
 969     if (fwin->resizebar && fwin->resizebar->window == event->xexpose.window)
 970         fwin->flags.repaint_only_resizebar = 1;
 971     wFrameWindowPaint(fwin);
 972     fwin->flags.repaint_only_titlebar = 0;
 973     fwin->flags.repaint_only_resizebar = 0;
 974 }
 975
 976
 977 static void
 978 checkTitleSize(WFrameWindow *fwin)
 979 {
 980     int width;
 981
 982     if (!fwin->title) {
 983         fwin->flags.incomplete_title = 0;
 984         return;
 985     }
 986
 987     if (!fwin->titlebar) {
 988         fwin->flags.incomplete_title = 1;
 989         return;
 990     } else {
 991         width = fwin->titlebar->width - 6 - 6;
 992     }
 993
 994     if (!wPreferences.new_style) {
 995         if (fwin->left_button && !fwin->flags.hide_left_button
 996             && !fwin->flags.lbutton_dont_fit)
 997             width -= fwin->left_button->width + 3;
 998
 999         if (fwin->right_button && !fwin->flags.hide_right_button
1000             && !fwin->flags.rbutton_dont_fit)
1001             width -= fwin->right_button->width + 3;
1002     }
1003     if (wTextWidth((*fwin->font)->font, fwin->title,
1004                     strlen(fwin->title)) > width) {
1005         fwin->flags.incomplete_title = 1;
1006     } else {
1007         fwin->flags.incomplete_title = 0;
1008     }
1009 }
1010
1011
1012 static void
1013 paintButton(WCoreWindow *button, WTexture *texture, unsigned long color,
1014             WPixmap *image, int pushed)
1015 {
1016     WScreen *scr = button->screen_ptr;
1017     GC copy_gc = scr->copy_gc;
1018     int x=0, y=0, d=0;
1019     int left=0, width=0;
1020
1021     /* setup stuff according to the state */
1022     if (pushed) {
1023         if (image) {
1024             if (image->width>=image->height*2) {
1025                 /* the image contains 2 pictures: the second is for the
1026                  * pushed state */
1027                 width = image->width/2;
1028                 left = image->width/2;
1029             } else {
1030                 width = image->width;
1031             }
1032         }
1033         XSetClipMask(dpy, copy_gc, None);
1034         XSetForeground(dpy, copy_gc, scr->white_pixel);
1035         d=1;
1036         if (wPreferences.new_style) {
1037             XFillRectangle(dpy, button->window, copy_gc, 0, 0,
1038                            button->width-1, button->height-1);
1039             XSetForeground(dpy, copy_gc, scr->black_pixel);
1040             XDrawRectangle(dpy, button->window, copy_gc, 0, 0,
1041                            button->width-1, button->height-1);
1042         } else {
1043             XFillRectangle(dpy, button->window, copy_gc, 0, 0,
1044                            button->width, button->height);
1045             XSetForeground(dpy, copy_gc, scr->black_pixel);
1046             XDrawRectangle(dpy, button->window, copy_gc, 0, 0,
1047                            button->width, button->height);
1048         }
1049     } else {
1050         XClearWindow(dpy, button->window);
1051
1052         if (image) {
1053             if (image->width>=image->height*2)
1054                 width = image->width/2;
1055             else
1056                 width = image->width;
1057         }
1058         d=0;
1059
1060         if (wPreferences.new_style) {
1061             if (texture->any.type==WTEX_SOLID || pushed) {
1062                 wDrawBevel(button->window, button->width, button->height,
1063                            (WTexSolid*)texture, WREL_RAISED);
1064             }
1065         } else {
1066             wDrawBevel(button->window, button->width, button->height,
1067                        scr->widget_texture, WREL_RAISED);
1068         }
1069     }
1070
1071     if (image) {
1072         /* display image */
1073         XSetClipMask(dpy, copy_gc, image->mask);
1074         x = (button->width - width)/2 + d;
1075         y = (button->height - image->height)/2 + d;
1076         XSetClipOrigin(dpy, copy_gc, x-left, y);
1077         if (!wPreferences.new_style) {
1078             XSetForeground(dpy, copy_gc, scr->black_pixel);
1079             if (!pushed) {
1080                 if (image->depth==1)
1081                     XCopyPlane(dpy, image->image, button->window, copy_gc,
1082                                left, 0, width, image->height, x, y, 1);
1083                 else
1084                     XCopyArea(dpy, image->image, button->window, copy_gc,
1085                               left, 0, width, image->height, x, y);
1086             } else {
1087                 XSetForeground(dpy, copy_gc, scr->dark_pixel);
1088                 XFillRectangle(dpy, button->window, copy_gc, 0, 0,
1089                                button->width, button->height);
1090             }
1091         } else {
1092             if (pushed) {
1093                 XSetForeground(dpy, copy_gc, scr->black_pixel);
1094             } else {
1095                 XSetForeground(dpy, copy_gc, color);
1096                 XSetBackground(dpy, copy_gc, texture->any.color.pixel);
1097             }
1098             XFillRectangle(dpy, button->window, copy_gc, 0, 0,
1099                            button->width, button->height);
1100         }
1101     }
1102 }
1103
1104
1105 static void
1106 handleButtonExpose(WObjDescriptor *desc, XEvent *event)
1107 {
1108     WFrameWindow *fwin = (WFrameWindow*)desc->parent;
1109     WCoreWindow *button = (WCoreWindow*)desc->self;
1110
1111     if (button == fwin->left_button) {
1112         paintButton(button, fwin->title_texture[fwin->flags.state],
1113                     fwin->title_pixel[fwin->flags.state],
1114                     fwin->lbutton_image, False);
1115     } else {
1116         Bool pushed = False;
1117
1118 #ifdef OLWM_HINTS
1119         if (fwin->flags.right_button_pushed_in)
1120             pushed = True;
1121 #endif
1122         /* emulate the olwm pushpin in the "out" state */
1123         paintButton(button, fwin->title_texture[fwin->flags.state],
1124                     fwin->title_pixel[fwin->flags.state],
1125                     fwin->rbutton_image, pushed);
1126     }
1127 }
1128
1129
1130 static void
1131 titlebarMouseDown(WObjDescriptor *desc, XEvent *event)
1132 {
1133     WFrameWindow *fwin = desc->parent;
1134     WCoreWindow *titlebar = desc->self;
1135
1136     if (IsDoubleClick(fwin->core->screen_ptr, event)) {
1137         if (fwin->on_dblclick_titlebar)
1138             (*fwin->on_dblclick_titlebar)(titlebar, fwin->child, event);
1139     } else {
1140         if (fwin->on_mousedown_titlebar)
1141             (*fwin->on_mousedown_titlebar)(titlebar, fwin->child, event);
1142     }
1143 }
1144
1145
1146 static void
1147 resizebarMouseDown(WObjDescriptor *desc, XEvent *event)
1148 {
1149     WFrameWindow *fwin = desc->parent;
1150     WCoreWindow *resizebar = desc->self;
1151
1152     if (fwin->on_mousedown_resizebar)
1153         (*fwin->on_mousedown_resizebar)(resizebar, fwin->child, event);
1154 }
1155
1156
1157 static void
1158 buttonMouseDown(WObjDescriptor *desc, XEvent *event)
1159 {
1160     WFrameWindow *fwin = desc->parent;
1161     WCoreWindow *button = desc->self;
1162     WPixmap *image;
1163     XEvent ev;
1164     int done=0, execute=1;
1165     WTexture *texture;
1166     unsigned long pixel;
1167     int clickButton = event->xbutton.button;
1168
1169     if (IsDoubleClick(fwin->core->screen_ptr, event)) {
1170         if (button == fwin->right_button && fwin->on_dblclick_right) {
1171             (*fwin->on_dblclick_right)(button, fwin->child, event);
1172         }
1173         return;
1174     }
1175
1176     if (button == fwin->left_button) {
1177         image = fwin->lbutton_image;
1178     } else {
1179         image = fwin->rbutton_image;
1180     }
1181
1182     pixel = fwin->title_pixel[fwin->flags.state];
1183     texture = fwin->title_texture[fwin->flags.state];
1184     paintButton(button, texture, pixel, image, True);
1185
1186     while (!done) {
1187         WMMaskEvent(dpy, LeaveWindowMask|EnterWindowMask|ButtonReleaseMask
1188                     |ButtonPressMask|ExposureMask, &ev);
1189         switch (ev.type) {
1190          case LeaveNotify:
1191             execute = 0;
1192             paintButton(button, texture, pixel, image, False);
1193             break;
1194
1195          case EnterNotify:
1196             execute = 1;
1197             paintButton(button, texture, pixel, image, True);
1198             break;
1199
1200          case ButtonPress:
1201             break;
1202
1203          case ButtonRelease:
1204             if (ev.xbutton.button == clickButton)
1205                 done = 1;
1206             break;
1207
1208          default:
1209             WMHandleEvent(&ev);
1210         }
1211     }
1212     paintButton(button, texture, pixel, image, False);
1213
1214     if (execute) {
1215         if (button == fwin->left_button) {
1216             if (fwin->on_click_left)
1217                 (*fwin->on_click_left)(button, fwin->child, &ev);
1218         } else if (button == fwin->right_button) {
1219             if (fwin->on_click_right)
1220                 (*fwin->on_click_right)(button, fwin->child, &ev);
1221         }
1222     }
1223 }
1224