WPrefs.app/WPrefs.c

   1 /* WPrefs.c- main window and other basic stuff
   2  *
   3  *  WPrefs - Window Maker Preferences Program
   4  *
   5  *  Copyright (c) 1998-2003 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 along
  18  *  with this program; if not, write to the Free Software Foundation, Inc.,
  19  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #include "config.h"
  23
  24 #include "WPrefs.h"
  25 #include <assert.h>
  26
  27 #ifdef HAVE_STDNORETURN
  28 #include <stdnoreturn.h>
  29 #endif
  30
  31
  32 #define ICON_TITLE_FONT "sans serif:pixelsize=9"
  33 #define ICON_TITLE_VFONT "sans serif:pixelsize=9:weight=100"
  34
  35 #define MAX_SECTIONS 16
  36
  37 typedef struct _WPrefs {
  38         WMWindow *win;
  39
  40         WMScrollView *scrollV;
  41         WMFrame *buttonF;
  42         WMButton *sectionB[MAX_SECTIONS];
  43
  44         int sectionCount;
  45
  46         WMButton *saveBtn;
  47         WMButton *closeBtn;
  48         WMButton *undoBtn;
  49         WMButton *undosBtn;
  50
  51         WMButton *balloonBtn;
  52
  53         WMFrame *banner;
  54         WMLabel *nameL;
  55         WMLabel *versionL;
  56         WMLabel *statusL;
  57
  58         Panel *currentPanel;
  59 } _WPrefs;
  60
  61 static _WPrefs WPrefs;
  62
  63 /* system wide defaults dictionary. Read-only */
  64 static WMPropList *GlobalDB = NULL;
  65 /* user defaults dictionary */
  66 static WMPropList *WindowMakerDB = NULL;
  67 static char *WindowMakerDBPath = NULL;
  68
  69 static Bool TIFFOK = False;
  70
  71 #define INITIALIZED_PANEL       (1<<0)
  72
  73 static void loadConfigurations(WMScreen * scr, WMWindow * mainw);
  74
  75 static void savePanelData(Panel * panel);
  76
  77 static void prepareForClose(void);
  78
  79 static noreturn void quit(WMWidget *w, void *data)
  80 {
  81         /* Parameter not used, but tell the compiler that it is ok */
  82         (void) w;
  83         (void) data;
  84
  85         prepareForClose();
  86
  87         exit(0);
  88 }
  89
  90 static void save(WMWidget * w, void *data)
  91 {
  92         int i;
  93         WMPropList *p1, *p2;
  94         WMPropList *keyList;
  95         WMPropList *key;
  96         XEvent ev;
  97
  98         /* Parameter not used, but tell the compiler that it is ok */
  99         (void) data;
 100
 101         /*    puts("gathering data"); */
 102         for (i = 0; i < WPrefs.sectionCount; i++) {
 103                 PanelRec *rec = WMGetHangedData(WPrefs.sectionB[i]);
 104                 if ((rec->callbacks.flags & INITIALIZED_PANEL))
 105                         savePanelData((Panel *) rec);
 106         }
 107         /*    puts("compressing data"); */
 108         /* compare the user dictionary with the global and remove redundant data */
 109         keyList = WMGetPLDictionaryKeys(GlobalDB);
 110         /*    puts(WMGetPropListDescription(WindowMakerDB, False)); */
 111         for (i = 0; i < WMGetPropListItemCount(keyList); i++) {
 112                 key = WMGetFromPLArray(keyList, i);
 113
 114                 /* We don't have this value anyway, so no problem.
 115                  * Probably  a new option */
 116                 p1 = WMGetFromPLDictionary(WindowMakerDB, key);
 117                 if (!p1)
 118                         continue;
 119                 /* The global doesn't have it, so no problem either. */
 120                 p2 = WMGetFromPLDictionary(GlobalDB, key);
 121                 if (!p2)
 122                         continue;
 123                 /* If both values are the same, don't save. */
 124                 if (WMIsPropListEqualTo(p1, p2))
 125                         WMRemoveFromPLDictionary(WindowMakerDB, key);
 126         }
 127         /*    puts(WMGetPropListDescription(WindowMakerDB, False)); */
 128         WMReleasePropList(keyList);
 129         /*    puts("storing data"); */
 130
 131         WMWritePropListToFile(WindowMakerDB, WindowMakerDBPath);
 132
 133         memset(&ev, 0, sizeof(XEvent));
 134
 135         ev.xclient.type = ClientMessage;
 136         ev.xclient.message_type = XInternAtom(WMScreenDisplay(WMWidgetScreen(w)), "_WINDOWMAKER_COMMAND", False);
 137         ev.xclient.window = DefaultRootWindow(WMScreenDisplay(WMWidgetScreen(w)));
 138         ev.xclient.format = 8;
 139         strncpy(ev.xclient.data.b, "Reconfigure", sizeof(ev.xclient.data.b));
 140
 141         XSendEvent(WMScreenDisplay(WMWidgetScreen(w)),
 142                    DefaultRootWindow(WMScreenDisplay(WMWidgetScreen(w))), False, SubstructureRedirectMask, &ev);
 143         XFlush(WMScreenDisplay(WMWidgetScreen(w)));
 144 }
 145
 146 static void undo(WMWidget * w, void *data)
 147 {
 148         PanelRec *rec = (PanelRec *) WPrefs.currentPanel;
 149
 150         /* Parameter not used, but tell the compiler that it is ok */
 151         (void) w;
 152         (void) data;
 153
 154         if (!rec)
 155                 return;
 156
 157         if (rec->callbacks.undoChanges && (rec->callbacks.flags & INITIALIZED_PANEL)) {
 158                 (*rec->callbacks.undoChanges) (WPrefs.currentPanel);
 159         }
 160 }
 161
 162 static void undoAll(WMWidget * w, void *data)
 163 {
 164         int i;
 165
 166         /* Parameter not used, but tell the compiler that it is ok */
 167         (void) w;
 168         (void) data;
 169
 170         for (i = 0; i < WPrefs.sectionCount; i++) {
 171                 PanelRec *rec = WMGetHangedData(WPrefs.sectionB[i]);
 172
 173                 if (rec->callbacks.undoChanges && (rec->callbacks.flags & INITIALIZED_PANEL))
 174                         (*rec->callbacks.undoChanges) ((Panel *) rec);
 175         }
 176 }
 177
 178 static void prepareForClose(void)
 179 {
 180         int i;
 181
 182         for (i = 0; i < WPrefs.sectionCount; i++) {
 183                 PanelRec *rec = WMGetHangedData(WPrefs.sectionB[i]);
 184
 185                 if (rec->callbacks.prepareForClose && (rec->callbacks.flags & INITIALIZED_PANEL))
 186                         (*rec->callbacks.prepareForClose) ((Panel *) rec);
 187         }
 188 }
 189
 190 static void toggleBalloons(WMWidget *w, void *data)
 191 {
 192         WMUserDefaults *udb = WMGetStandardUserDefaults();
 193         Bool flag;
 194
 195         /* Parameter not used, but tell the compiler that it is ok */
 196         (void) w;
 197         (void) data;
 198
 199         flag = WMGetButtonSelected(WPrefs.balloonBtn);
 200
 201         WMSetBalloonEnabled(WMWidgetScreen(WPrefs.win), flag);
 202
 203         WMSetUDBoolForKey(udb, flag, "BalloonHelp");
 204 }
 205
 206 static void createMainWindow(WMScreen * scr)
 207 {
 208         WMScroller *scroller;
 209         WMFont *font;
 210         char buffer[128];
 211
 212         WPrefs.win = WMCreateWindow(scr, "wprefs");
 213         WMResizeWidget(WPrefs.win, 520, 390);
 214         WMSetWindowTitle(WPrefs.win, _("Window Maker Preferences"));
 215         WMSetWindowCloseAction(WPrefs.win, quit, NULL);
 216         WMSetWindowMaxSize(WPrefs.win, 520, 390);
 217         WMSetWindowMinSize(WPrefs.win, 520, 390);
 218         WMSetWindowMiniwindowTitle(WPrefs.win, "Preferences");
 219
 220         WPrefs.scrollV = WMCreateScrollView(WPrefs.win);
 221         WMResizeWidget(WPrefs.scrollV, 500, 87);
 222         WMMoveWidget(WPrefs.scrollV, 10, 10);
 223         WMSetScrollViewRelief(WPrefs.scrollV, WRSunken);
 224         WMSetScrollViewHasHorizontalScroller(WPrefs.scrollV, True);
 225         WMSetScrollViewHasVerticalScroller(WPrefs.scrollV, False);
 226         scroller = WMGetScrollViewHorizontalScroller(WPrefs.scrollV);
 227         WMSetScrollerArrowsPosition(scroller, WSANone);
 228
 229         WPrefs.buttonF = WMCreateFrame(WPrefs.win);
 230         WMSetFrameRelief(WPrefs.buttonF, WRFlat);
 231
 232         WMSetScrollViewContentView(WPrefs.scrollV, WMWidgetView(WPrefs.buttonF));
 233
 234         WPrefs.undosBtn = WMCreateCommandButton(WPrefs.win);
 235         WMResizeWidget(WPrefs.undosBtn, 90, 28);
 236         WMMoveWidget(WPrefs.undosBtn, 135, 350);
 237         WMSetButtonText(WPrefs.undosBtn, _("Revert Page"));
 238         WMSetButtonAction(WPrefs.undosBtn, undo, NULL);
 239
 240         WPrefs.undoBtn = WMCreateCommandButton(WPrefs.win);
 241         WMResizeWidget(WPrefs.undoBtn, 90, 28);
 242         WMMoveWidget(WPrefs.undoBtn, 235, 350);
 243         WMSetButtonText(WPrefs.undoBtn, _("Revert All"));
 244         WMSetButtonAction(WPrefs.undoBtn, undoAll, NULL);
 245
 246         WPrefs.saveBtn = WMCreateCommandButton(WPrefs.win);
 247         WMResizeWidget(WPrefs.saveBtn, 80, 28);
 248         WMMoveWidget(WPrefs.saveBtn, 335, 350);
 249         WMSetButtonText(WPrefs.saveBtn, _("Save"));
 250         WMSetButtonAction(WPrefs.saveBtn, save, NULL);
 251
 252         WPrefs.closeBtn = WMCreateCommandButton(WPrefs.win);
 253         WMResizeWidget(WPrefs.closeBtn, 80, 28);
 254         WMMoveWidget(WPrefs.closeBtn, 425, 350);
 255         WMSetButtonText(WPrefs.closeBtn, _("Close"));
 256         WMSetButtonAction(WPrefs.closeBtn, quit, NULL);
 257
 258         WPrefs.balloonBtn = WMCreateSwitchButton(WPrefs.win);
 259         WMResizeWidget(WPrefs.balloonBtn, 200, 28);
 260         WMMoveWidget(WPrefs.balloonBtn, 15, 350);
 261         WMSetButtonText(WPrefs.balloonBtn, _("Balloon Help"));
 262         WMSetButtonAction(WPrefs.balloonBtn, toggleBalloons, NULL);
 263         {
 264                 WMUserDefaults *udb = WMGetStandardUserDefaults();
 265                 Bool flag = WMGetUDBoolForKey(udb, "BalloonHelp");
 266
 267                 WMSetButtonSelected(WPrefs.balloonBtn, flag);
 268                 WMSetBalloonEnabled(scr, flag);
 269         }
 270
 271         /* banner */
 272         WPrefs.banner = WMCreateFrame(WPrefs.win);
 273         WMResizeWidget(WPrefs.banner, FRAME_WIDTH, FRAME_HEIGHT);
 274         WMMoveWidget(WPrefs.banner, FRAME_LEFT, FRAME_TOP);
 275         WMSetFrameRelief(WPrefs.banner, WRFlat);
 276
 277         font = WMCreateFont(scr, "Lucida Sans,URW Gothic L,Times New Roman,serif"
 278                             ":bold:pixelsize=26:antialias=true");
 279         WPrefs.nameL = WMCreateLabel(WPrefs.banner);
 280         WMSetLabelTextAlignment(WPrefs.nameL, WACenter);
 281         WMResizeWidget(WPrefs.nameL, FRAME_WIDTH - 20, 60);
 282         WMMoveWidget(WPrefs.nameL, 10, 50);
 283         WMSetLabelFont(WPrefs.nameL, font);
 284         WMSetLabelText(WPrefs.nameL, _("Window Maker Preferences"));
 285         WMReleaseFont(font);
 286
 287         WPrefs.versionL = WMCreateLabel(WPrefs.banner);
 288         WMResizeWidget(WPrefs.versionL, FRAME_WIDTH - 20, 20);
 289         WMMoveWidget(WPrefs.versionL, 10, 120);
 290         WMSetLabelTextAlignment(WPrefs.versionL, WACenter);
 291         sprintf(buffer, _("Version %s"), VERSION);
 292         WMSetLabelText(WPrefs.versionL, buffer);
 293
 294         WPrefs.statusL = WMCreateLabel(WPrefs.banner);
 295         WMResizeWidget(WPrefs.statusL, FRAME_WIDTH - 20, 60);
 296         WMMoveWidget(WPrefs.statusL, 10, 150);
 297         WMSetLabelTextAlignment(WPrefs.statusL, WACenter);
 298         WMSetLabelText(WPrefs.statusL, _("Starting..."));
 299
 300         WMMapSubwidgets(WPrefs.win);
 301
 302         WMUnmapWidget(WPrefs.undosBtn);
 303         WMUnmapWidget(WPrefs.undoBtn);
 304         WMUnmapWidget(WPrefs.saveBtn);
 305 }
 306
 307 static void showPanel(Panel * panel)
 308 {
 309         PanelRec *rec = (PanelRec *) panel;
 310
 311         if (!(rec->callbacks.flags & INITIALIZED_PANEL)) {
 312                 (*rec->callbacks.createWidgets) (panel);
 313                 rec->callbacks.flags |= INITIALIZED_PANEL;
 314         }
 315
 316         WMSetWindowTitle(WPrefs.win, rec->sectionName);
 317
 318         if (rec->callbacks.showPanel)
 319                 (*rec->callbacks.showPanel) (panel);
 320
 321         WMMapWidget(rec->box);
 322 }
 323
 324 static void hidePanel(Panel * panel)
 325 {
 326         PanelRec *rec = (PanelRec *) panel;
 327
 328         WMUnmapWidget(rec->box);
 329
 330         if (rec->callbacks.hidePanel)
 331                 (*rec->callbacks.hidePanel) (panel);
 332 }
 333
 334 static void savePanelData(Panel * panel)
 335 {
 336         PanelRec *rec = (PanelRec *) panel;
 337
 338         if (rec->callbacks.updateDomain) {
 339                 (*rec->callbacks.updateDomain) (panel);
 340         }
 341 }
 342
 343 static void changeSection(WMWidget * self, void *data)
 344 {
 345         /* Parameter not used, but tell the compiler that it is ok */
 346         (void) self;
 347
 348         if (WPrefs.currentPanel == data)
 349                 return;
 350
 351         if (WPrefs.currentPanel == NULL) {
 352                 WMDestroyWidget(WPrefs.nameL);
 353                 WMDestroyWidget(WPrefs.versionL);
 354                 WMDestroyWidget(WPrefs.statusL);
 355
 356                 WMSetFrameRelief(WPrefs.banner, WRGroove);
 357
 358                 /*      WMMapWidget(WPrefs.undosBtn);
 359                    WMMapWidget(WPrefs.undoBtn);
 360                  */
 361                 WMMapWidget(WPrefs.saveBtn);
 362         }
 363
 364         showPanel(data);
 365
 366         if (WPrefs.currentPanel)
 367                 hidePanel(WPrefs.currentPanel);
 368         WPrefs.currentPanel = data;
 369 }
 370
 371 char *LocateImage(const char *name)
 372 {
 373         char *path;
 374         char *tmp = wmalloc(strlen(name) + 8);
 375
 376         if (TIFFOK) {
 377                 sprintf(tmp, "%s.tiff", name);
 378                 path = WMPathForResourceOfType(tmp, "tiff");
 379         } else {
 380                 sprintf(tmp, "%s.xpm", name);
 381                 path = WMPathForResourceOfType(tmp, "xpm");
 382         }
 383         wfree(tmp);
 384         if (!path) {
 385                 wwarning(_("could not locate image file %s"), name);
 386         }
 387
 388         return path;
 389 }
 390
 391 void CreateImages(WMScreen *scr, RContext *rc, RImage *xis, const char *file,
 392                 WMPixmap **icon_normal, WMPixmap **icon_greyed)
 393 {
 394         RImage *icon;
 395         char *path;
 396         RColor gray = { 0xae, 0xaa, 0xae, 0 };
 397
 398         path = LocateImage(file);
 399         if (!path)
 400         {
 401                 *icon_normal = NULL;
 402                 if (icon_greyed)
 403                         *icon_greyed = NULL;
 404                 return;
 405         }
 406
 407         *icon_normal = WMCreatePixmapFromFile(scr, path);
 408         if (!*icon_normal)
 409         {
 410                 wwarning(_("could not load icon %s"), path);
 411                 if (icon_greyed)
 412                         *icon_greyed = NULL;
 413                 wfree(path);
 414                 return;
 415         }
 416
 417         if (!icon_greyed) // Greyed-out version not requested, we are done
 418         {
 419                 wfree(path);
 420                 return;
 421         }
 422
 423         icon = RLoadImage(rc, path, 0);
 424         if (!icon)
 425         {
 426                 wwarning(_("could not load icon %s"), path);
 427                 *icon_greyed = NULL;
 428                 wfree(path);
 429                 return;
 430         }
 431         RCombineImageWithColor(icon, &gray);
 432         if (xis)
 433         {
 434                 RCombineImagesWithOpaqueness(icon, xis, 180);
 435         }
 436         *icon_greyed = WMCreatePixmapFromRImage(scr, icon, 127);
 437         if (!*icon_greyed)
 438         {
 439                 wwarning(_("could not process icon %s: %s"), path, RMessageForError(RErrorCode));
 440         }
 441         RReleaseImage(icon);
 442         wfree(path);
 443 }
 444
 445
 446 static WMPixmap *makeTitledIcon(WMPixmap *icon)
 447 {
 448         return WMRetainPixmap(icon);
 449 }
 450
 451 void SetButtonAlphaImage(WMScreen *scr, WMButton *bPtr, const char *file)
 452 {
 453         WMPixmap *icon;
 454         WMPixmap *icon2;
 455         RColor color;
 456         char *iconPath;
 457
 458         iconPath = LocateImage(file);
 459
 460         color.red = 0xae;
 461         color.green = 0xaa;
 462         color.blue = 0xae;
 463         color.alpha = 0;
 464         if (iconPath) {
 465                 icon = WMCreateBlendedPixmapFromFile(scr, iconPath, &color);
 466                 if (!icon)
 467                         wwarning(_("could not load icon file %s"), iconPath);
 468         } else {
 469                 icon = NULL;
 470         }
 471
 472         if (icon) {
 473                 icon2 = makeTitledIcon(icon);
 474                 if (icon)
 475                         WMReleasePixmap(icon);
 476         } else {
 477                 icon2 = NULL;
 478         }
 479
 480         WMSetButtonImage(bPtr, icon2);
 481
 482         if (icon2)
 483                 WMReleasePixmap(icon2);
 484
 485         color.red = 0xff;
 486         color.green = 0xff;
 487         color.blue = 0xff;
 488         color.alpha = 0;
 489         if (iconPath) {
 490                 icon = WMCreateBlendedPixmapFromFile(scr, iconPath, &color);
 491                 if (!icon)
 492                         wwarning(_("could not load icon file %s"), iconPath);
 493         } else {
 494                 icon = NULL;
 495         }
 496
 497         WMSetButtonAltImage(bPtr, icon);
 498
 499         if (icon)
 500                 WMReleasePixmap(icon);
 501
 502         if (iconPath)
 503                 wfree(iconPath);
 504 }
 505
 506 void AddSection(Panel * panel, const char *iconFile)
 507 {
 508         WMButton *bPtr;
 509
 510         assert(WPrefs.sectionCount < MAX_SECTIONS);
 511
 512         bPtr = WMCreateCustomButton(WPrefs.buttonF, WBBStateLightMask | WBBStateChangeMask);
 513         WMResizeWidget(bPtr, 64, 64);
 514         WMMoveWidget(bPtr, WPrefs.sectionCount * 64, 0);
 515         WMSetButtonImagePosition(bPtr, WIPImageOnly);
 516         WMSetButtonAction(bPtr, changeSection, panel);
 517         WMHangData(bPtr, panel);
 518
 519         WMSetBalloonTextForView(((PanelRec *) panel)->description, WMWidgetView(bPtr));
 520         SetButtonAlphaImage(WMWidgetScreen(bPtr), bPtr, iconFile);
 521         WMMapWidget(bPtr);
 522
 523         WPrefs.sectionB[WPrefs.sectionCount] = bPtr;
 524
 525         if (WPrefs.sectionCount > 0)
 526                 WMGroupButtons(WPrefs.sectionB[0], bPtr);
 527
 528         WPrefs.sectionCount++;
 529
 530         WMResizeWidget(WPrefs.buttonF, WPrefs.sectionCount * 64, 64);
 531 }
 532
 533 void Initialize(WMScreen * scr)
 534 {
 535         char **list;
 536         int i;
 537         char *path;
 538
 539         list = RSupportedFileFormats();
 540         for (i = 0; list[i] != NULL; i++) {
 541                 if (strcmp(list[i], "TIFF") == 0) {
 542                         TIFFOK = True;
 543                         break;
 544                 }
 545         }
 546
 547         if (TIFFOK)
 548                 path = WMPathForResourceOfType("WPrefs.tiff", NULL);
 549         else
 550                 path = WMPathForResourceOfType("WPrefs.xpm", NULL);
 551         if (path) {
 552                 RImage *tmp;
 553
 554                 tmp = RLoadImage(WMScreenRContext(scr), path, 0);
 555                 if (!tmp) {
 556                         wwarning(_("could not load image file %s:%s"), path, RMessageForError(RErrorCode));
 557                 } else {
 558                         WMSetApplicationIconImage(scr, tmp);
 559                         RReleaseImage(tmp);
 560                 }
 561                 wfree(path);
 562         }
 563
 564         memset(&WPrefs, 0, sizeof(_WPrefs));
 565         createMainWindow(scr);
 566
 567         WMRealizeWidget(WPrefs.win);
 568
 569         WMSetWindowMiniwindowImage(WPrefs.win, WMGetApplicationIconImage(scr));
 570
 571         WMMapWidget(WPrefs.win);
 572         XFlush(WMScreenDisplay(scr));
 573         WMSetLabelText(WPrefs.statusL, _("Loading Window Maker configuration files..."));
 574         XFlush(WMScreenDisplay(scr));
 575         loadConfigurations(scr, WPrefs.win);
 576
 577         WMSetLabelText(WPrefs.statusL, _("Initializing configuration panels..."));
 578
 579         InitFocus(WPrefs.banner);
 580         InitWindowHandling(WPrefs.banner);
 581
 582         InitMenuPreferences(WPrefs.banner);
 583         InitIcons(WPrefs.banner);
 584         InitPreferences(WPrefs.banner);
 585
 586         InitPaths(WPrefs.banner);
 587         InitDocks(WPrefs.banner);
 588         InitWorkspace(WPrefs.banner);
 589         InitConfigurations(WPrefs.banner);
 590
 591         InitMenu(WPrefs.banner);
 592
 593 #ifdef not_yet_fully_implemented
 594         InitKeyboardSettings(WPrefs.banner);
 595 #endif
 596         InitKeyboardShortcuts(WPrefs.banner);
 597         InitMouseSettings(WPrefs.banner);
 598
 599         InitAppearance(WPrefs.banner);
 600
 601         InitFontSimple(WPrefs.banner);
 602
 603 #ifdef not_yet_fully_implemented
 604         InitThemes(WPrefs.banner);
 605 #endif
 606         InitExpert(WPrefs.banner);
 607
 608         WMRealizeWidget(WPrefs.scrollV);
 609
 610         WMSetLabelText(WPrefs.statusL, "");
 611 }
 612
 613 WMWindow *GetWindow(void)
 614 {
 615         return WPrefs.win;
 616 }
 617
 618 static void loadConfigurations(WMScreen * scr, WMWindow * mainw)
 619 {
 620         WMPropList *db, *gdb;
 621         char *path;
 622         FILE *file;
 623         char buffer[1024];
 624         char mbuf[1024];
 625         int v1, v2, v3;
 626
 627         path = wdefaultspathfordomain("WindowMaker");
 628         WindowMakerDBPath = path;
 629
 630         db = WMReadPropListFromFile(path);
 631         if (db) {
 632                 if (!WMIsPLDictionary(db)) {
 633                         WMReleasePropList(db);
 634                         db = NULL;
 635                         sprintf(mbuf, _("Window Maker domain (%s) is corrupted!"), path);
 636                         WMRunAlertPanel(scr, mainw, _("Error"), mbuf, _("OK"), NULL, NULL);
 637                 }
 638         } else {
 639                 sprintf(mbuf, _("Could not load Window Maker domain (%s) from defaults database."), path);
 640                 WMRunAlertPanel(scr, mainw, _("Error"), mbuf, _("OK"), NULL, NULL);
 641         }
 642
 643         path = getenv("WMAKER_BIN_NAME");
 644         if (!path)
 645                 path = "wmaker";
 646         {
 647                 char *command;
 648
 649                 command = wstrconcat(path, " --version");
 650                 file = popen(command, "r");
 651                 wfree(command);
 652         }
 653         if (!file || !fgets(buffer, 1023, file)) {
 654                 werror(_("could not extract version information from Window Maker"));
 655                 wfatal(_("Make sure wmaker is in your search path."));
 656
 657                 WMRunAlertPanel(scr, mainw, _("Error"),
 658                                 _
 659                                 ("Could not extract version from Window Maker. Make sure it is correctly installed and is in your PATH environment variable."),
 660                                 _("OK"), NULL, NULL);
 661                 exit(1);
 662         }
 663         if (file)
 664                 pclose(file);
 665
 666         if (sscanf(buffer, "Window Maker %i.%i.%i", &v1, &v2, &v3) != 3
 667             && sscanf(buffer, "WindowMaker %i.%i.%i", &v1, &v2, &v3) != 3) {
 668                 WMRunAlertPanel(scr, mainw, _("Error"),
 669                                 _("Could not extract version from Window Maker. "
 670                                   "Make sure it is correctly installed and the path "
 671                                   "where it installed is in the PATH environment "
 672                                   "variable."), _("OK"), NULL, NULL);
 673                 exit(1);
 674         }
 675         if (v1 == 0 && (v2 < 18 || v3 < 0)) {
 676                 sprintf(mbuf, _("WPrefs only supports Window Maker 0.18.0 or newer.\n"
 677                                 "The version installed is %i.%i.%i\n"), v1, v2, v3);
 678                 WMRunAlertPanel(scr, mainw, _("Error"), mbuf, _("OK"), NULL, NULL);
 679                 exit(1);
 680
 681         }
 682         if (v1 > 1 || (v1 == 1 && (v2 > 0))) {
 683                 sprintf(mbuf,
 684                         _
 685                         ("Window Maker %i.%i.%i, which is installed in your system, is not fully supported by this version of WPrefs."),
 686                         v1, v2, v3);
 687                 WMRunAlertPanel(scr, mainw, _("Warning"), mbuf, _("OK"), NULL, NULL);
 688         }
 689
 690         {
 691                 char *command;
 692
 693                 command = wstrconcat(path, " --global_defaults_path");
 694                 file = popen(command, "r");
 695                 wfree(command);
 696         }
 697         if (!file || !fgets(buffer, 1023, file)) {
 698                 werror(_("could not run \"%s --global_defaults_path\"."), path);
 699                 exit(1);
 700         } else {
 701                 char *ptr;
 702                 ptr = strchr(buffer, '\n');
 703                 if (ptr)
 704                         *ptr = 0;
 705                 strcat(buffer, "/WindowMaker");
 706         }
 707
 708         if (file)
 709                 pclose(file);
 710
 711         gdb = WMReadPropListFromFile(buffer);
 712
 713         if (gdb) {
 714                 if (!WMIsPLDictionary(gdb)) {
 715                         WMReleasePropList(gdb);
 716                         gdb = NULL;
 717                         sprintf(mbuf, _("Window Maker domain (%s) is corrupted!"), buffer);
 718                         WMRunAlertPanel(scr, mainw, _("Error"), mbuf, _("OK"), NULL, NULL);
 719                 }
 720         } else {
 721                 sprintf(mbuf, _("Could not load global Window Maker domain (%s)."), buffer);
 722                 WMRunAlertPanel(scr, mainw, _("Error"), mbuf, _("OK"), NULL, NULL);
 723         }
 724
 725         if (!db) {
 726                 db = WMCreatePLDictionary(NULL, NULL);
 727         }
 728         if (!gdb) {
 729                 gdb = WMCreatePLDictionary(NULL, NULL);
 730         }
 731
 732         GlobalDB = gdb;
 733
 734         WindowMakerDB = db;
 735 }
 736
 737 WMPropList *GetObjectForKey(const char *defaultName)
 738 {
 739         WMPropList *object = NULL;
 740         WMPropList *key = WMCreatePLString(defaultName);
 741
 742         object = WMGetFromPLDictionary(WindowMakerDB, key);
 743         if (!object)
 744                 object = WMGetFromPLDictionary(GlobalDB, key);
 745
 746         WMReleasePropList(key);
 747
 748         return object;
 749 }
 750
 751 void SetObjectForKey(WMPropList * object, const char *defaultName)
 752 {
 753         WMPropList *key = WMCreatePLString(defaultName);
 754
 755         WMPutInPLDictionary(WindowMakerDB, key, object);
 756         WMReleasePropList(key);
 757 }
 758
 759 void RemoveObjectForKey(const char *defaultName)
 760 {
 761         WMPropList *key = WMCreatePLString(defaultName);
 762
 763         WMRemoveFromPLDictionary(WindowMakerDB, key);
 764
 765         WMReleasePropList(key);
 766 }
 767
 768 char *GetStringForKey(const char *defaultName)
 769 {
 770         WMPropList *val;
 771
 772         val = GetObjectForKey(defaultName);
 773
 774         if (!val)
 775                 return NULL;
 776
 777         if (!WMIsPLString(val))
 778                 return NULL;
 779
 780         return WMGetFromPLString(val);
 781 }
 782
 783 WMPropList *GetArrayForKey(const char *defaultName)
 784 {
 785         WMPropList *val;
 786
 787         val = GetObjectForKey(defaultName);
 788
 789         if (!val)
 790                 return NULL;
 791
 792         if (!WMIsPLArray(val))
 793                 return NULL;
 794
 795         return val;
 796 }
 797
 798 WMPropList *GetDictionaryForKey(const char *defaultName)
 799 {
 800         WMPropList *val;
 801
 802         val = GetObjectForKey(defaultName);
 803
 804         if (!val)
 805                 return NULL;
 806
 807         if (!WMIsPLDictionary(val))
 808                 return NULL;
 809
 810         return val;
 811 }
 812
 813 int GetIntegerForKey(const char *defaultName)
 814 {
 815         WMPropList *val;
 816         char *str;
 817         int value;
 818
 819         val = GetObjectForKey(defaultName);
 820
 821         if (!val)
 822                 return 0;
 823
 824         if (!WMIsPLString(val))
 825                 return 0;
 826
 827         str = WMGetFromPLString(val);
 828         if (!str)
 829                 return 0;
 830
 831         if (sscanf(str, "%i", &value) != 1)
 832                 return 0;
 833
 834         return value;
 835 }
 836
 837 Bool GetBoolForKey(const char *defaultName)
 838 {
 839         int value;
 840         char *str;
 841
 842         str = GetStringForKey(defaultName);
 843
 844         if (!str)
 845                 return False;
 846
 847         if (sscanf(str, "%i", &value) == 1 && value != 0)
 848                 return True;
 849
 850         if (strcasecmp(str, "YES") == 0)
 851                 return True;
 852
 853         if (strcasecmp(str, "Y") == 0)
 854                 return True;
 855
 856         return False;
 857 }
 858
 859 void SetIntegerForKey(int value, const char *defaultName)
 860 {
 861         WMPropList *object;
 862         char buffer[128];
 863
 864         sprintf(buffer, "%i", value);
 865         object = WMCreatePLString(buffer);
 866
 867         SetObjectForKey(object, defaultName);
 868         WMReleasePropList(object);
 869 }
 870
 871 void SetStringForKey(const char *value, const char *defaultName)
 872 {
 873         WMPropList *object;
 874
 875         object = WMCreatePLString(value);
 876
 877         SetObjectForKey(object, defaultName);
 878         WMReleasePropList(object);
 879 }
 880
 881 void SetBoolForKey(Bool value, const char *defaultName)
 882 {
 883         static WMPropList *yes = NULL, *no = NULL;
 884
 885         if (!yes) {
 886                 yes = WMCreatePLString("YES");
 887                 no = WMCreatePLString("NO");
 888         }
 889
 890         SetObjectForKey(value ? yes : no, defaultName);
 891 }
 892
 893 void SetSpeedForKey(int speed, const char *defaultName)
 894 {
 895         char *str;
 896
 897         switch (speed) {
 898         case 0:
 899                 str = "ultraslow";
 900                 break;
 901         case 1:
 902                 str = "slow";
 903                 break;
 904         case 2:
 905                 str = "medium";
 906                 break;
 907         case 3:
 908                 str = "fast";
 909                 break;
 910         case 4:
 911                 str = "ultrafast";
 912                 break;
 913         default:
 914                 str = NULL;
 915         }
 916
 917         if (str)
 918                 SetStringForKey(str, defaultName);
 919 }
 920
 921 int GetSpeedForKey(const char *defaultName)
 922 {
 923         char *str;
 924         int i;
 925
 926         str = GetStringForKey(defaultName);
 927         if (!str)
 928                 return 2;
 929
 930         if (strcasecmp(str, "ultraslow") == 0)
 931                 i = 0;
 932         else if (strcasecmp(str, "slow") == 0)
 933                 i = 1;
 934         else if (strcasecmp(str, "medium") == 0)
 935                 i = 2;
 936         else if (strcasecmp(str, "fast") == 0)
 937                 i = 3;
 938         else if (strcasecmp(str, "ultrafast") == 0)
 939                 i = 4;
 940         else {
 941                 wwarning(_("bad speed value for option %s; using default Medium"), defaultName);
 942                 i = 2;
 943         }
 944         return i;
 945 }