src/wdefaults.c

   1 /* wdefaults.c - window specific defaults
   2  *
   3  *  Window Maker window manager
   4  *
   5  *  Copyright (c) 1997, 1998 Alfredo K. Kojima
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  20  *  USA.
  21  */
  22
  23 #include "wconfig.h"
  24
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <unistd.h>
  28 #include <string.h>
  29 #include <ctype.h>
  30
  31 #include <X11/Xlib.h>
  32 #include <X11/Xutil.h>
  33 #include <X11/keysym.h>
  34
  35 #include <wraster.h>
  36
  37
  38 #include "WindowMaker.h"
  39 #include "window.h"
  40 #include "screen.h"
  41 #include "funcs.h"
  42 #include "workspace.h"
  43 #include "defaults.h"
  44 #include "icon.h"
  45
  46
  47 /* Global stuff */
  48
  49 extern WPreferences wPreferences;
  50
  51 extern proplist_t wAttributeDomainName;
  52
  53 extern WDDomain *WDWindowAttributes;
  54
  55
  56 /* Local stuff */
  57
  58
  59 /* type converters */
  60 static int getBool(proplist_t, proplist_t);
  61
  62 static char* getString(proplist_t, proplist_t);
  63
  64
  65 static proplist_t ANoTitlebar = NULL;
  66 static proplist_t ANoResizebar;
  67 static proplist_t ANoMiniaturizeButton;
  68 static proplist_t ANoCloseButton;
  69 static proplist_t ANoHideOthers;
  70 static proplist_t ANoMouseBindings;
  71 static proplist_t ANoKeyBindings;
  72 static proplist_t ANoAppIcon;          /* app */
  73 static proplist_t AKeepOnTop;
  74 static proplist_t AKeepOnBottom;
  75 static proplist_t AOmnipresent;
  76 static proplist_t ASkipWindowList;
  77 static proplist_t AKeepInsideScreen;
  78 static proplist_t AUnfocusable;
  79 static proplist_t AAlwaysUserIcon;
  80 static proplist_t AStartMiniaturized;
  81 static proplist_t AStartMaximized;
  82 static proplist_t AStartHidden;        /* app */
  83 static proplist_t ADontSaveSession;    /* app */
  84 static proplist_t AEmulateAppIcon;
  85
  86 static proplist_t AStartWorkspace;
  87
  88 static proplist_t AIcon;
  89
  90
  91 static proplist_t AnyWindow;
  92 static proplist_t No;
  93
  94
  95 static void
  96 init_wdefaults(WScreen *scr)
  97 {
  98     AIcon = PLMakeString("Icon");
  99
 100     ANoTitlebar = PLMakeString("NoTitlebar");
 101     ANoResizebar = PLMakeString("NoResizebar");
 102     ANoMiniaturizeButton = PLMakeString("NoMiniaturizeButton");
 103     ANoCloseButton = PLMakeString("NoCloseButton");
 104     ANoHideOthers = PLMakeString("NoHideOthers");
 105     ANoMouseBindings = PLMakeString("NoMouseBindings");
 106     ANoKeyBindings = PLMakeString("NoKeyBindings");
 107     ANoAppIcon = PLMakeString("NoAppIcon");
 108     AKeepOnTop = PLMakeString("KeepOnTop");
 109     AKeepOnBottom = PLMakeString("KeepOnBottom");
 110     AOmnipresent = PLMakeString("Omnipresent");
 111     ASkipWindowList = PLMakeString("SkipWindowList");
 112     AKeepInsideScreen = PLMakeString("KeepInsideScreen");
 113     AUnfocusable = PLMakeString("Unfocusable");
 114     AAlwaysUserIcon = PLMakeString("AlwaysUserIcon");
 115     AStartMiniaturized = PLMakeString("StartMiniaturized");
 116     AStartHidden = PLMakeString("StartHidden");
 117     AStartMaximized = PLMakeString("StartMaximized");
 118     ADontSaveSession = PLMakeString("DontSaveSession");
 119     AEmulateAppIcon = PLMakeString("EmulateAppIcon");
 120
 121     AStartWorkspace = PLMakeString("StartWorkspace");
 122
 123     AnyWindow = PLMakeString("*");
 124     No = PLMakeString("No");
 125     /*
 126     if (!scr->wattribs) {
 127         scr->wattribs = PLGetDomain(wAttributeDomainName);
 128     }*/
 129 }
 130
 131
 132
 133 static proplist_t
 134 get_value(proplist_t dict_win, proplist_t dict_class, proplist_t dict_name,
 135           proplist_t dict_any, proplist_t option, proplist_t default_value,
 136           Bool useGlobalDefault)
 137 {
 138     proplist_t value;
 139
 140
 141     if (dict_win) {
 142         value = PLGetDictionaryEntry(dict_win, option);
 143         if (value)
 144             return value;
 145     }
 146
 147     if (dict_name) {
 148         value = PLGetDictionaryEntry(dict_name, option);
 149         if (value)
 150             return value;
 151     }
 152
 153     if (dict_class) {
 154         value = PLGetDictionaryEntry(dict_class, option);
 155         if (value)
 156             return value;
 157     }
 158
 159     if (!useGlobalDefault)
 160         return NULL;
 161
 162     if (dict_any) {
 163         value = PLGetDictionaryEntry(dict_any, option);
 164         if (value)
 165             return value;
 166     }
 167
 168     return default_value;
 169 }
 170
 171
 172 /*
 173  *----------------------------------------------------------------------
 174  * wDefaultFillAttributes--
 175  *      Retrieves attributes for the specified instance/class and
 176  * fills attr with it. Values that are actually defined are also
 177  * set in mask. If useGlobalDefault is True, the default for
 178  * all windows ("*") will be used for when no values are found
 179  * for that instance/class.
 180  *
 181  *----------------------------------------------------------------------
 182  */
 183 void
 184 wDefaultFillAttributes(WScreen *scr, char *instance, char *class,
 185                        WWindowAttributes *attr,
 186                        WWindowAttributes *mask,
 187                        Bool useGlobalDefault)
 188 {
 189     proplist_t value;
 190     proplist_t key1, key2, key3;
 191     proplist_t dw, dc, dn, da;
 192     char buffer[256];
 193
 194
 195     if (class && instance)
 196       key1 = PLMakeString(strcat(strcat(strcpy(buffer,instance),"."),class));
 197     else
 198       key1 = NULL;
 199
 200     if (instance)
 201       key2 = PLMakeString(instance);
 202     else
 203       key2 = NULL;
 204
 205     if (class)
 206       key3 = PLMakeString(class);
 207     else
 208       key3 = NULL;
 209
 210     if (!ANoTitlebar) {
 211         init_wdefaults(scr);
 212     }
 213
 214     PLSetStringCmpHook(NULL);
 215
 216     if (WDWindowAttributes->dictionary) {
 217         dw = key1 ? PLGetDictionaryEntry(WDWindowAttributes->dictionary, key1) : NULL;
 218         dn = key2 ? PLGetDictionaryEntry(WDWindowAttributes->dictionary, key2) : NULL;
 219         dc = key3 ? PLGetDictionaryEntry(WDWindowAttributes->dictionary, key3) : NULL;
 220         if (useGlobalDefault)
 221             da = PLGetDictionaryEntry(WDWindowAttributes->dictionary, AnyWindow);
 222         else
 223             da = NULL;
 224     } else {
 225         dw = NULL;
 226         dn = NULL;
 227         dc = NULL;
 228         da = NULL;
 229     }
 230     if (key1)
 231       PLRelease(key1);
 232     if (key2)
 233       PLRelease(key2);
 234     if (key3)
 235       PLRelease(key3);
 236
 237 #define APPLY_VAL(value, flag, attrib)  \
 238         if (value) {attr->flag = getBool(attrib, value); \
 239                         if (mask) mask->flag = 1;}
 240
 241     /* get the data */
 242     value = get_value(dw, dc, dn, da, ANoTitlebar, No, useGlobalDefault);
 243     APPLY_VAL(value, no_titlebar, ANoTitlebar);
 244
 245     value = get_value(dw, dc, dn, da, ANoResizebar, No, useGlobalDefault);
 246     APPLY_VAL(value, no_resizebar, ANoResizebar);
 247
 248     value = get_value(dw, dc, dn, da, ANoMiniaturizeButton, No, useGlobalDefault);
 249     APPLY_VAL(value, no_miniaturize_button, ANoMiniaturizeButton);
 250
 251     value = get_value(dw, dc, dn, da, ANoCloseButton, No, useGlobalDefault);
 252     APPLY_VAL(value, no_close_button, ANoCloseButton);
 253
 254     value = get_value(dw, dc, dn, da, ANoHideOthers, No, useGlobalDefault);
 255     APPLY_VAL(value, no_hide_others, ANoHideOthers);
 256
 257     value = get_value(dw, dc, dn, da, ANoMouseBindings, No, useGlobalDefault);
 258     APPLY_VAL(value, no_bind_mouse, ANoMouseBindings);
 259
 260     value = get_value(dw, dc, dn, da, ANoKeyBindings, No, useGlobalDefault);
 261     APPLY_VAL(value, no_bind_keys, ANoKeyBindings);
 262
 263     value = get_value(dw, dc, dn, da, ANoAppIcon, No, useGlobalDefault);
 264     APPLY_VAL(value, no_appicon, ANoAppIcon);
 265
 266     value = get_value(dw, dc, dn, da, AKeepOnTop, No, useGlobalDefault);
 267     APPLY_VAL(value, floating, AKeepOnTop);
 268
 269     value = get_value(dw, dc, dn, da, AKeepOnBottom, No, useGlobalDefault);
 270     APPLY_VAL(value, sunken, AKeepOnBottom);
 271
 272     value = get_value(dw, dc, dn, da, AOmnipresent, No, useGlobalDefault);
 273     APPLY_VAL(value, omnipresent, AOmnipresent);
 274
 275     value = get_value(dw, dc, dn, da, ASkipWindowList, No, useGlobalDefault);
 276     APPLY_VAL(value, skip_window_list, ASkipWindowList);
 277
 278     value = get_value(dw, dc, dn, da, AKeepInsideScreen, No, useGlobalDefault);
 279     APPLY_VAL(value, dont_move_off, AKeepInsideScreen);
 280
 281     value = get_value(dw, dc, dn, da, AUnfocusable, No, useGlobalDefault);
 282     APPLY_VAL(value, no_focusable, AUnfocusable);
 283
 284     value = get_value(dw, dc, dn, da, AAlwaysUserIcon, No, useGlobalDefault);
 285     APPLY_VAL(value, always_user_icon, AAlwaysUserIcon);
 286
 287     value = get_value(dw, dc, dn, da, AStartMiniaturized, No, useGlobalDefault);
 288     APPLY_VAL(value, start_miniaturized, AStartMiniaturized);
 289
 290     value = get_value(dw, dc, dn, da, AStartHidden, No, useGlobalDefault);
 291     APPLY_VAL(value, start_hidden, AStartHidden);
 292
 293     value = get_value(dw, dc, dn, da, AStartMaximized, No, useGlobalDefault);
 294     APPLY_VAL(value, start_maximized, AStartMaximized);
 295
 296     value = get_value(dw, dc, dn, da, ADontSaveSession, No, useGlobalDefault);
 297     APPLY_VAL(value, dont_save_session, ADontSaveSession);
 298
 299     value = get_value(dw, dc, dn, da, AEmulateAppIcon, No, useGlobalDefault);
 300     APPLY_VAL(value, emulate_appicon, AEmulateAppIcon);
 301
 302     /* clean up */
 303     PLSetStringCmpHook(StringCompareHook);
 304 }
 305
 306
 307
 308 proplist_t
 309 get_generic_value(WScreen *scr, char *instance, char *class, proplist_t option,
 310                   Bool noDefault)
 311 {
 312     proplist_t value, key, dict;
 313     char buffer[256];
 314
 315     value = NULL;
 316
 317     PLSetStringCmpHook(NULL);
 318
 319     if (class && instance) {
 320         key = PLMakeString(strcat(strcat(strcpy(buffer,instance),"."),class));
 321
 322         dict = PLGetDictionaryEntry(WDWindowAttributes->dictionary, key);
 323         PLRelease(key);
 324
 325         if (dict) {
 326             value = PLGetDictionaryEntry(dict, option);
 327         }
 328     }
 329
 330     if (!value && instance) {
 331         key = PLMakeString(instance);
 332
 333         dict = PLGetDictionaryEntry(WDWindowAttributes->dictionary, key);
 334         PLRelease(key);
 335
 336         if (dict) {
 337             value = PLGetDictionaryEntry(dict, option);
 338         }
 339     }
 340
 341     if (!value && class) {
 342         key = PLMakeString(class);
 343
 344         dict = PLGetDictionaryEntry(WDWindowAttributes->dictionary, key);
 345         PLRelease(key);
 346
 347         if (dict) {
 348             value = PLGetDictionaryEntry(dict, option);
 349         }
 350     }
 351
 352     if (!value && !noDefault) {
 353         dict = PLGetDictionaryEntry(WDWindowAttributes->dictionary, AnyWindow);
 354
 355         if (dict) {
 356             value = PLGetDictionaryEntry(dict, option);
 357         }
 358     }
 359
 360     PLSetStringCmpHook(StringCompareHook);
 361
 362     return value;
 363 }
 364
 365
 366 char*
 367 wDefaultGetIconFile(WScreen *scr, char *instance, char *class,
 368                     Bool noDefault)
 369 {
 370     proplist_t value;
 371     char *tmp;
 372
 373     if (!ANoTitlebar) {
 374         init_wdefaults(scr);
 375     }
 376
 377     if (!WDWindowAttributes->dictionary)
 378         return NULL;
 379
 380     value = get_generic_value(scr, instance, class, AIcon, noDefault);
 381
 382     if (!value)
 383         return NULL;
 384
 385     tmp = getString(AIcon, value);
 386
 387     return tmp;
 388 }
 389
 390
 391 RImage*
 392 wDefaultGetImage(WScreen *scr, char *winstance, char *wclass)
 393 {
 394     char *file_name;
 395     char *path;
 396     RImage *image;
 397
 398     file_name = wDefaultGetIconFile(scr, winstance, wclass, False);
 399     if (!file_name)
 400         return NULL;
 401
 402     path = FindImage(wPreferences.icon_path, file_name);
 403
 404     if (!path) {
 405         wwarning(_("could not find icon file \"%s\""), file_name);
 406         return NULL;
 407     }
 408
 409     image = RLoadImage(scr->rcontext, path, 0);
 410     if (!image) {
 411         wwarning(_("error loading image file \"%s\""), path, RMessageForError(RErrorCode));
 412     }
 413     free(path);
 414
 415     image = wIconValidateIconSize(scr, image);
 416
 417     return image;
 418 }
 419
 420
 421 int
 422 wDefaultGetStartWorkspace(WScreen *scr, char *instance, char *class)
 423 {
 424     proplist_t value;
 425     int w, i;
 426     char *tmp;
 427
 428     if (!ANoTitlebar) {
 429         init_wdefaults(scr);
 430     }
 431
 432     if (!WDWindowAttributes->dictionary)
 433         return -1;
 434
 435     value = get_generic_value(scr, instance, class, AStartWorkspace,
 436                               False);
 437
 438     if (!value)
 439         return -1;
 440
 441     tmp = getString(AStartWorkspace, value);
 442
 443     if (!tmp || strlen(tmp)==0)
 444         return -1;
 445
 446     if (sscanf(tmp, "%i", &w)!=1) {
 447         w = -1;
 448         for (i=0; i < scr->workspace_count; i++) {
 449             if (strcmp(scr->workspaces[i]->name, tmp)==0) {
 450                 w = i;
 451                 break;
 452             }
 453         }
 454     } else {
 455         w--;
 456     }
 457
 458     return w;
 459 }
 460
 461
 462 void
 463 wDefaultChangeIcon(WScreen *scr, char *instance, char* class, char *file)
 464 {
 465     WDDomain *db = WDWindowAttributes;
 466     proplist_t icon_value=NULL, value, attr, key, def_win, def_icon=NULL;
 467     proplist_t dict = db->dictionary;
 468     char *buffer;
 469     int same = 0;
 470
 471     if (!dict) {
 472         dict = PLMakeDictionaryFromEntries(NULL, NULL, NULL);
 473         if (dict) {
 474             db->dictionary = dict;
 475             value = PLMakeString(db->path);
 476             PLSetFilename(dict, value);
 477             PLRelease(value);
 478         }
 479         else
 480             return;
 481     }
 482
 483     PLSetStringCmpHook(NULL);
 484
 485     if (instance && class) {
 486         buffer = wmalloc(strlen(instance) + strlen(class) + 2);
 487         strcat(strcat(strcpy(buffer, instance), "."), class);
 488         key = PLMakeString(buffer);
 489         free(buffer);
 490     } else if (instance) {
 491         key = PLMakeString(instance);
 492     } else if (class) {
 493         key = PLMakeString(class);
 494     } else {
 495         key = PLRetain(AnyWindow);
 496     }
 497
 498     if (file) {
 499         value = PLMakeString(file);
 500         icon_value = PLMakeDictionaryFromEntries(AIcon, value, NULL);
 501         PLRelease(value);
 502
 503         if ((def_win = PLGetDictionaryEntry(dict, AnyWindow)) != NULL) {
 504             def_icon = PLGetDictionaryEntry(def_win, AIcon);
 505         }
 506
 507         if (def_icon && !strcmp(PLGetString(def_icon), file))
 508             same = 1;
 509     }
 510
 511     if ((attr = PLGetDictionaryEntry(dict, key)) != NULL) {
 512         if (PLIsDictionary(attr)) {
 513             if (icon_value!=NULL && !same)
 514                 PLMergeDictionaries(attr, icon_value);
 515             else
 516                 PLRemoveDictionaryEntry(attr, AIcon);
 517         }
 518     } else if (icon_value!=NULL && !same) {
 519         PLInsertDictionaryEntry(dict, key, icon_value);
 520     }
 521     if (!wPreferences.flags.noupdates)
 522         PLSave(dict, YES);
 523
 524     PLRelease(key);
 525     if(icon_value)
 526         PLRelease(icon_value);
 527
 528     PLSetStringCmpHook(StringCompareHook);
 529 }
 530
 531
 532
 533 /* --------------------------- Local ----------------------- */
 534
 535 static int
 536 getBool(proplist_t key, proplist_t value)
 537 {
 538     char *val;
 539
 540     if (!PLIsString(value)) {
 541         wwarning(_("Wrong option format for key \"%s\". Should be %s."),
 542                  PLGetString(key), "Boolean");
 543         return 0;
 544     }
 545     val = PLGetString(value);
 546
 547     if ((val[1]=='\0' && (val[0]=='y' || val[0]=='Y' || val[0]=='T'
 548                           || val[0]=='t' || val[0]=='1'))
 549         || (strcasecmp(val, "YES")==0 || strcasecmp(val, "TRUE")==0)) {
 550
 551         return 1;
 552     } else if ((val[1]=='\0'
 553               && (val[0]=='n' || val[0]=='N' || val[0]=='F'
 554                   || val[0]=='f' || val[0]=='0'))
 555              || (strcasecmp(val, "NO")==0 || strcasecmp(val, "FALSE")==0)) {
 556
 557         return 0;
 558     } else {
 559         wwarning(_("can't convert \"%s\" to boolean"), val);
 560         /* We return False if we can't convert to BOOLEAN.
 561          * This is because all options defaults to False.
 562          * -1 is not checked and thus is interpreted as True,
 563          * which is not good.*/
 564         return 0;
 565     }
 566 }
 567
 568
 569
 570 /*
 571  * WARNING: Do not free value returned by this!!
 572  */
 573 static char*
 574 getString(proplist_t key, proplist_t value)
 575 {
 576     if (!PLIsString(value)) {
 577         wwarning(_("Wrong option format for key \"%s\". Should be %s."),
 578                  PLGetString(key), "String");
 579         return NULL;
 580     }
 581
 582     return PLGetString(value);
 583 }