src/winspector.c

   1 /* winspector.c - window attribute inspector
   2  *
   3  *  Window Maker window manager
   4  *
   5  *  Copyright (c) 1997, 1998 Alfredo K. Kojima
   6  *  Copyright (c) 1998       Dan Pascu
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 2 of the License, or
  11  *  (at your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with this program; if not, write to the Free Software
  20  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  21  *  USA.
  22  */
  23
  24 #include "wconfig.h"
  25
  26 #include <X11/Xlib.h>
  27 #include <X11/Xutil.h>
  28 #include <stdlib.h>
  29 #include <stdio.h>
  30 #include <string.h>
  31
  32 #include "WindowMaker.h"
  33 #include "screen.h"
  34 #include "wcore.h"
  35 #include "framewin.h"
  36 #include "window.h"
  37 #include "workspace.h"
  38 #include "funcs.h"
  39 #include "defaults.h"
  40 #include "dialog.h"
  41 #include "icon.h"
  42 #include "stacking.h"
  43 #include "application.h"
  44 #include "appicon.h"
  45 #include "actions.h"
  46 #include "winspector.h"
  47 #include "dock.h"
  48 #include "client.h"
  49
  50 #include <proplist.h>
  51
  52
  53
  54
  55
  56
  57
  58 typedef struct InspectorPanel {
  59     struct InspectorPanel *nextPtr;
  60
  61     WWindow *frame;
  62
  63     WWindow *inspected;       /* the window that's being inspected */
  64
  65     WMWindow *win;
  66
  67     Window parent;
  68
  69     /* common stuff */
  70     WMButton *revertBtn;
  71     WMButton *applyBtn;
  72     WMButton *saveBtn;
  73
  74     WMPopUpButton *pagePopUp;
  75
  76     /* first page. general stuff */
  77
  78     WMFrame *specFrm;
  79     WMButton *instRb;
  80     WMButton *clsRb;
  81     WMButton *bothRb;
  82     WMButton *defaultRb;
  83
  84     WMButton *selWinB;
  85
  86     WMLabel *specLbl;
  87
  88     /* second page. attributes */
  89
  90     WMFrame *attrFrm;
  91     WMButton *attrChk[11];
  92
  93     /* 3rd page. more attributes */
  94     WMFrame *moreFrm;
  95 #ifdef XKB_BUTTON_HINT
  96     WMButton *moreChk[9];
  97 #else
  98     WMButton *moreChk[8];
  99 #endif
 100
 101     /* 4th page. icon and workspace */
 102     WMFrame *iconFrm;
 103     WMLabel *iconLbl;
 104     WMLabel *fileLbl;
 105     WMTextField *fileText;
 106     WMButton *alwChk;
 107     /*
 108     WMButton *updateIconBtn;
 109      */
 110     WMButton *browseIconBtn;
 111
 112     WMFrame *wsFrm;
 113     WMPopUpButton *wsP;
 114
 115     /* 5th page. application wide attributes */
 116     WMFrame *appFrm;
 117     WMButton *appChk[2];
 118
 119     unsigned int done:1;
 120     unsigned int destroyed:1;
 121     unsigned int choosingIcon:1;
 122 } InspectorPanel;
 123
 124
 125
 126
 127 extern Cursor wCursor[WCUR_LAST];
 128
 129 extern WDDomain *WDWindowAttributes;
 130
 131 static InspectorPanel *panelList=NULL;
 132
 133 extern WPreferences wPreferences;
 134
 135 static proplist_t ANoTitlebar = NULL;
 136 static proplist_t ANoResizebar;
 137 static proplist_t ANoMiniaturizeButton;
 138 static proplist_t ANoCloseButton;
 139 static proplist_t ANoBorder;
 140 static proplist_t ANoHideOthers;
 141 static proplist_t ANoMouseBindings;
 142 static proplist_t ANoKeyBindings;
 143 static proplist_t ANoAppIcon;
 144 static proplist_t AKeepOnTop;
 145 static proplist_t AKeepOnBottom;
 146 static proplist_t AOmnipresent;
 147 static proplist_t ASkipWindowList;
 148 static proplist_t AKeepInsideScreen;
 149 static proplist_t AUnfocusable;
 150 static proplist_t AAlwaysUserIcon;
 151 static proplist_t AStartMiniaturized;
 152 static proplist_t AStartMaximized;
 153 static proplist_t ADontSaveSession;
 154 static proplist_t AEmulateAppIcon;
 155 static proplist_t AFullMaximize;
 156 #ifdef XKB_BUTTON_HINT
 157 static proplist_t ANoLanguageButton;
 158 #endif
 159
 160 static proplist_t AStartWorkspace;
 161
 162 static proplist_t AIcon;
 163
 164 /* application wide options */
 165 static proplist_t AStartHidden;
 166
 167
 168 static proplist_t AnyWindow;
 169 static proplist_t EmptyString;
 170 static proplist_t Yes, No;
 171
 172
 173 #define PWIDTH  270
 174 #define PHEIGHT 350
 175
 176
 177
 178
 179 static void applySettings(WMButton *button, InspectorPanel *panel);
 180
 181
 182
 183
 184 #define UNDEFINED_POS 0xffffff
 185
 186 static InspectorPanel *createInspectorForWindow(WWindow *wwin,
 187                                                 int xpos, int ypos,
 188                                                 Bool showSelectPanel);
 189
 190
 191
 192 static void
 193 make_keys()
 194 {
 195     if (ANoTitlebar!=NULL)
 196         return;
 197
 198     AIcon = PLMakeString("Icon");
 199     ANoTitlebar = PLMakeString("NoTitlebar");
 200     ANoResizebar = PLMakeString("NoResizebar");
 201     ANoMiniaturizeButton = PLMakeString("NoMiniaturizeButton");
 202     ANoCloseButton = PLMakeString("NoCloseButton");
 203     ANoBorder = PLMakeString("NoBorder");
 204     ANoHideOthers = PLMakeString("NoHideOthers");
 205     ANoMouseBindings = PLMakeString("NoMouseBindings");
 206     ANoKeyBindings = PLMakeString("NoKeyBindings");
 207     ANoAppIcon = PLMakeString("NoAppIcon");
 208     AKeepOnTop = PLMakeString("KeepOnTop");
 209     AKeepOnBottom = PLMakeString("KeepOnBottom");
 210     AOmnipresent = PLMakeString("Omnipresent");
 211     ASkipWindowList = PLMakeString("SkipWindowList");
 212     AKeepInsideScreen = PLMakeString("KeepInsideScreen");
 213     AUnfocusable = PLMakeString("Unfocusable");
 214     AAlwaysUserIcon = PLMakeString("AlwaysUserIcon");
 215     AStartMiniaturized = PLMakeString("StartMiniaturized");
 216     AStartMaximized = PLMakeString("StartMaximized");
 217     AStartHidden = PLMakeString("StartHidden");
 218     ADontSaveSession = PLMakeString("DontSaveSession");
 219     AEmulateAppIcon = PLMakeString("EmulateAppIcon");
 220     AFullMaximize = PLMakeString("FullMaximize");
 221 #ifdef XKB_BUTTON_HINT
 222     ANoLanguageButton = PLMakeString("NoLanguageButton");
 223 #endif
 224
 225     AStartWorkspace = PLMakeString("StartWorkspace");
 226
 227     AnyWindow = PLMakeString("*");
 228     EmptyString = PLMakeString("");
 229     Yes = PLMakeString("Yes");
 230     No = PLMakeString("No");
 231 }
 232
 233
 234
 235 static void
 236 freeInspector(InspectorPanel *panel)
 237 {
 238     panel->destroyed = 1;
 239     if (panel->choosingIcon)
 240         return;
 241
 242     WMDestroyWidget(panel->win);
 243
 244     XDestroyWindow(dpy, panel->parent);
 245
 246     wfree(panel);
 247 }
 248
 249
 250 static void
 251 destroyInspector(WCoreWindow *foo, void *data, XEvent *event)
 252 {
 253     InspectorPanel *panel;
 254     InspectorPanel *tmp;
 255
 256     panel = panelList;
 257     while (panel->frame!=data)
 258         panel = panel->nextPtr;
 259
 260     if (panelList == panel)
 261         panelList = panel->nextPtr;
 262     else {
 263         tmp = panelList;
 264         while (tmp->nextPtr!=panel) {
 265             tmp = tmp->nextPtr;
 266         }
 267         tmp->nextPtr = panel->nextPtr;
 268     }
 269     panel->inspected->flags.inspector_open = 0;
 270     panel->inspected->inspector = NULL;
 271
 272     WMRemoveNotificationObserver(panel);
 273
 274     wWindowUnmap(panel->frame);
 275     wUnmanageWindow(panel->frame, True, False);
 276
 277     freeInspector(panel);
 278 }
 279
 280
 281
 282 void
 283 wDestroyInspectorPanels()
 284 {
 285     InspectorPanel *panel;
 286
 287     while (panelList != NULL) {
 288         panel = panelList;
 289         panelList = panelList->nextPtr;
 290         wUnmanageWindow(panel->frame, False, False);
 291         WMDestroyWidget(panel->win);
 292
 293         panel->inspected->flags.inspector_open = 0;
 294         panel->inspected->inspector = NULL;
 295
 296         wfree(panel);
 297     }
 298 }
 299
 300
 301 static void
 302 changePage(WMPopUpButton *bPtr, InspectorPanel *panel)
 303 {
 304     int page;
 305
 306     page = WMGetPopUpButtonSelectedItem(bPtr);
 307
 308     if (page == 0) {
 309         WMMapWidget(panel->specFrm);
 310         WMMapWidget(panel->specLbl);
 311     } else if (page == 1) {
 312         WMMapWidget(panel->attrFrm);
 313     } else if (page == 2) {
 314         WMMapWidget(panel->moreFrm);
 315     } else if (page == 3) {
 316         WMMapWidget(panel->iconFrm);
 317         WMMapWidget(panel->wsFrm);
 318     } else {
 319         WMMapWidget(panel->appFrm);
 320     }
 321
 322     if (page != 0) {
 323         WMUnmapWidget(panel->specFrm);
 324         WMUnmapWidget(panel->specLbl);
 325     }
 326     if (page != 1)
 327         WMUnmapWidget(panel->attrFrm);
 328     if (page != 2)
 329         WMUnmapWidget(panel->moreFrm);
 330     if (page != 3) {
 331         WMUnmapWidget(panel->iconFrm);
 332         WMUnmapWidget(panel->wsFrm);
 333     }
 334     if (page != 4 && panel->appFrm)
 335         WMUnmapWidget(panel->appFrm);
 336 }
 337
 338
 339 #define USE_TEXT_FIELD          1
 340 #define UPDATE_TEXT_FIELD       2
 341 #define REVERT_TO_DEFAULT       4
 342
 343
 344 static int
 345 showIconFor(WMScreen *scrPtr, InspectorPanel *panel,
 346             char *wm_instance, char *wm_class, int flags)
 347 {
 348     WMPixmap *pixmap = (WMPixmap*) NULL;
 349     char *file=NULL, *path=NULL;
 350     char *db_icon=NULL;
 351
 352     if ((flags & USE_TEXT_FIELD) != 0) {
 353         file = WMGetTextFieldText(panel->fileText);
 354         if (file && file[0] == 0) {
 355             wfree(file);
 356             file = NULL;
 357         }
 358     } else {
 359         db_icon = wDefaultGetIconFile(panel->inspected->screen_ptr,
 360                                       wm_instance, wm_class, False);
 361         if(db_icon != NULL)
 362             file = wstrdup(db_icon);
 363     }
 364     if (db_icon!=NULL && (flags & REVERT_TO_DEFAULT)!=0) {
 365         if (file)
 366             file = wstrdup(db_icon);
 367         flags |= UPDATE_TEXT_FIELD;
 368     }
 369
 370     if ((flags & UPDATE_TEXT_FIELD) != 0) {
 371         WMSetTextFieldText(panel->fileText, file);
 372     }
 373
 374     if (file) {
 375         path = FindImage(wPreferences.icon_path, file);
 376
 377         if (!path) {
 378             char *buf;
 379
 380             buf = wmalloc(strlen(file)+80);
 381             sprintf(buf, _("Could not find icon \"%s\" specified for this window"),
 382                     file);
 383             wMessageDialog(panel->frame->screen_ptr, _("Error"), buf,
 384                            _("OK"), NULL, NULL);
 385             wfree(buf);
 386             wfree(file);
 387             return -1;
 388         }
 389
 390         pixmap = WMCreatePixmapFromFile(scrPtr, path);
 391         wfree(path);
 392
 393         if (!pixmap) {
 394             char *buf;
 395
 396             buf = wmalloc(strlen(file)+80);
 397             sprintf(buf, _("Could not open specified icon \"%s\":%s"),
 398                     file, RMessageForError(RErrorCode));
 399             wMessageDialog(panel->frame->screen_ptr, _("Error"), buf,
 400                            _("OK"), NULL, NULL);
 401             wfree(buf);
 402             wfree(file);
 403             return -1;
 404         }
 405         wfree(file);
 406     }
 407
 408     WMSetLabelImage(panel->iconLbl, pixmap);
 409     if (pixmap)
 410         WMReleasePixmap(pixmap);
 411
 412     return 0;
 413 }
 414
 415 #if 0
 416 static void
 417 updateIcon(WMButton *button, InspectorPanel *panel)
 418 {
 419     showIconFor(WMWidgetScreen(button), panel, NULL, NULL, USE_TEXT_FIELD);
 420 }
 421 #endif
 422
 423 static int
 424 getBool(proplist_t value)
 425 {
 426     char *val;
 427
 428     if (!PLIsString(value)) {
 429         return 0;
 430     }
 431     if (!(val = PLGetString(value))) {
 432         return 0;
 433     }
 434
 435     if ((val[1]=='\0' && (val[0]=='y' || val[0]=='Y' || val[0]=='T'
 436                           || val[0]=='t' || val[0]=='1'))
 437         || (strcasecmp(val, "YES")==0 || strcasecmp(val, "TRUE")==0)) {
 438
 439         return 1;
 440     } else if ((val[1]=='\0'
 441                 && (val[0]=='n' || val[0]=='N' || val[0]=='F'
 442                     || val[0]=='f' || val[0]=='0'))
 443                || (strcasecmp(val, "NO")==0 || strcasecmp(val, "FALSE")==0)) {
 444
 445         return 0;
 446     } else {
 447         wwarning(_("can't convert \"%s\" to boolean"), val);
 448         return 0;
 449     }
 450 }
 451
 452
 453 #define UPDATE_DEFAULTS    1
 454 #define IS_BOOLEAN         2
 455
 456
 457 /*
 458  *  Will insert the attribute = value; pair in window's list,
 459  * if it's different from the defaults.
 460  *  Defaults means either defaults database, or attributes saved
 461  * for the default window "*". This is to let one revert options that are
 462  * global because they were saved for all windows ("*").
 463  *
 464  */
 465
 466
 467 static int
 468 insertAttribute(proplist_t dict, proplist_t window, proplist_t attr,
 469                 proplist_t value, int flags)
 470 {
 471     proplist_t def_win, def_value=NULL;
 472     int update = 0;
 473     int modified = 0;
 474
 475     if (!(flags & UPDATE_DEFAULTS) && dict) {
 476         if ((def_win = PLGetDictionaryEntry(dict, AnyWindow)) != NULL) {
 477             def_value = PLGetDictionaryEntry(def_win, attr);
 478         }
 479     }
 480
 481     /* If we could not find defaults in database, fall to hardcoded values.
 482      * Also this is true if we save defaults for all windows
 483      */
 484     if (!def_value)
 485         def_value = ((flags & IS_BOOLEAN) != 0) ? No : EmptyString;
 486
 487     if ((flags & IS_BOOLEAN))
 488         update = (getBool(value) != getBool(def_value));
 489     else {
 490         update = !PLIsEqual(value, def_value);
 491     }
 492
 493     if (update) {
 494         PLInsertDictionaryEntry(window, attr, value);
 495         modified = 1;
 496     }
 497
 498     return modified;
 499 }
 500
 501
 502 static void
 503 saveSettings(WMButton *button, InspectorPanel *panel)
 504 {
 505     WWindow *wwin = panel->inspected;
 506     WDDomain *db = WDWindowAttributes;
 507     proplist_t dict = db->dictionary;
 508     proplist_t winDic, value, key;
 509     char *icon_file;
 510     int flags = 0;
 511     int different = 0;
 512
 513     /* Save will apply the changes and save them */
 514     applySettings(panel->applyBtn, panel);
 515
 516     if (WMGetButtonSelected(panel->instRb) != 0)
 517         key = PLMakeString(wwin->wm_instance);
 518     else if (WMGetButtonSelected(panel->clsRb) != 0)
 519         key = PLMakeString(wwin->wm_class);
 520     else if (WMGetButtonSelected(panel->bothRb) != 0) {
 521                 char *buffer;
 522
 523                 buffer = wmalloc(strlen(wwin->wm_instance)+strlen(wwin->wm_class)+4);
 524         strcat(strcat(strcpy(buffer, wwin->wm_instance), "."), wwin->wm_class);
 525         key = PLMakeString(buffer);
 526         wfree(buffer);
 527     } else if (WMGetButtonSelected(panel->defaultRb) != 0) {
 528         key = PLRetain(AnyWindow);
 529         flags = UPDATE_DEFAULTS;
 530     } else
 531         key = NULL;
 532
 533     if (!key)
 534         return;
 535
 536     if (!dict) {
 537         dict = PLMakeDictionaryFromEntries(NULL, NULL, NULL);
 538         if (dict) {
 539             db->dictionary = dict;
 540             value = PLMakeString(db->path);
 541             PLSetFilename(dict, value);
 542             PLRelease(value);
 543         }
 544         else {
 545             PLRelease(key);
 546             return;
 547         }
 548     }
 549
 550     if (showIconFor(WMWidgetScreen(button), panel, NULL, NULL,
 551                     USE_TEXT_FIELD) < 0)
 552         return;
 553
 554     PLSetStringCmpHook(NULL);
 555
 556     winDic = PLMakeDictionaryFromEntries(NULL, NULL, NULL);
 557
 558     /* Update icon for window */
 559     icon_file = WMGetTextFieldText(panel->fileText);
 560     if (icon_file) {
 561         if (icon_file[0] != 0) {
 562             value = PLMakeString(icon_file);
 563             different |= insertAttribute(dict, winDic, AIcon, value, flags);
 564             PLRelease(value);
 565         }
 566         wfree(icon_file);
 567     }
 568
 569     {
 570         int i = WMGetPopUpButtonSelectedItem(panel->wsP);
 571
 572         i--;
 573
 574         if (i>=0 && i < panel->frame->screen_ptr->workspace_count) {
 575             value = PLMakeString(panel->frame->screen_ptr->workspaces[i]->name);
 576             different |= insertAttribute(dict, winDic, AStartWorkspace, value,
 577                                          flags);
 578             PLRelease(value);
 579         }
 580     }
 581
 582     flags |= IS_BOOLEAN;
 583
 584     value = (WMGetButtonSelected(panel->alwChk)!=0) ? Yes : No;
 585     different |= insertAttribute(dict, winDic, AAlwaysUserIcon, value, flags);
 586
 587     value = (WMGetButtonSelected(panel->attrChk[0])!=0) ? Yes : No;
 588     different |= insertAttribute(dict, winDic, ANoTitlebar,     value, flags);
 589
 590     value = (WMGetButtonSelected(panel->attrChk[1])!=0) ? Yes : No;
 591     different |= insertAttribute(dict, winDic, ANoResizebar,     value, flags);
 592
 593     value = (WMGetButtonSelected(panel->attrChk[2])!=0) ? Yes : No;
 594     different |= insertAttribute(dict, winDic, ANoCloseButton,   value, flags);
 595
 596     value = (WMGetButtonSelected(panel->attrChk[3])!=0) ? Yes : No;
 597     different |= insertAttribute(dict, winDic, ANoMiniaturizeButton, value, flags);
 598
 599     value = (WMGetButtonSelected(panel->attrChk[4])!=0) ? Yes : No;
 600     different |= insertAttribute(dict, winDic, ANoBorder, value, flags);
 601
 602     value = (WMGetButtonSelected(panel->attrChk[5])!=0) ? Yes : No;
 603     different |= insertAttribute(dict, winDic, AKeepOnTop,       value, flags);
 604
 605     value = (WMGetButtonSelected(panel->attrChk[6])!=0) ? Yes : No;
 606     different |= insertAttribute(dict, winDic, AKeepOnBottom,    value, flags);
 607
 608     value = (WMGetButtonSelected(panel->attrChk[7])!=0) ? Yes : No;
 609     different |= insertAttribute(dict, winDic, AOmnipresent,     value, flags);
 610
 611     value = (WMGetButtonSelected(panel->attrChk[8])!=0) ? Yes : No;
 612     different |= insertAttribute(dict, winDic, AStartMiniaturized, value, flags);
 613
 614     value = (WMGetButtonSelected(panel->attrChk[9])!=0) ? Yes : No;
 615     different |= insertAttribute(dict, winDic, AStartMaximized,  value, flags);
 616
 617     value = (WMGetButtonSelected(panel->attrChk[10])!=0) ? Yes : No;
 618     different |= insertAttribute(dict, winDic, ASkipWindowList,  value, flags);
 619
 620
 621     value = (WMGetButtonSelected(panel->moreChk[0])!=0) ? Yes : No;
 622     different |= insertAttribute(dict, winDic, ANoHideOthers,    value, flags);
 623
 624     value = (WMGetButtonSelected(panel->moreChk[1])!=0) ? Yes : No;
 625     different |= insertAttribute(dict, winDic, ANoKeyBindings,   value, flags);
 626
 627     value = (WMGetButtonSelected(panel->moreChk[2])!=0) ? Yes : No;
 628     different |= insertAttribute(dict, winDic, ANoMouseBindings, value, flags);
 629
 630     value = (WMGetButtonSelected(panel->moreChk[3])!=0) ? Yes : No;
 631     different |= insertAttribute(dict, winDic, AKeepInsideScreen,value, flags);
 632
 633     value = (WMGetButtonSelected(panel->moreChk[4])!=0) ? Yes : No;
 634     different |= insertAttribute(dict, winDic, AUnfocusable, value, flags);
 635
 636     value = (WMGetButtonSelected(panel->moreChk[5])!=0) ? Yes : No;
 637     different |= insertAttribute(dict, winDic, ADontSaveSession, value, flags);
 638
 639     value = (WMGetButtonSelected(panel->moreChk[6])!=0) ? Yes : No;
 640     different |= insertAttribute(dict, winDic, AEmulateAppIcon,  value, flags);
 641
 642     value = (WMGetButtonSelected(panel->moreChk[7])!=0) ? Yes : No;
 643     different |= insertAttribute(dict, winDic, AFullMaximize, value, flags);
 644
 645 #ifdef XKB_BUTTON_HINT
 646     value = (WMGetButtonSelected(panel->moreChk[8])!=0) ? Yes : No;
 647     different |= insertAttribute(dict, winDic, ANoLanguageButton, value, flags);
 648 #endif
 649
 650     /* application wide settings for when */
 651     /* the window is the leader, save the attribute with the others */
 652     if (panel->inspected->main_window == panel->inspected->client_win) {
 653
 654         value = (WMGetButtonSelected(panel->appChk[0])!=0) ? Yes : No;
 655         different |= insertAttribute(dict, winDic, AStartHidden, value, flags);
 656
 657         value = (WMGetButtonSelected(panel->appChk[1])!=0) ? Yes : No;
 658         different |= insertAttribute(dict, winDic, ANoAppIcon, value, flags);
 659     }
 660
 661     PLRemoveDictionaryEntry(dict, key);
 662     if (different) {
 663         PLInsertDictionaryEntry(dict, key, winDic);
 664     }
 665
 666     PLRelease(key);
 667     PLRelease(winDic);
 668
 669     different = 0;
 670
 671     /* application wide settings */
 672     if (panel->inspected->main_window != panel->inspected->client_win
 673         && !(flags & UPDATE_DEFAULTS)) {
 674         WApplication *wapp;
 675         proplist_t appDic;
 676
 677         wapp = wApplicationOf(panel->inspected->main_window);
 678         if (wapp) {
 679             char *iconFile;
 680                 char *buffer;
 681
 682             appDic = PLMakeDictionaryFromEntries(NULL, NULL, NULL);
 683
 684             assert(wapp->main_window_desc->wm_instance!=NULL);
 685             assert(wapp->main_window_desc->wm_class!=NULL);
 686
 687                 buffer = wmalloc(strlen(wapp->main_window_desc->wm_instance)
 688                                                  +strlen(wapp->main_window_desc->wm_class)+4);
 689             strcat(strcpy(buffer, wapp->main_window_desc->wm_instance), ".");
 690             strcat(buffer, wapp->main_window_desc->wm_class);
 691             key = PLMakeString(buffer);
 692             wfree(buffer);
 693
 694             iconFile = wDefaultGetIconFile(wwin->screen_ptr,
 695                                            wapp->main_window_desc->wm_instance,
 696                                            wapp->main_window_desc->wm_class,
 697                                            False);
 698
 699             if (iconFile && iconFile[0]!=0) {
 700                 value = PLMakeString(iconFile);
 701                 different |= insertAttribute(dict, appDic, AIcon, value,
 702                                              flags&~IS_BOOLEAN);
 703                 PLRelease(value);
 704             }
 705
 706             value = (WMGetButtonSelected(panel->appChk[0])!=0) ? Yes : No;
 707             different |= insertAttribute(dict, appDic, AStartHidden,  value,
 708                                          flags);
 709
 710             value = (WMGetButtonSelected(panel->appChk[1])!=0) ? Yes : No;
 711             different |= insertAttribute(dict, appDic, ANoAppIcon,  value,
 712                                          flags);
 713
 714             PLRemoveDictionaryEntry(dict, key);
 715             if (different) {
 716                 PLInsertDictionaryEntry(dict, key, appDic);
 717             }
 718             PLRelease(key);
 719             PLRelease(appDic);
 720         }
 721     }
 722
 723     PLSave(dict, YES);
 724
 725     /* clean up */
 726     PLSetStringCmpHook(StringCompareHook);
 727 }
 728
 729
 730 static void
 731 makeAppIconFor(WApplication *wapp)
 732 {
 733     WScreen *scr = wapp->main_window_desc->screen_ptr;
 734
 735     if (wapp->app_icon)
 736         return;
 737
 738     if (!WFLAGP(wapp->main_window_desc, no_appicon))
 739         wapp->app_icon = wAppIconCreate(wapp->main_window_desc);
 740     else
 741         wapp->app_icon = NULL;
 742
 743     if (wapp->app_icon) {
 744         WIcon *icon = wapp->app_icon->icon;
 745         WDock *clip = scr->workspaces[scr->current_workspace]->clip;
 746         int x=0, y=0;
 747
 748         wapp->app_icon->main_window = wapp->main_window;
 749
 750         if (clip && clip->attract_icons && wDockFindFreeSlot(clip, &x, &y)) {
 751             wapp->app_icon->attracted = 1;
 752             if (!wapp->app_icon->icon->shadowed) {
 753                 wapp->app_icon->icon->shadowed = 1;
 754                 wapp->app_icon->icon->force_paint = 1;
 755             }
 756             wDockAttachIcon(clip, wapp->app_icon, x, y);
 757         } else {
 758             PlaceIcon(scr, &x, &y);
 759             wAppIconMove(wapp->app_icon, x, y);
 760         }
 761         if (!clip || !wapp->app_icon->attracted || !clip->collapsed)
 762             XMapWindow(dpy, icon->core->window);
 763
 764         if (wPreferences.auto_arrange_icons && !wapp->app_icon->attracted)
 765             wArrangeIcons(wapp->main_window_desc->screen_ptr, True);
 766     }
 767 }
 768
 769
 770 static void
 771 removeAppIconFor(WApplication *wapp)
 772 {
 773     if (!wapp->app_icon)
 774         return;
 775
 776     if (wapp->app_icon->docked && !wapp->app_icon->attracted) {
 777         wapp->app_icon->running = 0;
 778         /* since we keep it, we don't care if it was attracted or not */
 779         wapp->app_icon->attracted = 0;
 780         wapp->app_icon->icon->shadowed = 0;
 781         wapp->app_icon->main_window = None;
 782         wapp->app_icon->pid = 0;
 783         wapp->app_icon->icon->owner = NULL;
 784         wapp->app_icon->icon->icon_win = None;
 785         wapp->app_icon->icon->force_paint = 1;
 786         wAppIconPaint(wapp->app_icon);
 787     } else if (wapp->app_icon->docked) {
 788         wapp->app_icon->running = 0;
 789         wDockDetach(wapp->app_icon->dock, wapp->app_icon);
 790     } else {
 791         wAppIconDestroy(wapp->app_icon);
 792     }
 793     wapp->app_icon = NULL;
 794     if (wPreferences.auto_arrange_icons)
 795         wArrangeIcons(wapp->main_window_desc->screen_ptr, True);
 796 }
 797
 798
 799 static void
 800 applySettings(WMButton *button, InspectorPanel *panel)
 801 {
 802     WWindow *wwin = panel->inspected;
 803     WApplication *wapp = wApplicationOf(wwin->main_window);
 804     int floating, sunken, skip_window_list;
 805     int old_omnipresent;
 806     int old_no_bind_keys;
 807     int old_no_bind_mouse;
 808
 809     old_omnipresent = WFLAGP(wwin, omnipresent);
 810     old_no_bind_keys = WFLAGP(wwin, no_bind_keys);
 811     old_no_bind_mouse = WFLAGP(wwin, no_bind_mouse);
 812
 813     showIconFor(WMWidgetScreen(button), panel, NULL, NULL, USE_TEXT_FIELD);
 814
 815     WSETUFLAG(wwin, no_titlebar, WMGetButtonSelected(panel->attrChk[0]));
 816     WSETUFLAG(wwin, no_resizebar, WMGetButtonSelected(panel->attrChk[1]));
 817     WSETUFLAG(wwin, no_close_button, WMGetButtonSelected(panel->attrChk[2]));
 818     WSETUFLAG(wwin, no_miniaturize_button, WMGetButtonSelected(panel->attrChk[3]));
 819     WSETUFLAG(wwin, no_border, WMGetButtonSelected(panel->attrChk[4]));
 820     floating                   =  WMGetButtonSelected(panel->attrChk[5]);
 821     sunken                     =  WMGetButtonSelected(panel->attrChk[6]);
 822     WSETUFLAG(wwin, omnipresent, WMGetButtonSelected(panel->attrChk[7]));
 823     WSETUFLAG(wwin, start_miniaturized, WMGetButtonSelected(panel->attrChk[8]));
 824     WSETUFLAG(wwin, start_maximized, WMGetButtonSelected(panel->attrChk[9]));
 825     skip_window_list           =  WMGetButtonSelected(panel->attrChk[10]);
 826
 827     WSETUFLAG(wwin, no_hide_others, WMGetButtonSelected(panel->moreChk[0]));
 828     WSETUFLAG(wwin, no_bind_keys, WMGetButtonSelected(panel->moreChk[1]));
 829     WSETUFLAG(wwin, no_bind_mouse, WMGetButtonSelected(panel->moreChk[2]));
 830     WSETUFLAG(wwin, dont_move_off, WMGetButtonSelected(panel->moreChk[3]));
 831     WSETUFLAG(wwin, no_focusable, WMGetButtonSelected(panel->moreChk[4]));
 832     WSETUFLAG(wwin, dont_save_session, WMGetButtonSelected(panel->moreChk[5]));
 833     WSETUFLAG(wwin, emulate_appicon, WMGetButtonSelected(panel->moreChk[6]));
 834     WSETUFLAG(wwin, full_maximize, WMGetButtonSelected(panel->moreChk[7]));
 835 #ifdef XKB_BUTTON_HINT
 836     WSETUFLAG(wwin, no_language_button, WMGetButtonSelected(panel->moreChk[8]));
 837 #endif
 838     WSETUFLAG(wwin, always_user_icon, WMGetButtonSelected(panel->alwChk));
 839
 840     if (WFLAGP(wwin, no_titlebar) && wwin->flags.shaded)
 841         wUnshadeWindow(wwin);
 842
 843     WSETUFLAG(wwin, no_shadeable, WFLAGP(wwin, no_titlebar));
 844
 845     if (floating) {
 846         if (!WFLAGP(wwin, floating))
 847             ChangeStackingLevel(wwin->frame->core, WMFloatingLevel);
 848     } else if (sunken) {
 849         if (!WFLAGP(wwin, sunken))
 850             ChangeStackingLevel(wwin->frame->core, WMSunkenLevel);
 851     } else {
 852         if (WFLAGP(wwin, floating) || WFLAGP(wwin, sunken))
 853             ChangeStackingLevel(wwin->frame->core, WMNormalLevel);
 854     }
 855
 856     WSETUFLAG(wwin, sunken, sunken);
 857     WSETUFLAG(wwin, floating, floating);
 858     wwin->flags.omnipresent = 0;
 859
 860     if (WFLAGP(wwin, skip_window_list) != skip_window_list) {
 861         WSETUFLAG(wwin, skip_window_list, skip_window_list);
 862         UpdateSwitchMenu(wwin->screen_ptr, wwin,
 863                          skip_window_list ? ACTION_REMOVE : ACTION_ADD);
 864     } else {
 865         if (WFLAGP(wwin, omnipresent) != old_omnipresent) {
 866             UpdateSwitchMenu(wwin->screen_ptr, wwin, ACTION_CHANGE_WORKSPACE);
 867         }
 868     }
 869
 870     if (WFLAGP(wwin, no_bind_keys) != old_no_bind_keys) {
 871         if (WFLAGP(wwin, no_bind_keys)) {
 872             XUngrabKey(dpy, AnyKey, AnyModifier, wwin->frame->core->window);
 873         } else {
 874             wWindowSetKeyGrabs(wwin);
 875         }
 876     }
 877
 878     if (WFLAGP(wwin, no_bind_mouse) != old_no_bind_mouse) {
 879         wWindowResetMouseGrabs(wwin);
 880     }
 881
 882     wwin->frame->flags.need_texture_change = 1;
 883     wWindowConfigureBorders(wwin);
 884     wFrameWindowPaint(wwin->frame);
 885
 886     /*
 887      * Can't apply emulate_appicon because it will probably cause problems.
 888      */
 889
 890     if (wapp) {
 891         /* do application wide stuff */
 892         WSETUFLAG(wapp->main_window_desc, start_hidden,
 893                   WMGetButtonSelected(panel->appChk[0]));
 894
 895         WSETUFLAG(wapp->main_window_desc, no_appicon,
 896                   WMGetButtonSelected(panel->appChk[1]));
 897
 898         if (WFLAGP(wapp->main_window_desc, no_appicon))
 899             removeAppIconFor(wapp);
 900         else
 901             makeAppIconFor(wapp);
 902
 903         if (wapp->app_icon && wapp->main_window == wwin->client_win) {
 904             char *file = WMGetTextFieldText(panel->fileText);
 905
 906             if (file[0] == 0) {
 907                 wfree(file);
 908                 file = NULL;
 909             }
 910             wIconChangeImageFile(wapp->app_icon->icon, file);
 911             if (file)
 912                 wfree(file);
 913             wAppIconPaint(wapp->app_icon);
 914         }
 915     }
 916 }
 917
 918
 919
 920
 921 static void
 922 revertSettings(WMButton *button, InspectorPanel *panel)
 923 {
 924     WWindow *wwin = panel->inspected;
 925     WApplication *wapp = wApplicationOf(wwin->main_window);
 926     int i, n;
 927     char *wm_instance = NULL;
 928     char *wm_class = NULL;
 929     int workspace, level;
 930
 931     if (panel->instRb && WMGetButtonSelected(panel->instRb) != 0)
 932         wm_instance = wwin->wm_instance;
 933     else if (panel->clsRb && WMGetButtonSelected(panel->clsRb) != 0)
 934         wm_class = wwin->wm_class;
 935     else if (panel->bothRb && WMGetButtonSelected(panel->bothRb) != 0) {
 936         wm_instance = wwin->wm_instance;
 937         wm_class = wwin->wm_class;
 938     }
 939     memset(&wwin->defined_user_flags, 0, sizeof(WWindowAttributes));
 940     memset(&wwin->user_flags, 0, sizeof(WWindowAttributes));
 941     memset(&wwin->client_flags, 0, sizeof(WWindowAttributes));
 942
 943     wWindowSetupInitialAttributes(wwin, &level, &workspace);
 944
 945     for (i=0; i < 11; i++) {
 946         int flag = 0;
 947
 948         switch (i) {
 949          case 0:
 950             flag = WFLAGP(wwin, no_titlebar);
 951             break;
 952          case 1:
 953             flag = WFLAGP(wwin, no_resizebar);
 954             break;
 955          case 2:
 956             flag = WFLAGP(wwin, no_close_button);
 957             break;
 958          case 3:
 959             flag = WFLAGP(wwin, no_miniaturize_button);
 960             break;
 961          case 4:
 962             flag = WFLAGP(wwin, no_border);
 963             break;
 964          case 5:
 965             flag = WFLAGP(wwin, floating);
 966             break;
 967          case 6:
 968             flag = WFLAGP(wwin, sunken);
 969             break;
 970          case 7:
 971             flag = WFLAGP(wwin, omnipresent);
 972             break;
 973          case 8:
 974             flag = WFLAGP(wwin, start_miniaturized);
 975             break;
 976          case 9:
 977             flag = WFLAGP(wwin, start_maximized!=0);
 978             break;
 979          case 10:
 980             flag = WFLAGP(wwin, skip_window_list);
 981             break;
 982         }
 983         WMSetButtonSelected(panel->attrChk[i], flag);
 984     }
 985     for (i=0; i < 8; i++) {
 986         int flag = 0;
 987
 988         switch (i) {
 989          case 0:
 990             flag = WFLAGP(wwin, no_hide_others);
 991             break;
 992          case 1:
 993             flag = WFLAGP(wwin, no_bind_keys);
 994             break;
 995          case 2:
 996             flag = WFLAGP(wwin, no_bind_mouse);
 997             break;
 998          case 3:
 999             flag = WFLAGP(wwin, dont_move_off);
1000             break;
1001          case 4:
1002             flag = WFLAGP(wwin, no_focusable);
1003             break;
1004          case 5:
1005             flag = WFLAGP(wwin, dont_save_session);
1006             break;
1007          case 6:
1008             flag = WFLAGP(wwin, emulate_appicon);
1009             break;
1010          case 7:
1011             flag = WFLAGP(wwin, full_maximize);
1012             break;
1013 #ifdef XKB_BUTTON_HINT
1014      case 8:
1015         flag = WFLAGP(wwin, no_language_button);
1016         break;
1017 #endif
1018         }
1019         WMSetButtonSelected(panel->moreChk[i], flag);
1020     }
1021     if (panel->appFrm && wapp) {
1022         for (i=0; i < 2; i++) {
1023             int flag = 0;
1024
1025             switch (i) {
1026              case 0:
1027                 flag = WFLAGP(wapp->main_window_desc, start_hidden);
1028                 break;
1029              case 1:
1030                 flag = WFLAGP(wapp->main_window_desc, no_appicon);
1031                 break;
1032             }
1033             WMSetButtonSelected(panel->appChk[i], flag);
1034         }
1035     }
1036     WMSetButtonSelected(panel->alwChk, WFLAGP(wwin, always_user_icon));
1037
1038     showIconFor(WMWidgetScreen(panel->alwChk), panel, wm_instance, wm_class,
1039                 REVERT_TO_DEFAULT);
1040
1041     n = wDefaultGetStartWorkspace(wwin->screen_ptr, wm_instance, wm_class);
1042
1043     if (n >= 0 && n < wwin->screen_ptr->workspace_count) {
1044         WMSetPopUpButtonSelectedItem(panel->wsP, n+1);
1045     } else {
1046         WMSetPopUpButtonSelectedItem(panel->wsP, 0);
1047     }
1048
1049     /* must auto apply, so that there wno't be internal
1050      * inconsistencies between the state in the flags and
1051      * the actual state of the window */
1052     applySettings(panel->applyBtn, panel);
1053 }
1054
1055
1056 static void
1057 chooseIconCallback(WMWidget *self, void *clientData)
1058 {
1059     char *file;
1060     InspectorPanel *panel = (InspectorPanel*)clientData;
1061     int result;
1062
1063     panel->choosingIcon = 1;
1064
1065     WMSetButtonEnabled(panel->browseIconBtn, False);
1066
1067     result = wIconChooserDialog(panel->frame->screen_ptr, &file,
1068                                 panel->inspected->wm_instance,
1069                                 panel->inspected->wm_class);
1070
1071     panel->choosingIcon = 0;
1072
1073     if (!panel->destroyed) { /* kluge */
1074         if (result) {
1075             WMSetTextFieldText(panel->fileText, file);
1076             showIconFor(WMWidgetScreen(self), panel, NULL, NULL,
1077                         USE_TEXT_FIELD);
1078             wfree(file);
1079         }
1080         WMSetButtonEnabled(panel->browseIconBtn, True);
1081     } else {
1082         freeInspector(panel);
1083     }
1084 }
1085
1086
1087 static void
1088 textEditedObserver(void *observerData, WMNotification *notification)
1089 {
1090     InspectorPanel *panel = (InspectorPanel*)observerData;
1091
1092     if ((long)WMGetNotificationClientData(notification) != WMReturnTextMovement)
1093         return;
1094
1095     showIconFor(WMWidgetScreen(panel->win), panel, NULL, NULL,
1096                 USE_TEXT_FIELD);
1097     /*
1098      WMPerformButtonClick(panel->updateIconBtn);
1099      */
1100 }
1101
1102
1103 static void
1104 selectSpecification(WMWidget *bPtr, void *data)
1105 {
1106     InspectorPanel *panel = (InspectorPanel*)data;
1107     char *str;
1108     WWindow *wwin = panel->inspected;
1109
1110
1111     if (bPtr == panel->defaultRb && (wwin->wm_instance || wwin->wm_class)) {
1112         WMSetButtonEnabled(panel->applyBtn, False);
1113     } else {
1114         WMSetButtonEnabled(panel->applyBtn, True);
1115     }
1116
1117     str = wmalloc(16 + strlen(wwin->wm_instance ? wwin->wm_instance : "?")
1118                   + strlen(wwin->wm_class ? wwin->wm_class : "?"));
1119
1120     sprintf(str, "Inspecting  %s.%s",
1121             wwin->wm_instance ? wwin->wm_instance : "?",
1122             wwin->wm_class ? wwin->wm_class : "?");
1123
1124     wFrameWindowChangeTitle(panel->frame->frame, str);
1125
1126     wfree(str);
1127 }
1128
1129
1130
1131
1132 #define SPEC_TEXT "The configuration will apply to all\n"\
1133                      "windows that have their WM_CLASS property"\
1134                      " set to the above selected\nname, when saved."
1135
1136
1137 #define SELEC_TEXT "Click in the window you wish to inspect."
1138
1139
1140
1141 static void
1142 selectWindow(WMWidget *bPtr, void *data)
1143 {
1144     InspectorPanel *panel = (InspectorPanel*)data;
1145     WWindow *wwin = panel->inspected;
1146     WScreen *scr = wwin->screen_ptr;
1147     XEvent event;
1148     WWindow *iwin;
1149
1150     if (XGrabPointer(dpy, scr->root_win, True,
1151                      ButtonPressMask, GrabModeAsync, GrabModeAsync, None,
1152                      wCursor[WCUR_SELECT], CurrentTime)!=GrabSuccess) {
1153         wwarning("could not grab mouse pointer");
1154         return;
1155     }
1156
1157     WMSetLabelText(panel->specLbl, _(SELEC_TEXT));
1158
1159     WMMaskEvent(dpy, ButtonPressMask, &event);
1160
1161     XUngrabPointer(dpy, CurrentTime);
1162
1163     iwin = wWindowFor(event.xbutton.subwindow);
1164
1165     if (iwin && !iwin->flags.internal_window && iwin != wwin
1166         && !iwin->flags.inspector_open) {
1167
1168         iwin->flags.inspector_open = 1;
1169         iwin->inspector = createInspectorForWindow(iwin,
1170                                                    panel->frame->frame_x,
1171                                                    panel->frame->frame_y,
1172                                                    True);
1173         wCloseInspectorForWindow(wwin);
1174     } else {
1175         WMSetLabelText(panel->specLbl, _(SPEC_TEXT));
1176     }
1177 }
1178
1179
1180
1181 static InspectorPanel*
1182 createInspectorForWindow(WWindow *wwin, int xpos, int ypos,
1183                          Bool showSelectPanel)
1184 {
1185     WScreen *scr = wwin->screen_ptr;
1186     InspectorPanel *panel;
1187     Window parent;
1188     int i;
1189     int x, y;
1190     int btn_width, frame_width;
1191     WMButton *selectedBtn = NULL;
1192 #ifdef wrong_behaviour
1193     WMPixmap *pixmap;
1194 #endif
1195
1196
1197     panel = wmalloc(sizeof(InspectorPanel));
1198     memset(panel, 0, sizeof(InspectorPanel));
1199
1200     panel->destroyed = 0;
1201
1202
1203     panel->inspected = wwin;
1204
1205     panel->nextPtr = panelList;
1206     panelList = panel;
1207
1208
1209     panel->win = WMCreateWindow(scr->wmscreen, "windowInspector");
1210     WMResizeWidget(panel->win, PWIDTH, PHEIGHT);
1211
1212
1213     /**** create common stuff ****/
1214
1215     /* command buttons */
1216     /* (PWIDTH - (left and right margin) - (btn interval)) / 3 */
1217     btn_width = (PWIDTH - (2 * 15) - (2 * 10)) / 3;
1218     panel->saveBtn = WMCreateCommandButton(panel->win);
1219     WMSetButtonAction(panel->saveBtn, (WMAction*)saveSettings, panel);
1220     WMMoveWidget(panel->saveBtn, (2 * (btn_width + 10)) + 15, 310);
1221     WMSetButtonText(panel->saveBtn, _("Save"));
1222     WMResizeWidget(panel->saveBtn, btn_width, 28);
1223     if (wPreferences.flags.noupdates || !(wwin->wm_class || wwin->wm_instance))
1224         WMSetButtonEnabled(panel->saveBtn, False);
1225
1226     panel->applyBtn = WMCreateCommandButton(panel->win);
1227     WMSetButtonAction(panel->applyBtn, (WMAction*)applySettings, panel);
1228     WMMoveWidget(panel->applyBtn, btn_width + 10 + 15, 310);
1229     WMSetButtonText(panel->applyBtn, _("Apply"));
1230     WMResizeWidget(panel->applyBtn, btn_width, 28);
1231
1232     panel->revertBtn = WMCreateCommandButton(panel->win);
1233     WMSetButtonAction(panel->revertBtn, (WMAction*)revertSettings, panel);
1234     WMMoveWidget(panel->revertBtn, 15, 310);
1235     WMSetButtonText(panel->revertBtn, _("Reload"));
1236     WMResizeWidget(panel->revertBtn, btn_width, 28);
1237
1238     /* page selection popup button */
1239     panel->pagePopUp = WMCreatePopUpButton(panel->win);
1240     WMSetPopUpButtonAction(panel->pagePopUp, (WMAction*)changePage, panel);
1241     WMMoveWidget(panel->pagePopUp, 25, 15);
1242     WMResizeWidget(panel->pagePopUp, PWIDTH - 50, 20);
1243
1244     WMAddPopUpButtonItem(panel->pagePopUp, _("Window Specification"));
1245     WMAddPopUpButtonItem(panel->pagePopUp, _("Window Attributes"));
1246     WMAddPopUpButtonItem(panel->pagePopUp, _("Advanced Options"));
1247     WMAddPopUpButtonItem(panel->pagePopUp, _("Icon and Initial Workspace"));
1248     WMAddPopUpButtonItem(panel->pagePopUp, _("Application Specific"));
1249
1250     /**** window spec ****/
1251     frame_width = PWIDTH - (2 * 15);
1252
1253     panel->specFrm = WMCreateFrame(panel->win);
1254     WMSetFrameTitle(panel->specFrm, _("Window Specification"));
1255     WMMoveWidget(panel->specFrm, 15, 65);
1256     WMResizeWidget(panel->specFrm, frame_width, 145);
1257
1258
1259     panel->defaultRb = WMCreateRadioButton(panel->specFrm);
1260     WMMoveWidget(panel->defaultRb, 10, 78);
1261     WMResizeWidget(panel->defaultRb, frame_width - (2 * 10), 20);
1262     WMSetButtonText(panel->defaultRb, _("Defaults for all windows"));
1263     WMSetButtonSelected(panel->defaultRb, False);
1264     WMSetButtonAction(panel->defaultRb, selectSpecification, panel);
1265
1266     if (wwin->wm_class && wwin->wm_instance) {
1267         char *str, *tmp;
1268
1269         tmp = wstrappend(wwin->wm_instance, ".");
1270         str = wstrappend(tmp, wwin->wm_class);
1271
1272         panel->bothRb = WMCreateRadioButton(panel->specFrm);
1273         WMMoveWidget(panel->bothRb, 10, 18);
1274         WMResizeWidget(panel->bothRb, frame_width - (2 * 10), 20);
1275         WMSetButtonText(panel->bothRb, str);
1276         wfree(tmp);
1277         wfree(str);
1278         WMGroupButtons(panel->defaultRb, panel->bothRb);
1279
1280         if (!selectedBtn)
1281             selectedBtn = panel->bothRb;
1282
1283         WMSetButtonAction(panel->bothRb, selectSpecification, panel);
1284     }
1285
1286     if (wwin->wm_instance) {
1287         panel->instRb = WMCreateRadioButton(panel->specFrm);
1288         WMMoveWidget(panel->instRb, 10, 38);
1289         WMResizeWidget(panel->instRb, frame_width - (2 * 10), 20);
1290         WMSetButtonText(panel->instRb, wwin->wm_instance);
1291         WMGroupButtons(panel->defaultRb, panel->instRb);
1292
1293         if (!selectedBtn)
1294             selectedBtn = panel->instRb;
1295
1296         WMSetButtonAction(panel->instRb, selectSpecification, panel);
1297     }
1298
1299     if (wwin->wm_class) {
1300         panel->clsRb = WMCreateRadioButton(panel->specFrm);
1301         WMMoveWidget(panel->clsRb, 10, 58);
1302         WMResizeWidget(panel->clsRb, frame_width - (2 * 10), 20);
1303         WMSetButtonText(panel->clsRb, wwin->wm_class);
1304         WMGroupButtons(panel->defaultRb, panel->clsRb);
1305
1306         if (!selectedBtn)
1307             selectedBtn = panel->clsRb;
1308
1309         WMSetButtonAction(panel->clsRb, selectSpecification, panel);
1310     }
1311
1312
1313     panel->selWinB = WMCreateCommandButton(panel->specFrm);
1314     WMMoveWidget(panel->selWinB, 20, 145-24 - 10);
1315     WMResizeWidget(panel->selWinB, frame_width - 2*10 - 20, 24);
1316     WMSetButtonText(panel->selWinB, _("Select Window"));
1317     WMSetButtonAction(panel->selWinB, selectWindow, panel);
1318
1319
1320     panel->specLbl = WMCreateLabel(panel->win);
1321     WMMoveWidget(panel->specLbl, 15, 210);
1322     WMResizeWidget(panel->specLbl, frame_width, 100);
1323     WMSetLabelText(panel->specLbl, _(SPEC_TEXT));
1324
1325     WMSetLabelTextAlignment(panel->specLbl, WACenter);
1326
1327     /**** attributes ****/
1328     panel->attrFrm = WMCreateFrame(panel->win);
1329     WMSetFrameTitle(panel->attrFrm, _("Attributes"));
1330     WMMoveWidget(panel->attrFrm, 15, 45);
1331     WMResizeWidget(panel->attrFrm, frame_width, 250);
1332
1333     for (i=0; i < 11; i++) {
1334         char *caption = NULL;
1335         int flag = 0;
1336         char *descr = NULL;
1337
1338         switch (i) {
1339          case 0:
1340             caption = _("Disable Titlebar");
1341             flag = WFLAGP(wwin, no_titlebar);
1342             descr = _("Remove the titlebar of this window.\n"
1343                       "To access the window commands menu of a window\n"
1344                       "without it's titlebar, press Control+Esc (or the\n"
1345                       "equivalent shortcut, if you changed the default\n"
1346                       "settings).");
1347             break;
1348          case 1:
1349             caption = _("Disable Resizebar");
1350             flag = WFLAGP(wwin, no_resizebar);
1351             descr = _("Remove the resizebar of this window.");
1352             break;
1353          case 2:
1354             caption = _("Disable Close Button");
1355             flag = WFLAGP(wwin, no_close_button);
1356             descr = _("Remove the `close window' button of this window.");
1357             break;
1358          case 3:
1359             caption = _("Disable Miniaturize Button");
1360             flag = WFLAGP(wwin, no_miniaturize_button);
1361             descr = _("Remove the `miniaturize window' button of the window.");
1362             break;
1363          case 4:
1364             caption = _("Disable Border");
1365             flag = WFLAGP(wwin, no_border);
1366             descr = _("Remove the 1 pixel black border around the window.");
1367             break;
1368          case 5:
1369             caption = _("Keep on Top / Floating");
1370             flag = WFLAGP(wwin, floating);
1371             descr = _("Keep the window over other windows, not allowing\n"
1372                       "them to covert it.");
1373             break;
1374          case 6:
1375             caption = _("Keep at Bottom / Sunken");
1376             flag = WFLAGP(wwin, sunken);
1377             descr = _("Keep the window under all other windows.");
1378             break;
1379          case 7:
1380             caption = _("Omnipresent");
1381             flag = WFLAGP(wwin, omnipresent);
1382             descr = _("Make window occupy all workspaces.");
1383             break;
1384          case 8:
1385             caption = _("Start Miniaturized");
1386             flag = WFLAGP(wwin, start_miniaturized);
1387             descr = _("Make the window be automatically miniaturized when it's\n"
1388                     "first shown.");
1389             break;
1390          case 9:
1391             caption = _("Start Maximized");
1392             flag = WFLAGP(wwin, start_maximized!=0);
1393             descr = _("Make the window be automatically maximized when it's\n"
1394                     "first shown.");
1395             break;
1396          case 10:
1397             caption = _("Skip Window List");
1398             flag = WFLAGP(wwin, skip_window_list);
1399             descr = _("Do not list the window in the window list menu.");
1400             break;
1401         }
1402         panel->attrChk[i] = WMCreateSwitchButton(panel->attrFrm);
1403         WMMoveWidget(panel->attrChk[i], 10, 20*(i+1));
1404         WMResizeWidget(panel->attrChk[i], frame_width-15, 20);
1405         WMSetButtonSelected(panel->attrChk[i], flag);
1406         WMSetButtonText(panel->attrChk[i], caption);
1407
1408         WMSetBalloonTextForView(descr, WMWidgetView(panel->attrChk[i]));
1409     }
1410
1411
1412     /**** more attributes ****/
1413     panel->moreFrm = WMCreateFrame(panel->win);
1414     WMSetFrameTitle(panel->moreFrm, _("Advanced"));
1415     WMMoveWidget(panel->moreFrm, 15, 45);
1416     WMResizeWidget(panel->moreFrm, frame_width, 250);
1417
1418     for (i=0;
1419 #ifdef XKB_BUTTON_HINT
1420          i < 9;
1421 #else
1422          i < 8;
1423 #endif
1424          i++) {
1425         char *caption = NULL;
1426         int flag = 0;
1427         char *descr = NULL;
1428
1429         switch (i) {
1430          case 0:
1431             caption = _("Ignore HideOthers");
1432             flag = WFLAGP(wwin, no_hide_others);
1433             descr = _("Do not hide the window when issuing the\n"
1434                       "`HideOthers' command.");
1435             break;
1436          case 1:
1437             caption = _("Don't Bind Keyboard Shortcuts");
1438             flag = WFLAGP(wwin, no_bind_keys);
1439             descr = _("Do not bind keyboard shortcuts from Window Maker\n"
1440                       "when this window is focused. This will allow the\n"
1441                       "window to receive all key combinations regardless\n"
1442                       "of your shortcut configuration.");
1443             break;
1444          case 2:
1445             caption = _("Don't Bind Mouse Clicks");
1446             flag = WFLAGP(wwin, no_bind_mouse);
1447             descr = _("Do not bind mouse actions, such as `Alt'+drag\n"
1448                       "in the window (when alt is the modifier you have"
1449                       "configured).");
1450             break;
1451          case 3:
1452             caption = _("Keep Inside Screen");
1453             flag = WFLAGP(wwin, dont_move_off);
1454             descr = _("Do not allow the window to move itself completely\n"
1455                       "outside the screen. For bug compatibility.\n");
1456             break;
1457          case 4:
1458             caption = _("Don't Let It Take Focus");
1459             flag = WFLAGP(wwin, no_focusable);
1460             descr = _("Do not let the window take keyboard focus when you\n"
1461                       "click on it.");
1462             break;
1463          case 5:
1464             caption = _("Don't Save Session");
1465             flag = WFLAGP(wwin, dont_save_session);
1466             descr = _("Do not save the associated application in the\n"
1467                       "session's state, so that it won't be restarted\n"
1468                       "together with other applications when Window Maker\n"
1469                       "starts.");
1470             break;
1471          case 6:
1472             caption = _("Emulate Application Icon");
1473             flag = WFLAGP(wwin, emulate_appicon);
1474             descr = _("Make this window act as an application that provides\n"
1475                       "enough information to Window Maker for a dockable\n"
1476                       "application icon to be created.");
1477             break;
1478          case 7:
1479             caption = _("Full Screen Maximization");
1480             flag = WFLAGP(wwin, full_maximize);
1481             descr = _("Make the window use the whole screen space when it's\n"
1482                       "maximized. The titlebar and resizebar will be moved\n"
1483                       "to outside the screen.");
1484             break;
1485 #ifdef XKB_BUTTON_HINT
1486      case 8:
1487         caption = _("Disable Language Button");
1488         flag = WFLAGP(wwin, no_language_button);
1489         descr = _("Remove the `toggle language' button of the window.");
1490         break;
1491 #endif
1492         }
1493         panel->moreChk[i] = WMCreateSwitchButton(panel->moreFrm);
1494         WMMoveWidget(panel->moreChk[i], 10, 20*(i+1));
1495         WMResizeWidget(panel->moreChk[i], frame_width-15, 20);
1496         WMSetButtonSelected(panel->moreChk[i], flag);
1497         WMSetButtonText(panel->moreChk[i], caption);
1498
1499         WMSetBalloonTextForView(descr, WMWidgetView(panel->moreChk[i]));
1500     }
1501
1502     /* miniwindow/workspace */
1503     panel->iconFrm = WMCreateFrame(panel->win);
1504     WMMoveWidget(panel->iconFrm, 15, 50);
1505     WMResizeWidget(panel->iconFrm,  PWIDTH - (2 * 15), 170);
1506     WMSetFrameTitle(panel->iconFrm, _("Miniwindow Image"));
1507
1508     panel->iconLbl = WMCreateLabel(panel->iconFrm);
1509     WMMoveWidget(panel->iconLbl, PWIDTH - (2 * 15) - 22 - 64, 20);
1510     WMResizeWidget(panel->iconLbl, 64, 64);
1511     WMSetLabelRelief(panel->iconLbl, WRGroove);
1512     WMSetLabelImagePosition(panel->iconLbl, WIPImageOnly);
1513
1514     panel->browseIconBtn = WMCreateCommandButton(panel->iconFrm);
1515     WMSetButtonAction(panel->browseIconBtn, chooseIconCallback, panel);
1516     WMMoveWidget(panel->browseIconBtn, 22, 32);
1517     WMResizeWidget(panel->browseIconBtn, 120, 26);
1518     WMSetButtonText(panel->browseIconBtn, _("Browse..."));
1519
1520 #ifdef wrong_behaviour
1521     WMSetButtonImagePosition(panel->updateIconBtn, WIPRight);
1522     pixmap = WMGetSystemPixmap(scr->wmscreen, WSIReturnArrow);
1523     WMSetButtonImage(panel->updateIconBtn, pixmap);
1524     WMReleasePixmap(pixmap);
1525     pixmap = WMGetSystemPixmap(scr->wmscreen, WSIHighlightedReturnArrow);
1526     WMSetButtonAltImage(panel->updateIconBtn, pixmap);
1527     WMReleasePixmap(pixmap);
1528 #endif
1529
1530     panel->fileLbl = WMCreateLabel(panel->iconFrm);
1531     WMMoveWidget(panel->fileLbl, 20, 85);
1532     WMResizeWidget(panel->fileLbl, PWIDTH - (2 * 15) - (2 * 20), 14);
1533     WMSetLabelText(panel->fileLbl, _("Icon File Name:"));
1534
1535     panel->fileText = WMCreateTextField(panel->iconFrm);
1536     WMMoveWidget(panel->fileText, 20, 105);
1537     WMResizeWidget(panel->fileText, PWIDTH - (2 * 20) - (2 * 15), 20);
1538     WMSetTextFieldText(panel->fileText, NULL);
1539     WMAddNotificationObserver(textEditedObserver, panel,
1540                               WMTextDidEndEditingNotification,
1541                               panel->fileText);
1542
1543     panel->alwChk = WMCreateSwitchButton(panel->iconFrm);
1544     WMMoveWidget(panel->alwChk, 20, 130);
1545     WMResizeWidget(panel->alwChk, PWIDTH - (2 * 15) - (2 * 15), 30);
1546     WMSetButtonText(panel->alwChk, _("Ignore client supplied icon"));
1547     WMSetButtonSelected(panel->alwChk, WFLAGP(wwin, always_user_icon));
1548
1549
1550     panel->wsFrm = WMCreateFrame(panel->win);
1551     WMMoveWidget(panel->wsFrm, 15, 225);
1552     WMResizeWidget(panel->wsFrm, PWIDTH - (2 * 15), 70);
1553     WMSetFrameTitle(panel->wsFrm, _("Initial Workspace"));
1554
1555     WMSetBalloonTextForView(_("The workspace to place the window when it's"
1556                               "first shown."), WMWidgetView(panel->wsFrm));
1557
1558     panel->wsP = WMCreatePopUpButton(panel->wsFrm);
1559     WMMoveWidget(panel->wsP, 20, 30);
1560     WMResizeWidget(panel->wsP, PWIDTH - (2 * 15) - (2 * 20), 20);
1561     WMAddPopUpButtonItem(panel->wsP, _("Nowhere in particular"));
1562     for (i = 0; i < wwin->screen_ptr->workspace_count; i++) {
1563         WMAddPopUpButtonItem(panel->wsP, scr->workspaces[i]->name);
1564     }
1565
1566     i = wDefaultGetStartWorkspace(wwin->screen_ptr, wwin->wm_instance,
1567                                   wwin->wm_class);
1568     if (i >= 0 && i <= wwin->screen_ptr->workspace_count) {
1569         WMSetPopUpButtonSelectedItem(panel->wsP, i + 1);
1570     } else {
1571         WMSetPopUpButtonSelectedItem(panel->wsP, 0);
1572     }
1573
1574     /* application wide attributes */
1575     if (wwin->main_window != None) {
1576         WApplication *wapp = wApplicationOf(wwin->main_window);
1577
1578         panel->appFrm = WMCreateFrame(panel->win);
1579         WMSetFrameTitle(panel->appFrm, _("Application Wide"));
1580         WMMoveWidget(panel->appFrm, 15, 50);
1581         WMResizeWidget(panel->appFrm, frame_width, 240);
1582
1583         for (i=0; i < 2; i++) {
1584             char *caption = NULL;
1585             int flag = 0;
1586             char *descr = NULL;
1587
1588             switch (i) {
1589              case 0:
1590                 caption = _("Start Hidden");
1591                 flag = WFLAGP(wapp->main_window_desc, start_hidden);
1592                 descr = _("Automatically hide application when it's started.");
1593                 break;
1594              case 1:
1595                 caption = _("No Application Icon");
1596                 flag = WFLAGP(wapp->main_window_desc, no_appicon);
1597                 descr = _("Disable the application icon for the application.\n"
1598                           "Note that you won't be able to dock it anymore,\n"
1599                           "and any icons that are already docked will stop\n"
1600                           "working correctly.");
1601                 break;
1602             }
1603             panel->appChk[i] = WMCreateSwitchButton(panel->appFrm);
1604             WMMoveWidget(panel->appChk[i], 10, 20*(i+1));
1605             WMResizeWidget(panel->appChk[i], 205, 20);
1606             WMSetButtonSelected(panel->appChk[i], flag);
1607             WMSetButtonText(panel->appChk[i], caption);
1608
1609             WMSetBalloonTextForView(descr, WMWidgetView(panel->appChk[i]));
1610         }
1611
1612         if (WFLAGP(wwin, emulate_appicon)) {
1613             WMSetButtonEnabled(panel->appChk[1], False);
1614             WMSetButtonEnabled(panel->moreChk[6], True);
1615         } else {
1616             WMSetButtonEnabled(panel->appChk[1], True);
1617             WMSetButtonEnabled(panel->moreChk[6], False);
1618         }
1619     } else {
1620         int tmp;
1621
1622         if ((wwin->transient_for!=None && wwin->transient_for!=scr->root_win)
1623             || !wwin->wm_class || !wwin->wm_instance)
1624             tmp = False;
1625         else
1626             tmp = True;
1627         WMSetButtonEnabled(panel->moreChk[6], tmp);
1628
1629         WMSetPopUpButtonItemEnabled(panel->pagePopUp, 4, False);
1630         panel->appFrm = NULL;
1631     }
1632
1633     /* if the window is a transient, don't let it have a miniaturize
1634      * button */
1635     if (wWindowFor(wwin->transient_for)!=NULL)
1636         WMSetButtonEnabled(panel->attrChk[3], False);
1637     else
1638         WMSetButtonEnabled(panel->attrChk[3], True);
1639
1640
1641     if (!wwin->wm_class && !wwin->wm_instance) {
1642         WMSetPopUpButtonItemEnabled(panel->pagePopUp, 0, False);
1643     }
1644
1645
1646     WMRealizeWidget(panel->win);
1647
1648     WMMapSubwidgets(panel->win);
1649     WMMapSubwidgets(panel->specFrm);
1650     WMMapSubwidgets(panel->attrFrm);
1651     WMMapSubwidgets(panel->moreFrm);
1652     WMMapSubwidgets(panel->iconFrm);
1653     WMMapSubwidgets(panel->wsFrm);
1654     if (panel->appFrm)
1655         WMMapSubwidgets(panel->appFrm);
1656
1657     if (showSelectPanel) {
1658         WMSetPopUpButtonSelectedItem(panel->pagePopUp, 0);
1659         changePage(panel->pagePopUp, panel);
1660     } else {
1661         WMSetPopUpButtonSelectedItem(panel->pagePopUp, 1);
1662         changePage(panel->pagePopUp, panel);
1663     }
1664
1665
1666     parent = XCreateSimpleWindow(dpy, scr->root_win, 0, 0, PWIDTH, PHEIGHT,
1667                                  0, 0, 0);
1668     XSelectInput(dpy, parent, KeyPressMask|KeyReleaseMask);
1669     panel->parent = parent;
1670     XReparentWindow(dpy, WMWidgetXID(panel->win), parent, 0, 0);
1671
1672     WMMapWidget(panel->win);
1673
1674     XSetTransientForHint(dpy, parent, wwin->client_win);
1675
1676     if (xpos == UNDEFINED_POS) {
1677         x = wwin->frame_x+wwin->frame->core->width/2;
1678         y = wwin->frame_y+wwin->frame->top_width*2;
1679         if (y + PHEIGHT > scr->scr_height)
1680             y = scr->scr_height - PHEIGHT - 30;
1681         if (x + PWIDTH > scr->scr_width)
1682             x = scr->scr_width - PWIDTH;
1683     } else {
1684         x = xpos;
1685         y = ypos;
1686     }
1687
1688     panel->frame = wManageInternalWindow(scr, parent, wwin->client_win,
1689                                          "Inspector", x, y, PWIDTH, PHEIGHT);
1690
1691     if (!selectedBtn)
1692         selectedBtn = panel->defaultRb;
1693
1694     WMSetButtonSelected(selectedBtn, True);
1695
1696     selectSpecification(selectedBtn, panel);
1697
1698     /* kluge to know who should get the key events */
1699     panel->frame->client_leader = WMWidgetXID(panel->win);
1700
1701     WSETUFLAG(panel->frame, no_closable, 0);
1702     WSETUFLAG(panel->frame, no_close_button, 0);
1703     wWindowUpdateButtonImages(panel->frame);
1704     wFrameWindowShowButton(panel->frame->frame, WFF_RIGHT_BUTTON);
1705     panel->frame->frame->on_click_right = destroyInspector;
1706
1707     wWindowMap(panel->frame);
1708
1709     showIconFor(WMWidgetScreen(panel->alwChk), panel, wwin->wm_instance,
1710                 wwin->wm_class, UPDATE_TEXT_FIELD);
1711
1712     return panel;
1713 }
1714
1715
1716 void
1717 wShowInspectorForWindow(WWindow *wwin)
1718 {
1719     if (wwin->flags.inspector_open)
1720         return;
1721
1722     WMSetBalloonEnabled(wwin->screen_ptr->wmscreen, wPreferences.help_balloon);
1723
1724     make_keys();
1725     wwin->flags.inspector_open = 1;
1726     wwin->inspector = createInspectorForWindow(wwin, UNDEFINED_POS,
1727                                                UNDEFINED_POS, False);
1728 }
1729
1730
1731
1732
1733 void
1734 wHideInspectorForWindow(WWindow *wwin)
1735 {
1736     WWindow *pwin = wwin->inspector->frame;
1737
1738     wWindowUnmap(pwin);
1739     pwin->flags.hidden = 1;
1740
1741     wClientSetState(pwin, IconicState, None);
1742 }
1743
1744
1745
1746 void
1747 wUnhideInspectorForWindow(WWindow *wwin)
1748 {
1749     WWindow *pwin = wwin->inspector->frame;
1750
1751     pwin->flags.hidden = 0;
1752     pwin->flags.mapped = 1;
1753     XMapWindow(dpy, pwin->client_win);
1754     XMapWindow(dpy, pwin->frame->core->window);
1755     wClientSetState(pwin, NormalState, None);
1756 }
1757
1758
1759
1760 WWindow*
1761 wGetWindowOfInspectorForWindow(WWindow *wwin)
1762 {
1763     if (wwin->inspector) {
1764         assert(wwin->flags.inspector_open != 0);
1765
1766         return wwin->inspector->frame;
1767     } else
1768         return NULL;
1769 }
1770
1771
1772 void
1773 wCloseInspectorForWindow(WWindow *wwin)
1774 {
1775     WWindow *pwin = wwin->inspector->frame; /* the inspector window */
1776
1777     (*pwin->frame->on_click_right)(NULL, pwin, NULL);
1778 }
1779
1780