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