WPrefs.app/Expert.c

   1 /* Expert.c- expert user options
   2  *
   3  *  WPrefs - Window Maker Preferences Program
   4  *
   5  *  Copyright (c) 2014 Window Maker Team
   6  *  Copyright (c) 1998-2003 Alfredo K. Kojima
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 2 of the License, or
  11  *  (at your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License along
  19  *  with this program; if not, write to the Free Software Foundation, Inc.,
  20  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  21  */
  22
  23 #include "WPrefs.h"
  24
  25 /* This structure containts the list of all the check-buttons to display in the
  26  * expert tab of the window with the corresponding information for effect
  27  */
  28 static struct expert_option {
  29         const char *label;  /* Text displayed to user */
  30
  31         int def_state;  /* True/False: the default value, if not defined in current config */
  32
  33         enum {
  34                 OPTION_WMAKER,
  35                 OPTION_WMAKER_ARRAY,
  36                 OPTION_USERDEF,
  37                 OPTION_WMAKER_INT
  38         } class;
  39
  40         const char *op_name;  /* The identifier for the option in the config file */
  41
  42 } expert_options[] = {
  43
  44         { N_("Disable miniwindows (icons for minimized windows). For use with KDE/GNOME."),
  45           /* default: */ False, OPTION_WMAKER, "DisableMiniwindows" },
  46
  47         { N_("Ignore decoration hints for GTK applications."),
  48           /* default: */ False, OPTION_WMAKER, "IgnoreGtkHints" },
  49
  50         { N_("Enable workspace pager."),
  51           /* default: */ False, OPTION_WMAKER, "EnableWorkspacePager" },
  52
  53         { N_("Do not set non-WindowMaker specific parameters (do not use xset)."),
  54           /* default: */ False, OPTION_USERDEF, "NoXSetStuff" },
  55
  56         { N_("Automatically save session when exiting Window Maker."),
  57           /* default: */ False, OPTION_WMAKER, "SaveSessionOnExit" },
  58
  59         { N_("Use SaveUnder in window frames, icons, menus and other objects."),
  60           /* default: */ False, OPTION_WMAKER, "UseSaveUnders" },
  61
  62         { N_("Disable confirmation panel for the Kill command."),
  63           /* default: */ False, OPTION_WMAKER, "DontConfirmKill" },
  64
  65         { N_("Disable selection animation for selected icons."),
  66           /* default: */ False, OPTION_WMAKER, "DisableBlinking" },
  67
  68         { N_("Smooth font edges (needs restart)."),
  69           /* default: */ True, OPTION_WMAKER, "AntialiasedText" },
  70
  71         { N_("Cycle windows only on the active head."),
  72           /* default: */ False, OPTION_WMAKER, "CycleActiveHeadOnly" },
  73
  74         { N_("Ignore minimized windows when cycling."),
  75           /* default: */ False, OPTION_WMAKER, "CycleIgnoreMinimized" },
  76
  77         { N_("Show switch panel when cycling windows."),
  78           /* default: */ True, OPTION_WMAKER_ARRAY, "SwitchPanelImages" },
  79
  80         { N_("Show workspace title on Clip."),
  81           /* default: */ True, OPTION_WMAKER, "ShowClipTitle" },
  82
  83         { N_("Highlight the icon of the application when it has the focus."),
  84           /* default: */ True, OPTION_WMAKER, "HighlightActiveApp" },
  85
  86 #ifdef XKB_MODELOCK
  87         { N_("Enable keyboard language switch button in window titlebars."),
  88           /* default: */ False, OPTION_WMAKER, "KbdModeLock" },
  89 #endif /* XKB_MODELOCK */
  90
  91         { N_("Maximize (snap) a window to edge or corner by dragging."),
  92           /* default: */ False, OPTION_WMAKER, "WindowSnapping" },
  93
  94         { N_("Distance from edge to begin window snap."),
  95           /* default: */ 1, OPTION_WMAKER_INT, "SnapEdgeDetect" },
  96
  97         { N_("Distance from corner to begin window snap."),
  98           /* default: */ 10, OPTION_WMAKER_INT, "SnapCornerDetect" },
  99
 100         { N_("Snapping a window to the top maximizes it to the full screen."),
 101           /* default: */ False, OPTION_WMAKER, "SnapToTopMaximizesFullscreen" },
 102
 103         { N_("Allow move half-maximized windows between multiple screens."),
 104           /* default: */ False, OPTION_WMAKER, "MoveHalfMaximizedWindowsBetweenScreens" },
 105
 106         { N_("Alternative transitions between states for half maximized windows."),
 107           /* default: */ False, OPTION_WMAKER, "AlternativeHalfMaximized" },
 108
 109         { N_("Move mouse pointer with half maximized windows."),
 110           /* default: */ False, OPTION_WMAKER, "PointerWithHalfMaxWindows" },
 111
 112         { N_("Open dialogs in the same workspace as their owners."),
 113           /* default: */ False, OPTION_WMAKER, "OpenTransientOnOwnerWorkspace" },
 114
 115         { N_("Wrap dock-attached icons around the screen edges."),
 116           /* default: */ True, OPTION_WMAKER, "WrapAppiconsInDock" },
 117
 118         { N_("Double click on titlebar maximize a window to full screen."),
 119           /* default: */ False, OPTION_WMAKER, "DbClickFullScreen" },
 120
 121         { N_("Close rootmenu when mouse (left or right) is clicked outside focus."),
 122           /* default: */ False, OPTION_WMAKER, "CloseRootMenuByLeftOrRightMouseClick" },
 123         { N_("Keep dock on primary head."),
 124           /* default: */ False, OPTION_WMAKER, "KeepDockOnPrimaryHead"},
 125
 126 };
 127
 128
 129
 130 typedef struct _Panel {
 131         WMBox *box;
 132         char *sectionName;
 133
 134         char *description;
 135
 136         CallbackRec callbacks;
 137
 138         WMWidget *parent;
 139
 140         WMButton *swi[wlengthof_nocheck(expert_options)];
 141
 142         WMTextField *textfield[wlengthof_nocheck(expert_options)];
 143
 144 } _Panel;
 145
 146 #define ICON_FILE       "expert"
 147
 148 static void changeIntTextfield(void *data, int delta)
 149 {
 150         WMTextField *textfield;
 151         char *text, buffer[12];
 152         int value;
 153
 154         textfield = (WMTextField *)data;
 155         text = WMGetTextFieldText(textfield);
 156         value = atoi(text);
 157         wfree(text);
 158         value += delta;
 159         sprintf(buffer, "%d", value);
 160         WMSetTextFieldText(textfield, buffer);
 161 }
 162
 163 static void downButtonCallback(WMWidget *self, void *data)
 164 {
 165         (void) self;
 166         changeIntTextfield(data, -1);
 167 }
 168
 169 static void upButtonCallback(WMWidget *self, void *data)
 170 {
 171         (void) self;
 172         changeIntTextfield(data, 1);
 173 }
 174
 175 static int cmpExpertOptions(const void *v1, const void *v2)
 176 {
 177         int rc;
 178         const struct expert_option *opt1 = (struct expert_option *)v1;
 179         const struct expert_option *opt2 = (struct expert_option *)v2;
 180
 181         if ((rc = strcmp(opt1->label, opt2->label)) < 0)
 182                 return -1;
 183         else if (rc > 0)
 184                 return 1;
 185         return 0;
 186 }
 187
 188 static void createPanel(Panel *p)
 189 {
 190         _Panel *panel = (_Panel *) p;
 191         WMScrollView *sv;
 192         WMFrame *f;
 193         WMUserDefaults *udb;
 194         int i, state;
 195
 196         panel->box = WMCreateBox(panel->parent);
 197         WMSetViewExpandsToParent(WMWidgetView(panel->box), 2, 2, 2, 2);
 198
 199         sv = WMCreateScrollView(panel->box);
 200         WMResizeWidget(sv, 500, 215);
 201         WMMoveWidget(sv, 12, 10);
 202         WMSetScrollViewRelief(sv, WRSunken);
 203         WMSetScrollViewHasVerticalScroller(sv, True);
 204         WMSetScrollViewHasHorizontalScroller(sv, False);
 205
 206         f = WMCreateFrame(panel->box);
 207         WMResizeWidget(f, 495, wlengthof(expert_options) * 25 + 8);
 208         WMSetFrameRelief(f, WRFlat);
 209
 210         udb = WMGetStandardUserDefaults();
 211         qsort(expert_options, wlengthof(expert_options), sizeof(expert_options[0]), cmpExpertOptions);
 212         for (i = 0; i < wlengthof(expert_options); i++) {
 213                 if (expert_options[i].class != OPTION_WMAKER_INT) {
 214                         panel->swi[i] = WMCreateSwitchButton(f);
 215                         WMResizeWidget(panel->swi[i], FRAME_WIDTH - 40, 25);
 216                         WMMoveWidget(panel->swi[i], 5, 5 + i * 25);
 217
 218                         WMSetButtonText(panel->swi[i], _(expert_options[i].label));
 219                 }
 220
 221                 switch (expert_options[i].class) {
 222                 case OPTION_WMAKER:
 223                         if (GetStringForKey(expert_options[i].op_name))
 224                                 state = GetBoolForKey(expert_options[i].op_name);
 225                         else
 226                                 state = expert_options[i].def_state;
 227                         break;
 228
 229                 case OPTION_WMAKER_ARRAY: {
 230                                 char *str = GetStringForKey(expert_options[i].op_name);
 231                                 state = expert_options[i].def_state;
 232                                 if (str && strcasecmp(str, "None") == 0)
 233                                         state = False;
 234                         }
 235                         break;
 236
 237                 case OPTION_USERDEF:
 238                         state = WMGetUDBoolForKey(udb, expert_options[i].op_name);
 239                         break;
 240
 241                 case OPTION_WMAKER_INT:
 242                 {
 243                         char tmp[10];
 244                         WMButton *up, *down;
 245                         WMLabel *label;
 246
 247                         panel->textfield[i] = WMCreateTextField(f);
 248                         WMResizeWidget(panel->textfield[i], 41, 20);
 249                         WMMoveWidget(panel->textfield[i], 22, 7 + i * 25);
 250
 251                         down = WMCreateCommandButton(f);
 252                         WMSetButtonImage(down, WMGetSystemPixmap(WMWidgetScreen(down), WSIArrowDown));
 253                         WMSetButtonAltImage(down,
 254                                             WMGetSystemPixmap(WMWidgetScreen(down), WSIHighlightedArrowDown));
 255                         WMSetButtonImagePosition(down, WIPImageOnly);
 256                         WMSetButtonAction(down, downButtonCallback, panel->textfield[i]);
 257                         WMResizeWidget(down, 16, 16);
 258                         WMMoveWidget(down, 5, 9 + i * 25);
 259
 260                         up = WMCreateCommandButton(f);
 261                         WMSetButtonImage(up, WMGetSystemPixmap(WMWidgetScreen(up), WSIArrowUp));
 262                         WMSetButtonAltImage(up, WMGetSystemPixmap(WMWidgetScreen(up), WSIHighlightedArrowUp));
 263                         WMSetButtonImagePosition(up, WIPImageOnly);
 264                         WMSetButtonAction(up, upButtonCallback, panel->textfield[i]);
 265                         WMResizeWidget(up, 16, 16);
 266                         WMMoveWidget(up, 64, 9 + i * 25);
 267
 268                         label = WMCreateLabel(f);
 269                         WMSetLabelText(label, _(expert_options[i].label));
 270                         WMResizeWidget(label, FRAME_WIDTH - 99, 25);
 271                         WMMoveWidget(label, 85, 5 + i * 25);
 272
 273                         if (GetStringForKey(expert_options[i].op_name))
 274                                 state = GetIntegerForKey(expert_options[i].op_name);
 275                         else
 276                                 state = expert_options[i].def_state;
 277
 278                         sprintf(tmp, "%d", state);
 279                         WMSetTextFieldText(panel->textfield[i], tmp);
 280
 281                         break;
 282                 }
 283
 284                 default:
 285 #ifdef DEBUG
 286                         wwarning("export_options[%d].class = %d, this should not happen\n",
 287                                 i, expert_options[i].class);
 288 #endif
 289                         state = expert_options[i].def_state;
 290                         break;
 291                 }
 292                 if (expert_options[i].class != OPTION_WMAKER_INT)
 293                         WMSetButtonSelected(panel->swi[i], state);
 294         }
 295
 296         WMMapSubwidgets(panel->box);
 297         WMSetScrollViewContentView(sv, WMWidgetView(f));
 298         WMRealizeWidget(panel->box);
 299 }
 300
 301 static void storeDefaults(_Panel *panel)
 302 {
 303         WMUserDefaults *udb = WMGetStandardUserDefaults();
 304         int i;
 305
 306         for (i = 0; i < wlengthof(expert_options); i++) {
 307                 switch (expert_options[i].class) {
 308                 case OPTION_WMAKER:
 309                         SetBoolForKey(WMGetButtonSelected(panel->swi[i]), expert_options[i].op_name);
 310                         break;
 311
 312                 case OPTION_WMAKER_ARRAY:
 313                         if (WMGetButtonSelected(panel->swi[i])) {
 314                                 /* check if the array was not manually modified */
 315                                 char *str = GetStringForKey(expert_options[i].op_name);
 316                                 if (str && strcasecmp(str, "None") == 0)
 317                                         RemoveObjectForKey(expert_options[i].op_name);
 318                         }
 319                         else
 320                                 SetStringForKey("None", expert_options[i].op_name);
 321                         break;
 322
 323                 case OPTION_USERDEF:
 324                         WMSetUDBoolForKey(udb, WMGetButtonSelected(panel->swi[i]), expert_options[i].op_name);
 325                         break;
 326
 327                 case OPTION_WMAKER_INT:
 328                 {
 329                         char *text;
 330                         int value;
 331
 332                         text = WMGetTextFieldText(panel->textfield[i]);
 333                         value = atoi(text);
 334                         wfree(text);
 335
 336                         SetIntegerForKey(value, expert_options[i].op_name);
 337                         break;
 338                 }
 339                 }
 340         }
 341 }
 342
 343 Panel *InitExpert(WMWidget *parent)
 344 {
 345         _Panel *panel;
 346
 347         panel = wmalloc(sizeof(_Panel));
 348
 349         panel->sectionName = _("Expert User Preferences");
 350
 351         panel->description = _("Options for people who know what they're doing...\n"
 352                                "Also has some other misc. options.");
 353
 354         panel->parent = parent;
 355
 356         panel->callbacks.createWidgets = createPanel;
 357         panel->callbacks.updateDomain = storeDefaults;
 358
 359         AddSection(panel, ICON_FILE);
 360
 361         return panel;
 362 }