src/winspector.c

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