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     char *str;
 992
 993     if (bPtr == panel->defaultRb) {
 994         WMSetButtonEnabled(panel->applyBtn, False);
 995     } else {
 996         WMSetButtonEnabled(panel->applyBtn, True);
 997     }
 998
 999     str = wmalloc(16 + strlen(wwin->wm_instance ? wwin->wm_instance : "?")
1000                   + strlen(wwin->wm_class ? wwin->wm_class : "?"));
1001
1002     sprintf(str, "Inspecting  %s.%s",
1003             wwin->wm_instance ? wwin->wm_instance : "?",
1004             wwin->wm_class ? wwin->wm_class : "?");
1005
1006     wFrameWindowChangeTitle(panel->wwin->frame, str);
1007
1008     free(str);
1009 }
1010
1011
1012 static InspectorPanel*
1013 createInspectorForWindow(WWindow *wwin)
1014 {
1015     WScreen *scr = wwin->screen_ptr;
1016     InspectorPanel *panel;
1017     Window parent;
1018     int i;
1019     int x, y;
1020     int btn_width, frame_width;
1021     WMButton *selectedBtn = NULL;
1022 #ifdef wrong_behaviour
1023     WMPixmap *pixmap;
1024 #endif
1025
1026
1027     panel = wmalloc(sizeof(InspectorPanel));
1028     memset(panel, 0, sizeof(InspectorPanel));
1029
1030     panel->destroyed = 0;
1031
1032
1033     panel->inspected = wwin;
1034
1035     panel->nextPtr = panelList;
1036     panelList = panel;
1037
1038
1039     panel->win = WMCreateWindow(scr->wmscreen, "windowInspector");
1040     WMResizeWidget(panel->win, PWIDTH, PHEIGHT);
1041
1042
1043     /**** create common stuff ****/
1044
1045     /* command buttons */
1046     /* (PWIDTH - (left and right margin) - (btn interval)) / 3 */
1047     btn_width = (PWIDTH - (2 * 15) - (2 * 10)) / 3;
1048     panel->saveBtn = WMCreateCommandButton(panel->win);
1049     WMSetButtonAction(panel->saveBtn, (WMAction*)saveSettings, panel);
1050     WMMoveWidget(panel->saveBtn, (2 * (btn_width + 10)) + 15, 310);
1051     WMSetButtonText(panel->saveBtn, _("Save"));
1052     WMResizeWidget(panel->saveBtn, btn_width, 28);
1053     if (wPreferences.flags.noupdates || !(wwin->wm_class || wwin->wm_instance))
1054         WMSetButtonEnabled(panel->saveBtn, False);
1055
1056     panel->applyBtn = WMCreateCommandButton(panel->win);
1057     WMSetButtonAction(panel->applyBtn, (WMAction*)applySettings, panel);
1058     WMMoveWidget(panel->applyBtn, btn_width + 10 + 15, 310);
1059     WMSetButtonText(panel->applyBtn, _("Apply"));
1060     WMResizeWidget(panel->applyBtn, btn_width, 28);
1061
1062     panel->revertBtn = WMCreateCommandButton(panel->win);
1063     WMSetButtonAction(panel->revertBtn, (WMAction*)revertSettings, panel);
1064     WMMoveWidget(panel->revertBtn, 15, 310);
1065     WMSetButtonText(panel->revertBtn, _("Reload"));
1066     WMResizeWidget(panel->revertBtn, btn_width, 28);
1067
1068     /* page selection popup button */
1069     panel->pagePopUp = WMCreatePopUpButton(panel->win);
1070     WMSetPopUpButtonAction(panel->pagePopUp, (WMAction*)changePage, panel);
1071     WMMoveWidget(panel->pagePopUp, 25, 15);
1072     WMResizeWidget(panel->pagePopUp, PWIDTH - 50, 20);
1073
1074     WMAddPopUpButtonItem(panel->pagePopUp, _("Window Specification"));
1075     WMAddPopUpButtonItem(panel->pagePopUp, _("Window Attributes"));
1076     WMAddPopUpButtonItem(panel->pagePopUp, _("Advanced Options"));
1077     WMAddPopUpButtonItem(panel->pagePopUp, _("Icon and Initial Workspace"));
1078     WMAddPopUpButtonItem(panel->pagePopUp, _("Application Specific"));
1079
1080     /**** window spec ****/
1081     frame_width = PWIDTH - (2 * 15);
1082
1083     panel->specFrm = WMCreateFrame(panel->win);
1084     WMSetFrameTitle(panel->specFrm, _("Window Specification"));
1085     WMMoveWidget(panel->specFrm, 15, 65);
1086     WMResizeWidget(panel->specFrm, frame_width, 105);
1087
1088
1089     panel->defaultRb = WMCreateRadioButton(panel->specFrm);
1090     WMMoveWidget(panel->defaultRb, 10, 78);
1091     WMResizeWidget(panel->defaultRb, frame_width - (2 * 10), 20);
1092     WMSetButtonText(panel->defaultRb, _("Defaults for all windows"));
1093     WMSetButtonSelected(panel->defaultRb, False);
1094     WMSetButtonAction(panel->defaultRb, selectSpecification, panel);
1095
1096     if (wwin->wm_class && wwin->wm_instance) {
1097         char *str;
1098
1099         str = wstrappend(wwin->wm_instance, wwin->wm_class);
1100         panel->bothRb = WMCreateRadioButton(panel->specFrm);
1101         WMMoveWidget(panel->bothRb, 10, 18);
1102         WMResizeWidget(panel->bothRb, frame_width - (2 * 10), 20);
1103         WMSetButtonText(panel->bothRb, str);
1104         free(str);
1105         WMGroupButtons(panel->defaultRb, panel->bothRb);
1106
1107         if (!selectedBtn)
1108             selectedBtn = panel->bothRb;
1109
1110         WMSetButtonAction(panel->bothRb, selectSpecification, panel);
1111     }
1112
1113     if (wwin->wm_instance) {
1114         panel->instRb = WMCreateRadioButton(panel->specFrm);
1115         WMMoveWidget(panel->instRb, 10, 38);
1116         WMResizeWidget(panel->instRb, frame_width - (2 * 10), 20);
1117         WMSetButtonText(panel->instRb, wwin->wm_instance);
1118         WMGroupButtons(panel->defaultRb, panel->instRb);
1119
1120         if (!selectedBtn)
1121             selectedBtn = panel->instRb;
1122
1123         WMSetButtonAction(panel->instRb, selectSpecification, panel);
1124     }
1125
1126     if (wwin->wm_class) {
1127         panel->clsRb = WMCreateRadioButton(panel->specFrm);
1128         WMMoveWidget(panel->clsRb, 10, 58);
1129         WMResizeWidget(panel->clsRb, frame_width - (2 * 10), 20);
1130         WMSetButtonText(panel->clsRb, wwin->wm_class);
1131         WMGroupButtons(panel->defaultRb, panel->clsRb);
1132
1133         if (!selectedBtn)
1134             selectedBtn = panel->clsRb;
1135
1136         WMSetButtonAction(panel->clsRb, selectSpecification, panel);
1137     }
1138
1139     panel->specLbl = WMCreateLabel(panel->win);
1140     WMMoveWidget(panel->specLbl, 15, 170);
1141     WMResizeWidget(panel->specLbl, frame_width, 100);
1142     WMSetLabelText(panel->specLbl,
1143                    _("The configuration will apply to all\n"
1144                      "windows that have their WM_CLASS property"
1145                      " set to the above selected\nname, when saved."));
1146     WMSetLabelTextAlignment(panel->specLbl, WACenter);
1147
1148     /**** attributes ****/
1149     panel->attrFrm = WMCreateFrame(panel->win);
1150     WMSetFrameTitle(panel->attrFrm, _("Attributes"));
1151     WMMoveWidget(panel->attrFrm, 15, 45);
1152     WMResizeWidget(panel->attrFrm, frame_width, 250);
1153
1154     for (i=0; i < 10; i++) {
1155         char *caption = NULL;
1156         int flag = 0;
1157         char *descr = NULL;
1158
1159         switch (i) {
1160          case 0:
1161             caption = _("Disable Titlebar");
1162             flag = WFLAGP(wwin, no_titlebar);
1163             descr = _("Remove the titlebar of this window.\n"
1164                       "To access the window commands menu of a window\n"
1165                       "without it's titlebar, press Control+Esc (or the\n"
1166                       "equivalent shortcut, if you changed the default\n"
1167                       "settings).");
1168             break;
1169          case 1:
1170             caption = _("Disable Resizebar");
1171             flag = WFLAGP(wwin, no_resizebar);
1172             descr = _("Remove the resizebar of this window.");
1173             break;
1174          case 2:
1175             caption = _("Disable Close Button");
1176             flag = WFLAGP(wwin, no_close_button);
1177             descr = _("Remove the `close window' button of this window.");
1178             break;
1179          case 3:
1180             caption = _("Disable Miniaturize Button");
1181             flag = WFLAGP(wwin, no_miniaturize_button);
1182             descr = _("Remove the `miniaturize window' button of the window.");
1183             break;
1184          case 4:
1185             caption = _("Keep on Top / Floating");
1186             flag = WFLAGP(wwin, floating);
1187             descr = _("Keep the window over other windows, not allowing\n"
1188                       "them to covert it.");
1189             break;
1190          case 5:
1191             caption = _("Keep at Bottom / Sunken");
1192             flag = WFLAGP(wwin, sunken);
1193             descr = _("Keep the window under all other windows.");
1194             break;
1195          case 6:
1196             caption = _("Omnipresent");
1197             flag = WFLAGP(wwin, omnipresent);
1198             descr = _("Make window occupy all workspaces.");
1199             break;
1200          case 7:
1201             caption = _("Start Miniaturized");
1202             flag = WFLAGP(wwin, start_miniaturized);
1203             descr = _("Make the window be automatically miniaturized when it's\n"
1204                     "first shown.");
1205             break;
1206          case 8:
1207             caption = _("Start Maximized");
1208             flag = WFLAGP(wwin, start_maximized!=0);
1209             descr = _("Make the window be automatically maximized when it's\n"
1210                     "first shown.");
1211             break;
1212          case 9:
1213             caption = _("Skip Window List");
1214             flag = WFLAGP(wwin, skip_window_list);
1215             descr = _("Do not list the window in the window list menu.");
1216             break;
1217         }
1218         panel->attrChk[i] = WMCreateSwitchButton(panel->attrFrm);
1219         WMMoveWidget(panel->attrChk[i], 10, 20*(i+1));
1220         WMResizeWidget(panel->attrChk[i], frame_width-15, 20);
1221         WMSetButtonSelected(panel->attrChk[i], flag);
1222         WMSetButtonText(panel->attrChk[i], caption);
1223
1224         WMSetBalloonTextForView(descr, WMWidgetView(panel->attrChk[i]));
1225     }
1226
1227
1228     /**** more attributes ****/
1229     panel->moreFrm = WMCreateFrame(panel->win);
1230     WMSetFrameTitle(panel->moreFrm, _("Advanced"));
1231     WMMoveWidget(panel->moreFrm, 15, 45);
1232     WMResizeWidget(panel->moreFrm, frame_width, 250);
1233
1234 #ifdef XKB_BUTTON_HINT
1235     for (i=0; i < 9; i++) {
1236 #else
1237     for (i=0; i < 8; i++) {
1238 #endif
1239         char *caption = NULL;
1240         int flag = 0;
1241         char *descr = NULL;
1242
1243         switch (i) {
1244          case 0:
1245             caption = _("Ignore HideOthers");
1246             flag = WFLAGP(wwin, no_hide_others);
1247             descr = _("Do not hide the window when issuing the\n"
1248                       "`HideOthers' command.");
1249             break;
1250          case 1:
1251             caption = _("Don't Bind Keyboard Shortcuts");
1252             flag = WFLAGP(wwin, no_bind_keys);
1253             descr = _("Do not bind keyboard shortcuts from Window Maker\n"
1254                       "when this window is focused. This will allow the\n"
1255                       "window to receive all key combinations regardless\n"
1256                       "of your shortcut configuration.");
1257             break;
1258          case 2:
1259             caption = _("Don't Bind Mouse Clicks");
1260             flag = WFLAGP(wwin, no_bind_mouse);
1261             descr = _("Do not bind mouse actions, such as `Alt'+drag\n"
1262                       "in the window (when alt is the modifier you have"
1263                       "configured).");
1264             break;
1265          case 3:
1266             caption = _("Keep Inside Screen");
1267             flag = WFLAGP(wwin, dont_move_off);
1268             descr = _("Do not allow the window to move itself completely\n"
1269                       "outside the screen. For bug compatibility.\n");
1270             break;
1271          case 4:
1272             caption = _("Don't Let It Take Focus");
1273             flag = WFLAGP(wwin, no_focusable);
1274             descr = _("Do not let the window take keyboard focus when you\n"
1275                       "click on it.");
1276             break;
1277          case 5:
1278             caption = _("Don't Save Session");
1279             flag = WFLAGP(wwin, dont_save_session);
1280             descr = _("Do not save the associated application in the\n"
1281                       "session's state, so that it won't be restarted\n"
1282                       "together with other applications when Window Maker\n"
1283                       "starts.");
1284             break;
1285          case 6:
1286             caption = _("Emulate Application Icon");
1287             flag = WFLAGP(wwin, emulate_appicon);
1288             descr = _("Make this window act as an application that provides\n"
1289                       "enough information to Window Maker for a dockable\n"
1290                       "application icon to be created.");
1291             break;
1292          case 7:
1293             caption = _("Full Screen Maximization");
1294             flag = WFLAGP(wwin, full_maximize);
1295             descr = _("Make the window use the whole screen space when it's\n"
1296                       "maximized. The titlebar and resizebar will be moved\n"
1297                       "to outside the screen.");
1298             break;
1299 #ifdef XKB_BUTTON_HINT
1300      case 8:
1301         caption = _("Disable Language Button");
1302         flag = WFLAGP(wwin, no_language_button);
1303         descr = _("Remove the `toggle language' button of the window.");
1304         break;
1305 #endif
1306         }
1307         panel->moreChk[i] = WMCreateSwitchButton(panel->moreFrm);
1308         WMMoveWidget(panel->moreChk[i], 10, 20*(i+1));
1309         WMResizeWidget(panel->moreChk[i], frame_width-15, 20);
1310         WMSetButtonSelected(panel->moreChk[i], flag);
1311         WMSetButtonText(panel->moreChk[i], caption);
1312
1313         WMSetBalloonTextForView(descr, WMWidgetView(panel->moreChk[i]));
1314     }
1315
1316     /* miniwindow/workspace */
1317     panel->iconFrm = WMCreateFrame(panel->win);
1318     WMMoveWidget(panel->iconFrm, 15, 50);
1319     WMResizeWidget(panel->iconFrm,  PWIDTH - (2 * 15), 170);
1320     WMSetFrameTitle(panel->iconFrm, _("Miniwindow Image"));
1321
1322     panel->iconLbl = WMCreateLabel(panel->iconFrm);
1323     WMMoveWidget(panel->iconLbl, PWIDTH - (2 * 15) - 22 - 64, 30);
1324     WMResizeWidget(panel->iconLbl, 64, 64);
1325     WMSetLabelRelief(panel->iconLbl, WRGroove);
1326     WMSetLabelImagePosition(panel->iconLbl, WIPImageOnly);
1327
1328     panel->browseIconBtn = WMCreateCommandButton(panel->iconFrm);
1329     WMSetButtonAction(panel->browseIconBtn, chooseIconCallback, panel);
1330     WMMoveWidget(panel->browseIconBtn, 22, 30);
1331     WMResizeWidget(panel->browseIconBtn, 100, 26);
1332     WMSetButtonText(panel->browseIconBtn, _("Browse..."));
1333
1334 #if 0
1335     panel->updateIconBtn = WMCreateCommandButton(panel->iconFrm);
1336     WMSetButtonAction(panel->updateIconBtn, (WMAction*)updateIcon, panel);
1337     WMMoveWidget(panel->updateIconBtn, 22, 65);
1338     WMResizeWidget(panel->updateIconBtn, 100, 26);
1339     WMSetButtonText(panel->updateIconBtn, _("Update"));
1340 #endif
1341 #ifdef wrong_behaviour
1342     WMSetButtonImagePosition(panel->updateIconBtn, WIPRight);
1343     pixmap = WMGetSystemPixmap(scr->wmscreen, WSIReturnArrow);
1344     WMSetButtonImage(panel->updateIconBtn, pixmap);
1345     WMReleasePixmap(pixmap);
1346     pixmap = WMGetSystemPixmap(scr->wmscreen, WSIHighlightedReturnArrow);
1347     WMSetButtonAltImage(panel->updateIconBtn, pixmap);
1348     WMReleasePixmap(pixmap);
1349 #endif
1350
1351     panel->fileLbl = WMCreateLabel(panel->iconFrm);
1352     WMMoveWidget(panel->fileLbl, 20, 95);
1353     WMResizeWidget(panel->fileLbl, PWIDTH - (2 * 15) - (2 * 20), 14);
1354     WMSetLabelText(panel->fileLbl, _("Icon File Name:"));
1355
1356     panel->fileText = WMCreateTextField(panel->iconFrm);
1357     WMMoveWidget(panel->fileText, 20, 115);
1358     WMResizeWidget(panel->fileText, PWIDTH - (2 * 15) - (2 * 15), 20);
1359     WMSetTextFieldText(panel->fileText, NULL);
1360     WMAddNotificationObserver(textEditedObserver, panel,
1361                               WMTextDidEndEditingNotification,
1362                               panel->fileText);
1363     panel->alwChk = WMCreateSwitchButton(panel->iconFrm);
1364     WMMoveWidget(panel->alwChk, 20, 140);
1365     WMResizeWidget(panel->alwChk, PWIDTH - (2 * 15) - (2 * 15), 20);
1366     WMSetButtonText(panel->alwChk, _("Ignore client supplied icon"));
1367     WMSetButtonSelected(panel->alwChk, WFLAGP(wwin, always_user_icon));
1368
1369
1370     panel->wsFrm = WMCreateFrame(panel->win);
1371     WMMoveWidget(panel->wsFrm, 15, 225);
1372     WMResizeWidget(panel->wsFrm, PWIDTH - (2 * 15), 70);
1373     WMSetFrameTitle(panel->wsFrm, _("Initial Workspace"));
1374
1375     WMSetBalloonTextForView(_("The workspace to place the window when it's"
1376                               "first shown."), WMWidgetView(panel->wsFrm));
1377
1378     panel->wsP = WMCreatePopUpButton(panel->wsFrm);
1379     WMMoveWidget(panel->wsP, 20, 30);
1380     WMResizeWidget(panel->wsP, PWIDTH - (2 * 15) - (2 * 20), 20);
1381     WMAddPopUpButtonItem(panel->wsP, _("Nowhere in particular"));
1382     for (i = 0; i < wwin->screen_ptr->workspace_count; i++) {
1383         WMAddPopUpButtonItem(panel->wsP, scr->workspaces[i]->name);
1384     }
1385
1386     i = wDefaultGetStartWorkspace(wwin->screen_ptr, wwin->wm_instance,
1387                                   wwin->wm_class);
1388     if (i >= 0 && i <= wwin->screen_ptr->workspace_count) {
1389         WMSetPopUpButtonSelectedItem(panel->wsP, i + 1);
1390     } else {
1391         WMSetPopUpButtonSelectedItem(panel->wsP, 0);
1392     }
1393
1394     /* application wide attributes */
1395     if (wwin->main_window != None) {
1396         WApplication *wapp = wApplicationOf(wwin->main_window);
1397
1398         panel->appFrm = WMCreateFrame(panel->win);
1399         WMSetFrameTitle(panel->appFrm, _("Application Wide"));
1400         WMMoveWidget(panel->appFrm, 15, 50);
1401         WMResizeWidget(panel->appFrm, frame_width, 240);
1402
1403         for (i=0; i < 2; i++) {
1404             char *caption = NULL;
1405             int flag = 0;
1406             char *descr = NULL;
1407
1408             switch (i) {
1409              case 0:
1410                 caption = _("Start Hidden");
1411                 flag = WFLAGP(wapp->main_window_desc, start_hidden);
1412                 descr = _("Automatically hide application when it's started.");
1413                 break;
1414              case 1:
1415                 caption = _("No Application Icon");
1416                 flag = WFLAGP(wapp->main_window_desc, no_appicon);
1417                 descr = _("Disable the application icon for the application.\n"
1418                           "Note that you won't be able to dock it anymore,\n"
1419                           "and any icons that are already docked will stop\n"
1420                           "working correctly.");
1421                 break;
1422             }
1423             panel->appChk[i] = WMCreateSwitchButton(panel->appFrm);
1424             WMMoveWidget(panel->appChk[i], 10, 20*(i+1));
1425             WMResizeWidget(panel->appChk[i], 205, 20);
1426             WMSetButtonSelected(panel->appChk[i], flag);
1427             WMSetButtonText(panel->appChk[i], caption);
1428
1429             WMSetBalloonTextForView(descr, WMWidgetView(panel->appChk[i]));
1430         }
1431
1432         if (WFLAGP(wwin, emulate_appicon)) {
1433             WMSetButtonEnabled(panel->appChk[1], False);
1434             WMSetButtonEnabled(panel->moreChk[6], True);
1435         } else {
1436             WMSetButtonEnabled(panel->appChk[1], True);
1437             WMSetButtonEnabled(panel->moreChk[6], False);
1438         }
1439     } else {
1440         int tmp;
1441
1442         if ((wwin->transient_for!=None && wwin->transient_for!=scr->root_win)
1443             || !wwin->wm_class || !wwin->wm_instance)
1444             tmp = False;
1445         else
1446             tmp = True;
1447         WMSetButtonEnabled(panel->moreChk[6], tmp);
1448
1449         WMSetPopUpButtonItemEnabled(panel->pagePopUp, 4, False);
1450         panel->appFrm = NULL;
1451     }
1452
1453     /* if the window is a transient, don't let it have a miniaturize
1454      * button */
1455     if (wWindowFor(wwin->transient_for)!=NULL)
1456         WMSetButtonEnabled(panel->attrChk[3], False);
1457     else
1458         WMSetButtonEnabled(panel->attrChk[3], True);
1459
1460
1461     if (!wwin->wm_class && !wwin->wm_instance) {
1462         WMSetPopUpButtonItemEnabled(panel->pagePopUp, 0, False);
1463     }
1464
1465
1466     WMRealizeWidget(panel->win);
1467
1468     WMMapSubwidgets(panel->win);
1469     WMMapSubwidgets(panel->specFrm);
1470     WMMapSubwidgets(panel->attrFrm);
1471     WMMapSubwidgets(panel->moreFrm);
1472     WMMapSubwidgets(panel->iconFrm);
1473     WMMapSubwidgets(panel->wsFrm);
1474     if (panel->appFrm)
1475         WMMapSubwidgets(panel->appFrm);
1476
1477     WMSetPopUpButtonSelectedItem(panel->pagePopUp, 1);
1478     changePage(panel->pagePopUp, panel);
1479
1480
1481     parent = XCreateSimpleWindow(dpy, scr->root_win, 0, 0, PWIDTH, PHEIGHT,
1482                                  0, 0, 0);
1483     XSelectInput(dpy, parent, KeyPressMask|KeyReleaseMask);
1484     panel->parent = parent;
1485     XReparentWindow(dpy, WMWidgetXID(panel->win), parent, 0, 0);
1486
1487     WMMapWidget(panel->win);
1488
1489     XSetTransientForHint(dpy, parent, wwin->client_win);
1490
1491     x = wwin->frame_x+wwin->frame->core->width/2;
1492     y = wwin->frame_y+wwin->frame->top_width*2;
1493     if (y + PHEIGHT > scr->scr_height)
1494         y = scr->scr_height - PHEIGHT - 30;
1495     if (x + PWIDTH > scr->scr_width)
1496         x = scr->scr_width - PWIDTH;
1497
1498     panel->frame = wManageInternalWindow(scr, parent, wwin->client_win,
1499                                          "Inspector", x, y, PWIDTH, PHEIGHT);
1500
1501     if (!selectedBtn)
1502         selectedBtn = panel->defaultRb;
1503
1504     selectSpecification(selectedBtn, panel);
1505
1506     /* kluge to know who should get the key events */
1507     panel->frame->client_leader = WMWidgetXID(panel->win);
1508
1509     WSETUFLAG(panel->frame, no_closable, 0);
1510     WSETUFLAG(panel->frame, no_close_button, 0);
1511     wWindowUpdateButtonImages(panel->frame);
1512     wFrameWindowShowButton(panel->frame->frame, WFF_RIGHT_BUTTON);
1513     panel->frame->frame->on_click_right = destroyInspector;
1514
1515     wWindowMap(panel->frame);
1516
1517     showIconFor(WMWidgetScreen(panel->alwChk), panel, wwin->wm_instance,
1518                 wwin->wm_class, UPDATE_TEXT_FIELD);
1519
1520     return panel;
1521 }
1522
1523
1524 void
1525 wShowInspectorForWindow(WWindow *wwin)
1526 {
1527     if (wwin->flags.inspector_open)
1528         return;
1529
1530     WMSetBalloonEnabled(wwin->screen_ptr->wmscreen, wPreferences.help_balloon);
1531
1532     make_keys();
1533     wwin->flags.inspector_open = 1;
1534     wwin->inspector = createInspectorForWindow(wwin);;
1535 }
1536
1537