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