WPrefs.app/Docks.c

   1 /* Workspace.c- workspace options
   2  *
   3  *  WPrefs - Window Maker Preferences Program
   4  *
   5  *  Copyright (c) 2012 Daniel Déchelotte (heavily inspired from file (c) 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
  24 typedef struct _Panel {
  25         WMBox *box;
  26
  27         char *sectionName;
  28
  29         char *description;
  30
  31         CallbackRec callbacks;
  32
  33         WMWidget *parent;
  34
  35         WMFrame *autoDelayF[2];
  36         WMLabel *autoDelayL[4];
  37         WMButton *autoDelayB[4][5];
  38         WMTextField *autoDelayT[4];
  39
  40         WMFrame *dockF;
  41         WMButton *docksB[3];
  42 } _Panel;
  43
  44 #define ICON_FILE       "dockclipdrawersection"
  45
  46 #define ARQUIVO_XIS     "xis"
  47 #define DELAY_ICON "timer%i"
  48 #define DELAY_ICON_S "timer%is"
  49
  50 static const struct {
  51         const char *key;
  52         const char *string;
  53 } auto_delay[] = {
  54         { "ClipAutoexpandDelay",   N_("Delay before auto-expansion") },
  55         { "ClipAutocollapseDelay", N_("Delay before auto-collapsing") },
  56         { "ClipAutoraiseDelay",    N_("Delay before auto-raise") },
  57         { "ClipAutolowerDelay",    N_("Delay before auto-lowering") }
  58 };
  59
  60
  61 static char *autoDelayPresetValues[5] = { "0", "100", "250", "600", "1000" };
  62
  63 static const struct {
  64         const char *disable_key;
  65         const char *icon_file;
  66 } dock_config[] = {
  67         { "DisableDock",    "dock"   },
  68         { "DisableClip",    "clip"   },
  69         { "DisableDrawers", "drawer" }
  70 };
  71
  72 static void showData(_Panel *panel);
  73 static void storeData(_Panel *panel);
  74
  75
  76 static void pushAutoDelayButton(WMWidget *w, void *data)
  77 {
  78         _Panel *panel = (_Panel *) data;
  79         int i, j;
  80         for (i = 0; i < 4; i++)
  81         {
  82                 for (j = 0; j < 5; j++)
  83                 {
  84                         if (w == panel->autoDelayB[i][j])
  85                         {
  86                                 WMSetTextFieldText(panel->autoDelayT[i], autoDelayPresetValues[j]);
  87                                 return;
  88                         }
  89                 }
  90         }
  91 }
  92
  93 static void adjustButtonSelectionBasedOnValue(_Panel *panel, int row, const char *value)
  94 {
  95         int j;
  96
  97         if (!value)
  98                 return;
  99
 100         for (j = 0; j < 5; j++)
 101         {
 102                 int isThatOne = !strcmp(autoDelayPresetValues[j], value);
 103                 WMSetButtonSelected(panel->autoDelayB[row][j], isThatOne);
 104                 if (isThatOne)
 105                         return;
 106         }
 107 }
 108
 109 static void autoDelayChanged(void *observerData, WMNotification *notification)
 110 {
 111         _Panel *panel = (_Panel *) observerData;
 112         int row;
 113         WMTextField *anAutoDelayT = (WMTextField *) WMGetNotificationObject(notification);
 114         for (row = 0; row < 4; row++)
 115         {
 116                 if (anAutoDelayT != panel->autoDelayT[row])
 117                 {
 118                         continue;
 119                 }
 120                 char *value = WMGetTextFieldText(anAutoDelayT);
 121                 adjustButtonSelectionBasedOnValue(panel, row, value);
 122                 return;
 123         }
 124 }
 125
 126 static void pushDockButton(WMWidget *w, void *data)
 127 {
 128         _Panel *panel = (_Panel *) data;
 129         WMButton *button = (WMButton *) w;
 130         if (button == panel->docksB[0] &&
 131             !WMGetButtonSelected(panel->docksB[0]))
 132         {
 133                 WMSetButtonSelected(panel->docksB[2], False);
 134         }
 135         if (button == panel->docksB[2] &&
 136             WMGetButtonSelected(panel->docksB[2]))
 137         {
 138                 WMSetButtonSelected(panel->docksB[0], True);
 139         }
 140 }
 141
 142 static void createPanel(Panel *p)
 143 {
 144         _Panel *panel = (_Panel *) p;
 145         WMScreen *scr = WMWidgetScreen(panel->parent);
 146         WMPixmap *icon1, *icon2;
 147         RImage *xis = NULL;
 148         RContext *rc = WMScreenRContext(scr);
 149         char *path;
 150         int i, j, k;
 151         char *buf1, *buf2;
 152
 153         path = LocateImage(ARQUIVO_XIS);
 154         if (path) {
 155                 xis = RLoadImage(rc, path, 0);
 156                 if (!xis) {
 157                         wwarning(_("could not load image file %s"), path);
 158                 }
 159                 wfree(path);
 160         }
 161
 162         panel->box = WMCreateBox(panel->parent);
 163         WMSetViewExpandsToParent(WMWidgetView(panel->box), 2, 2, 2, 2);
 164
 165         /***************** Auto-delays *****************/
 166         buf1 = wmalloc(strlen(DELAY_ICON) + 1);
 167         buf2 = wmalloc(strlen(DELAY_ICON_S) + 1);
 168
 169         for (k = 0; k < 2; k++)
 170         {
 171                 panel->autoDelayF[k] = WMCreateFrame(panel->box);
 172                 WMResizeWidget(panel->autoDelayF[k], 365, 100);
 173                 WMMoveWidget(panel->autoDelayF[k], 15, 10 + k * 110);
 174                 if (k == 0)
 175                         WMSetFrameTitle(panel->autoDelayF[k], _("Delays in milliseconds for autocollapsing clips"));
 176                 else
 177                         WMSetFrameTitle(panel->autoDelayF[k], _("Delays in milliseconds for autoraising clips"));
 178
 179                 for (i = 0; i < 2; i++)
 180                 {
 181                         panel->autoDelayL[i + k * 2] = WMCreateLabel(panel->autoDelayF[k]);
 182                         WMResizeWidget(panel->autoDelayL[i + k * 2], 165, 20);
 183                         WMMoveWidget(panel->autoDelayL[i + k * 2], 10, 27 + 40 * i);
 184                         WMSetLabelText(panel->autoDelayL[i + k * 2], _(auto_delay[i + k * 2].string));
 185                         WMSetLabelTextAlignment(panel->autoDelayL[i + k * 2], WARight);
 186
 187                         for (j = 0; j < 5; j++)
 188                         {
 189                                 panel->autoDelayB[i + k * 2][j] = WMCreateCustomButton(panel->autoDelayF[k], WBBStateChangeMask);
 190                                 WMResizeWidget(panel->autoDelayB[i + k * 2][j], 25, 25);
 191                                 WMMoveWidget(panel->autoDelayB[i + k * 2][j], 175 + (25 * j), 25 + 40 * i);
 192                                 WMSetButtonBordered(panel->autoDelayB[i + k * 2][j], False);
 193                                 WMSetButtonImagePosition(panel->autoDelayB[i + k * 2][j], WIPImageOnly);
 194                                 WMSetButtonAction(panel->autoDelayB[i + k * 2][j], pushAutoDelayButton, panel);
 195                                 if (j > 0)
 196                                         WMGroupButtons(panel->autoDelayB[i + k * 2][0], panel->autoDelayB[i + k * 2][j]);
 197                                 sprintf(buf1, DELAY_ICON, j);
 198                                 CreateImages(scr, rc, NULL, buf1, &icon1, NULL);
 199                                 if (icon1) {
 200                                         WMSetButtonImage(panel->autoDelayB[i + k * 2][j], icon1);
 201                                         WMReleasePixmap(icon1);
 202                                 } else {
 203                                         wwarning(_("could not load icon file %s"), buf1);
 204                                 }
 205                                 sprintf(buf2, DELAY_ICON_S, j);
 206                                 CreateImages(scr, rc, NULL, buf2, &icon2, NULL);
 207                                 if (icon2) {
 208                                         WMSetButtonAltImage(panel->autoDelayB[i + k * 2][j], icon2);
 209                                         WMReleasePixmap(icon2);
 210                                 } else {
 211                                         wwarning(_("could not load icon file %s"), buf2);
 212                                 }
 213                         }
 214
 215                         panel->autoDelayT[i + k * 2] = WMCreateTextField(panel->autoDelayF[k]);
 216                         WMResizeWidget(panel->autoDelayT[i + k * 2], 36, 20);
 217                         WMMoveWidget(panel->autoDelayT[i + k * 2], 310, 27 + 40 * i);
 218                         WMAddNotificationObserver(autoDelayChanged, panel, WMTextDidChangeNotification, panel->autoDelayT[i + k * 2]);
 219                 }
 220
 221                 WMMapSubwidgets(panel->autoDelayF[k]);
 222         }
 223         wfree(buf1);
 224         wfree(buf2);
 225
 226         /***************** Enable/disable clip/dock/drawers *****************/
 227         panel->dockF = WMCreateFrame(panel->box);
 228         WMResizeWidget(panel->dockF, 115, 210);
 229         WMMoveWidget(panel->dockF, 390, 10);
 230         WMSetFrameTitle(panel->dockF, _("Dock/Clip/Drawer"));
 231
 232         for (i = 0; i < 3; i++)
 233         {
 234                 panel->docksB[i] = WMCreateButton(panel->dockF, WBTToggle);
 235                 WMResizeWidget(panel->docksB[i], 56, 56);
 236                 WMMoveWidget(panel->docksB[i], 30, 20 + 62 * i);
 237                 WMSetButtonImagePosition(panel->docksB[i], WIPImageOnly);
 238                 CreateImages(scr, rc, xis, dock_config[i].icon_file, &icon1, &icon2);
 239                 if (icon2) {
 240                         WMSetButtonImage(panel->docksB[i], icon2);
 241                         WMReleasePixmap(icon2);
 242                 }
 243                 if (icon1) {
 244                         WMSetButtonAltImage(panel->docksB[i], icon1);
 245                         WMReleasePixmap(icon1);
 246                 }
 247                 switch(i)
 248                 {
 249                 case 0:
 250                         WMSetBalloonTextForView(_("Disable/enable the application Dock (the\n"
 251                                                   "vertical icon bar in the side of the screen)."), WMWidgetView(panel->docksB[i]));
 252                         break;
 253                 case 1:
 254                         WMSetBalloonTextForView(_("Disable/enable the Clip (that thing with\n"
 255                                                   "a paper clip icon)."), WMWidgetView(panel->docksB[i]));
 256                         break;
 257                 case 2:
 258                         WMSetBalloonTextForView(_("Disable/enable Drawers (a dock that stores\n"
 259                                                   "application icons horizontally). The dock is required."), WMWidgetView(panel->docksB[i]));
 260                         break;
 261                 }
 262                 WMSetButtonAction(panel->docksB[i], pushDockButton, panel);
 263         }
 264
 265         WMMapSubwidgets(panel->dockF);
 266
 267         if (xis)
 268                 RReleaseImage(xis);
 269
 270         WMRealizeWidget(panel->box);
 271         WMMapSubwidgets(panel->box);
 272
 273         showData(panel);
 274 }
 275
 276 static void storeData(_Panel *panel)
 277 {
 278         int i;
 279         for (i = 0; i < 4; i++)
 280         {
 281                 SetStringForKey(WMGetTextFieldText(panel->autoDelayT[i]), auto_delay[i].key);
 282         }
 283         for (i = 0; i < 3; i++)
 284         {
 285                 SetBoolForKey(!WMGetButtonSelected(panel->docksB[i]), dock_config[i].disable_key);
 286         }
 287 }
 288
 289 static void showData(_Panel *panel)
 290 {
 291         char *value;
 292         int i;
 293         for (i = 0; i < 4; i++)
 294         {
 295                 value = GetStringForKey(auto_delay[i].key);
 296                 WMSetTextFieldText(panel->autoDelayT[i], value);
 297                 adjustButtonSelectionBasedOnValue(panel, i, value);
 298         }
 299         for (i = 0; i < 3; i++)
 300         {
 301                 WMSetButtonSelected(panel->docksB[i], !GetBoolForKey(dock_config[i].disable_key));
 302         }
 303 }
 304
 305 Panel *InitDocks(WMWidget *parent)
 306 {
 307         _Panel *panel;
 308
 309         panel = wmalloc(sizeof(_Panel));
 310         memset(panel, 0, sizeof(_Panel));
 311
 312         panel->sectionName = _("Dock Preferences");
 313
 314         panel->description = _("Dock and clip features.\n"
 315                                "Enable/disable the Dock and Clip, and tune some delays.");
 316
 317         panel->parent = parent;
 318
 319         panel->callbacks.createWidgets = createPanel;
 320         panel->callbacks.updateDomain = storeData;
 321
 322         AddSection(panel, ICON_FILE);
 323
 324         return panel;
 325 }