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