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 = wstrconcat(wwin->wm_instance, ".");
1270         str = wstrconcat(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     WMSetLabelWraps(panel->specLbl, True);
1325
1326     WMSetLabelTextAlignment(panel->specLbl, WALeft);
1327
1328     /**** attributes ****/
1329     panel->attrFrm = WMCreateFrame(panel->win);
1330     WMSetFrameTitle(panel->attrFrm, _("Attributes"));
1331     WMMoveWidget(panel->attrFrm, 15, 45);
1332     WMResizeWidget(panel->attrFrm, frame_width, 250);
1333
1334     for (i=0; i < 11; i++) {
1335         char *caption = NULL;
1336         int flag = 0;
1337         char *descr = NULL;
1338
1339         switch (i) {
1340          case 0:
1341             caption = _("Disable Titlebar");
1342             flag = WFLAGP(wwin, no_titlebar);
1343             descr = _("Remove the titlebar of this window.\n"
1344                       "To access the window commands menu of a window\n"
1345                       "without it's titlebar, press Control+Esc (or the\n"
1346                       "equivalent shortcut, if you changed the default\n"
1347                       "settings).");
1348             break;
1349          case 1:
1350             caption = _("Disable Resizebar");
1351             flag = WFLAGP(wwin, no_resizebar);
1352             descr = _("Remove the resizebar of this window.");
1353             break;
1354          case 2:
1355             caption = _("Disable Close Button");
1356             flag = WFLAGP(wwin, no_close_button);
1357             descr = _("Remove the `close window' button of this window.");
1358             break;
1359          case 3:
1360             caption = _("Disable Miniaturize Button");
1361             flag = WFLAGP(wwin, no_miniaturize_button);
1362             descr = _("Remove the `miniaturize window' button of the window.");
1363             break;
1364          case 4:
1365             caption = _("Disable Border");
1366             flag = WFLAGP(wwin, no_border);
1367             descr = _("Remove the 1 pixel black border around the window.");
1368             break;
1369          case 5:
1370             caption = _("Keep on Top / Floating");
1371             flag = WFLAGP(wwin, floating);
1372             descr = _("Keep the window over other windows, not allowing\n"
1373                       "them to covert it.");
1374             break;
1375          case 6:
1376             caption = _("Keep at Bottom / Sunken");
1377             flag = WFLAGP(wwin, sunken);
1378             descr = _("Keep the window under all other windows.");
1379             break;
1380          case 7:
1381             caption = _("Omnipresent");
1382             flag = WFLAGP(wwin, omnipresent);
1383             descr = _("Make window occupy all workspaces.");
1384             break;
1385          case 8:
1386             caption = _("Start Miniaturized");
1387             flag = WFLAGP(wwin, start_miniaturized);
1388             descr = _("Make the window be automatically miniaturized when it's\n"
1389                     "first shown.");
1390             break;
1391          case 9:
1392             caption = _("Start Maximized");
1393             flag = WFLAGP(wwin, start_maximized!=0);
1394             descr = _("Make the window be automatically maximized when it's\n"
1395                     "first shown.");
1396             break;
1397          case 10:
1398             caption = _("Skip Window List");
1399             flag = WFLAGP(wwin, skip_window_list);
1400             descr = _("Do not list the window in the window list menu.");
1401             break;
1402         }
1403         panel->attrChk[i] = WMCreateSwitchButton(panel->attrFrm);
1404         WMMoveWidget(panel->attrChk[i], 10, 20*(i+1));
1405         WMResizeWidget(panel->attrChk[i], frame_width-15, 20);
1406         WMSetButtonSelected(panel->attrChk[i], flag);
1407         WMSetButtonText(panel->attrChk[i], caption);
1408
1409         WMSetBalloonTextForView(descr, WMWidgetView(panel->attrChk[i]));
1410     }
1411
1412
1413     /**** more attributes ****/
1414     panel->moreFrm = WMCreateFrame(panel->win);
1415     WMSetFrameTitle(panel->moreFrm, _("Advanced"));
1416     WMMoveWidget(panel->moreFrm, 15, 45);
1417     WMResizeWidget(panel->moreFrm, frame_width, 250);
1418
1419     for (i=0;
1420 #ifdef XKB_BUTTON_HINT
1421          i < 9;
1422 #else
1423          i < 8;
1424 #endif
1425          i++) {
1426         char *caption = NULL;
1427         int flag = 0;
1428         char *descr = NULL;
1429
1430         switch (i) {
1431          case 0:
1432             caption = _("Ignore HideOthers");
1433             flag = WFLAGP(wwin, no_hide_others);
1434             descr = _("Do not hide the window when issuing the\n"
1435                       "`HideOthers' command.");
1436             break;
1437          case 1:
1438             caption = _("Don't Bind Keyboard Shortcuts");
1439             flag = WFLAGP(wwin, no_bind_keys);
1440             descr = _("Do not bind keyboard shortcuts from Window Maker\n"
1441                       "when this window is focused. This will allow the\n"
1442                       "window to receive all key combinations regardless\n"
1443                       "of your shortcut configuration.");
1444             break;
1445          case 2:
1446             caption = _("Don't Bind Mouse Clicks");
1447             flag = WFLAGP(wwin, no_bind_mouse);
1448             descr = _("Do not bind mouse actions, such as `Alt'+drag\n"
1449                       "in the window (when alt is the modifier you have"
1450                       "configured).");
1451             break;
1452          case 3:
1453             caption = _("Keep Inside Screen");
1454             flag = WFLAGP(wwin, dont_move_off);
1455             descr = _("Do not allow the window to move itself completely\n"
1456                       "outside the screen. For bug compatibility.\n");
1457             break;
1458          case 4:
1459             caption = _("Don't Let It Take Focus");
1460             flag = WFLAGP(wwin, no_focusable);
1461             descr = _("Do not let the window take keyboard focus when you\n"
1462                       "click on it.");
1463             break;
1464          case 5:
1465             caption = _("Don't Save Session");
1466             flag = WFLAGP(wwin, dont_save_session);
1467             descr = _("Do not save the associated application in the\n"
1468                       "session's state, so that it won't be restarted\n"
1469                       "together with other applications when Window Maker\n"
1470                       "starts.");
1471             break;
1472          case 6:
1473             caption = _("Emulate Application Icon");
1474             flag = WFLAGP(wwin, emulate_appicon);
1475             descr = _("Make this window act as an application that provides\n"
1476                       "enough information to Window Maker for a dockable\n"
1477                       "application icon to be created.");
1478             break;
1479          case 7:
1480             caption = _("Full Screen Maximization");
1481             flag = WFLAGP(wwin, full_maximize);
1482             descr = _("Make the window use the whole screen space when it's\n"
1483                       "maximized. The titlebar and resizebar will be moved\n"
1484                       "to outside the screen.");
1485             break;
1486 #ifdef XKB_BUTTON_HINT
1487      case 8:
1488         caption = _("Disable Language Button");
1489         flag = WFLAGP(wwin, no_language_button);
1490         descr = _("Remove the `toggle language' button of the window.");
1491         break;
1492 #endif
1493         }
1494         panel->moreChk[i] = WMCreateSwitchButton(panel->moreFrm);
1495         WMMoveWidget(panel->moreChk[i], 10, 20*(i+1));
1496         WMResizeWidget(panel->moreChk[i], frame_width-15, 20);
1497         WMSetButtonSelected(panel->moreChk[i], flag);
1498         WMSetButtonText(panel->moreChk[i], caption);
1499
1500         WMSetBalloonTextForView(descr, WMWidgetView(panel->moreChk[i]));
1501     }
1502
1503     /* miniwindow/workspace */
1504     panel->iconFrm = WMCreateFrame(panel->win);
1505     WMMoveWidget(panel->iconFrm, 15, 50);
1506     WMResizeWidget(panel->iconFrm,  PWIDTH - (2 * 15), 170);
1507     WMSetFrameTitle(panel->iconFrm, _("Miniwindow Image"));
1508
1509     panel->iconLbl = WMCreateLabel(panel->iconFrm);
1510     WMMoveWidget(panel->iconLbl, PWIDTH - (2 * 15) - 22 - 64, 20);
1511     WMResizeWidget(panel->iconLbl, 64, 64);
1512     WMSetLabelRelief(panel->iconLbl, WRGroove);
1513     WMSetLabelImagePosition(panel->iconLbl, WIPImageOnly);
1514
1515     panel->browseIconBtn = WMCreateCommandButton(panel->iconFrm);
1516     WMSetButtonAction(panel->browseIconBtn, chooseIconCallback, panel);
1517     WMMoveWidget(panel->browseIconBtn, 22, 32);
1518     WMResizeWidget(panel->browseIconBtn, 120, 26);
1519     WMSetButtonText(panel->browseIconBtn, _("Browse..."));
1520
1521 #ifdef wrong_behaviour
1522     WMSetButtonImagePosition(panel->updateIconBtn, WIPRight);
1523     pixmap = WMGetSystemPixmap(scr->wmscreen, WSIReturnArrow);
1524     WMSetButtonImage(panel->updateIconBtn, pixmap);
1525     WMReleasePixmap(pixmap);
1526     pixmap = WMGetSystemPixmap(scr->wmscreen, WSIHighlightedReturnArrow);
1527     WMSetButtonAltImage(panel->updateIconBtn, pixmap);
1528     WMReleasePixmap(pixmap);
1529 #endif
1530
1531     panel->fileLbl = WMCreateLabel(panel->iconFrm);
1532     WMMoveWidget(panel->fileLbl, 20, 85);
1533     WMResizeWidget(panel->fileLbl, PWIDTH - (2 * 15) - (2 * 20), 14);
1534     WMSetLabelText(panel->fileLbl, _("Icon File Name:"));
1535
1536     panel->fileText = WMCreateTextField(panel->iconFrm);
1537     WMMoveWidget(panel->fileText, 20, 105);
1538     WMResizeWidget(panel->fileText, PWIDTH - (2 * 20) - (2 * 15), 20);
1539     WMSetTextFieldText(panel->fileText, NULL);
1540     WMAddNotificationObserver(textEditedObserver, panel,
1541                               WMTextDidEndEditingNotification,
1542                               panel->fileText);
1543
1544     panel->alwChk = WMCreateSwitchButton(panel->iconFrm);
1545     WMMoveWidget(panel->alwChk, 20, 130);
1546     WMResizeWidget(panel->alwChk, PWIDTH - (2 * 15) - (2 * 15), 30);
1547     WMSetButtonText(panel->alwChk, _("Ignore client supplied icon"));
1548     WMSetButtonSelected(panel->alwChk, WFLAGP(wwin, always_user_icon));
1549
1550
1551     panel->wsFrm = WMCreateFrame(panel->win);
1552     WMMoveWidget(panel->wsFrm, 15, 225);
1553     WMResizeWidget(panel->wsFrm, PWIDTH - (2 * 15), 70);
1554     WMSetFrameTitle(panel->wsFrm, _("Initial Workspace"));
1555
1556     WMSetBalloonTextForView(_("The workspace to place the window when it's"
1557                               "first shown."), WMWidgetView(panel->wsFrm));
1558
1559     panel->wsP = WMCreatePopUpButton(panel->wsFrm);
1560     WMMoveWidget(panel->wsP, 20, 30);
1561     WMResizeWidget(panel->wsP, PWIDTH - (2 * 15) - (2 * 20), 20);
1562     WMAddPopUpButtonItem(panel->wsP, _("Nowhere in particular"));
1563     for (i = 0; i < wwin->screen_ptr->workspace_count; i++) {
1564         WMAddPopUpButtonItem(panel->wsP, scr->workspaces[i]->name);
1565     }
1566
1567     i = wDefaultGetStartWorkspace(wwin->screen_ptr, wwin->wm_instance,
1568                                   wwin->wm_class);
1569     if (i >= 0 && i <= wwin->screen_ptr->workspace_count) {
1570         WMSetPopUpButtonSelectedItem(panel->wsP, i + 1);
1571     } else {
1572         WMSetPopUpButtonSelectedItem(panel->wsP, 0);
1573     }
1574
1575     /* application wide attributes */
1576     if (wwin->main_window != None) {
1577         WApplication *wapp = wApplicationOf(wwin->main_window);
1578
1579         panel->appFrm = WMCreateFrame(panel->win);
1580         WMSetFrameTitle(panel->appFrm, _("Application Wide"));
1581         WMMoveWidget(panel->appFrm, 15, 50);
1582         WMResizeWidget(panel->appFrm, frame_width, 240);
1583
1584         for (i=0; i < 2; i++) {
1585             char *caption = NULL;
1586             int flag = 0;
1587             char *descr = NULL;
1588
1589             switch (i) {
1590              case 0:
1591                 caption = _("Start Hidden");
1592                 flag = WFLAGP(wapp->main_window_desc, start_hidden);
1593                 descr = _("Automatically hide application when it's started.");
1594                 break;
1595              case 1:
1596                 caption = _("No Application Icon");
1597                 flag = WFLAGP(wapp->main_window_desc, no_appicon);
1598                 descr = _("Disable the application icon for the application.\n"
1599                           "Note that you won't be able to dock it anymore,\n"
1600                           "and any icons that are already docked will stop\n"
1601                           "working correctly.");
1602                 break;
1603             }
1604             panel->appChk[i] = WMCreateSwitchButton(panel->appFrm);
1605             WMMoveWidget(panel->appChk[i], 10, 20*(i+1));
1606             WMResizeWidget(panel->appChk[i], 205, 20);
1607             WMSetButtonSelected(panel->appChk[i], flag);
1608             WMSetButtonText(panel->appChk[i], caption);
1609
1610             WMSetBalloonTextForView(descr, WMWidgetView(panel->appChk[i]));
1611         }
1612
1613         if (WFLAGP(wwin, emulate_appicon)) {
1614             WMSetButtonEnabled(panel->appChk[1], False);
1615             WMSetButtonEnabled(panel->moreChk[6], True);
1616         } else {
1617             WMSetButtonEnabled(panel->appChk[1], True);
1618             WMSetButtonEnabled(panel->moreChk[6], False);
1619         }
1620     } else {
1621         int tmp;
1622
1623         if ((wwin->transient_for!=None && wwin->transient_for!=scr->root_win)
1624             || !wwin->wm_class || !wwin->wm_instance)
1625             tmp = False;
1626         else
1627             tmp = True;
1628         WMSetButtonEnabled(panel->moreChk[6], tmp);
1629
1630         WMSetPopUpButtonItemEnabled(panel->pagePopUp, 4, False);
1631         panel->appFrm = NULL;
1632     }
1633
1634     /* if the window is a transient, don't let it have a miniaturize
1635      * button */
1636     if (wWindowFor(wwin->transient_for)!=NULL)
1637         WMSetButtonEnabled(panel->attrChk[3], False);
1638     else
1639         WMSetButtonEnabled(panel->attrChk[3], True);
1640
1641
1642     if (!wwin->wm_class && !wwin->wm_instance) {
1643         WMSetPopUpButtonItemEnabled(panel->pagePopUp, 0, False);
1644     }
1645
1646
1647     WMRealizeWidget(panel->win);
1648
1649     WMMapSubwidgets(panel->win);
1650     WMMapSubwidgets(panel->specFrm);
1651     WMMapSubwidgets(panel->attrFrm);
1652     WMMapSubwidgets(panel->moreFrm);
1653     WMMapSubwidgets(panel->iconFrm);
1654     WMMapSubwidgets(panel->wsFrm);
1655     if (panel->appFrm)
1656         WMMapSubwidgets(panel->appFrm);
1657
1658     if (showSelectPanel) {
1659         WMSetPopUpButtonSelectedItem(panel->pagePopUp, 0);
1660         changePage(panel->pagePopUp, panel);
1661     } else {
1662         WMSetPopUpButtonSelectedItem(panel->pagePopUp, 1);
1663         changePage(panel->pagePopUp, panel);
1664     }
1665
1666
1667     parent = XCreateSimpleWindow(dpy, scr->root_win, 0, 0, PWIDTH, PHEIGHT,
1668                                  0, 0, 0);
1669     XSelectInput(dpy, parent, KeyPressMask|KeyReleaseMask);
1670     panel->parent = parent;
1671     XReparentWindow(dpy, WMWidgetXID(panel->win), parent, 0, 0);
1672
1673     WMMapWidget(panel->win);
1674
1675     XSetTransientForHint(dpy, parent, wwin->client_win);
1676
1677     if (xpos == UNDEFINED_POS) {
1678         x = wwin->frame_x+wwin->frame->core->width/2;
1679         y = wwin->frame_y+wwin->frame->top_width*2;
1680         if (y + PHEIGHT > scr->scr_height)
1681             y = scr->scr_height - PHEIGHT - 30;
1682         if (x + PWIDTH > scr->scr_width)
1683             x = scr->scr_width - PWIDTH;
1684     } else {
1685         x = xpos;
1686         y = ypos;
1687     }
1688
1689     panel->frame = wManageInternalWindow(scr, parent, wwin->client_win,
1690                                          "Inspector", x, y, PWIDTH, PHEIGHT);
1691
1692     if (!selectedBtn)
1693         selectedBtn = panel->defaultRb;
1694
1695     WMSetButtonSelected(selectedBtn, True);
1696
1697     selectSpecification(selectedBtn, panel);
1698
1699     /* kluge to know who should get the key events */
1700     panel->frame->client_leader = WMWidgetXID(panel->win);
1701
1702     WSETUFLAG(panel->frame, no_closable, 0);
1703     WSETUFLAG(panel->frame, no_close_button, 0);
1704     wWindowUpdateButtonImages(panel->frame);
1705     wFrameWindowShowButton(panel->frame->frame, WFF_RIGHT_BUTTON);
1706     panel->frame->frame->on_click_right = destroyInspector;
1707
1708     wWindowMap(panel->frame);
1709
1710     showIconFor(WMWidgetScreen(panel->alwChk), panel, wwin->wm_instance,
1711                 wwin->wm_class, UPDATE_TEXT_FIELD);
1712
1713     return panel;
1714 }
1715
1716
1717 void
1718 wShowInspectorForWindow(WWindow *wwin)
1719 {
1720     if (wwin->flags.inspector_open)
1721         return;
1722
1723     WMSetBalloonEnabled(wwin->screen_ptr->wmscreen, wPreferences.help_balloon);
1724
1725     make_keys();
1726     wwin->flags.inspector_open = 1;
1727     wwin->inspector = createInspectorForWindow(wwin, UNDEFINED_POS,
1728                                                UNDEFINED_POS, False);
1729 }
1730
1731
1732
1733
1734 void
1735 wHideInspectorForWindow(WWindow *wwin)
1736 {
1737     WWindow *pwin = wwin->inspector->frame;
1738
1739     wWindowUnmap(pwin);
1740     pwin->flags.hidden = 1;
1741
1742     wClientSetState(pwin, IconicState, None);
1743 }
1744
1745
1746
1747 void
1748 wUnhideInspectorForWindow(WWindow *wwin)
1749 {
1750     WWindow *pwin = wwin->inspector->frame;
1751
1752     pwin->flags.hidden = 0;
1753     pwin->flags.mapped = 1;
1754     XMapWindow(dpy, pwin->client_win);
1755     XMapWindow(dpy, pwin->frame->core->window);
1756     wClientSetState(pwin, NormalState, None);
1757 }
1758
1759
1760
1761 WWindow*
1762 wGetWindowOfInspectorForWindow(WWindow *wwin)
1763 {
1764     if (wwin->inspector) {
1765         assert(wwin->flags.inspector_open != 0);
1766
1767         return wwin->inspector->frame;
1768     } else
1769         return NULL;
1770 }
1771
1772
1773 void
1774 wCloseInspectorForWindow(WWindow *wwin)
1775 {
1776     WWindow *pwin = wwin->inspector->frame; /* the inspector window */
1777
1778     (*pwin->frame->on_click_right)(NULL, pwin, NULL);
1779 }
1780
1781