WPrefs.app/WindowHandling.c

   1 /* WindowHandling.c- options for handling windows
   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
  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 *placF;
  36         WMPopUpButton *placP;
  37         WMLabel *porigL;
  38         WMLabel *porigvL;
  39         WMFrame *porigF;
  40         WMLabel *porigW;
  41
  42         WMSlider *vsli;
  43         WMSlider *hsli;
  44
  45         WMFrame *resF;
  46         WMSlider *resS;
  47         WMLabel *resL;
  48         WMButton *resaB;
  49         WMButton *resrB;
  50
  51         WMFrame *maxiF;
  52         WMButton *miconB;
  53         WMButton *mdockB;
  54
  55         WMLabel *resizeL;
  56         WMLabel *resizeTextL;
  57         WMSlider *resizeS;
  58
  59         WMFrame *opaqF;
  60         WMButton *opaqB;
  61
  62         WMButton *opaqresizeB;
  63
  64         WMFrame *tranF;
  65         WMButton *tranB;
  66 } _Panel;
  67
  68 #define ICON_FILE "whandling"
  69
  70 #define OPAQUE_MOVE_PIXMAP "opaque"
  71
  72 #define NON_OPAQUE_MOVE_PIXMAP "nonopaque"
  73
  74 #define OPAQUE_RESIZE_PIXMAP "opaqueresize"
  75
  76 #define NON_OPAQUE_RESIZE_PIXMAP "noopaqueresize"
  77
  78 #define THUMB_SIZE      16
  79
  80 static char *placements[] = {
  81         "auto",
  82         "random",
  83         "manual",
  84         "cascade",
  85         "smart"
  86 };
  87
  88 static void sliderCallback(WMWidget * w, void *data)
  89 {
  90         _Panel *panel = (_Panel *) data;
  91         int x, y, rx, ry;
  92         char buffer[64];
  93         int swidth = WMGetSliderMaxValue(panel->hsli);
  94         int sheight = WMGetSliderMaxValue(panel->vsli);
  95
  96         x = WMGetSliderValue(panel->hsli);
  97         y = WMGetSliderValue(panel->vsli);
  98
  99         rx = x * (WMWidgetWidth(panel->porigF) - 3) / swidth + 2;
 100         ry = y * (WMWidgetHeight(panel->porigF) - 3) / sheight + 2;
 101         WMMoveWidget(panel->porigW, rx, ry);
 102
 103         sprintf(buffer, "(%i,%i)", x, y);
 104         WMSetLabelText(panel->porigvL, buffer);
 105 }
 106
 107 static void resistanceCallback(WMWidget * w, void *data)
 108 {
 109         _Panel *panel = (_Panel *) data;
 110         char buffer[64];
 111         int i;
 112
 113         i = WMGetSliderValue(panel->resS);
 114
 115         if (i == 0)
 116                 WMSetLabelText(panel->resL, "OFF");
 117         else {
 118                 sprintf(buffer, "%i", i);
 119                 WMSetLabelText(panel->resL, buffer);
 120         }
 121 }
 122
 123 static void resizeCallback(WMWidget * w, void *data)
 124 {
 125         _Panel *panel = (_Panel *) data;
 126         char buffer[64];
 127         int i;
 128
 129         i = WMGetSliderValue(panel->resizeS);
 130
 131         if (i == 0)
 132                 WMSetLabelText(panel->resizeL, "OFF");
 133         else {
 134                 sprintf(buffer, "%i", i);
 135                 WMSetLabelText(panel->resizeL, buffer);
 136         }
 137 }
 138
 139 static int getPlacement(char *str)
 140 {
 141         if (!str)
 142                 return 0;
 143
 144         if (strcasecmp(str, "auto") == 0)
 145                 return 0;
 146         else if (strcasecmp(str, "random") == 0)
 147                 return 1;
 148         else if (strcasecmp(str, "manual") == 0)
 149                 return 2;
 150         else if (strcasecmp(str, "cascade") == 0)
 151                 return 3;
 152         else if (strcasecmp(str, "smart") == 0)
 153                 return 4;
 154         else
 155                 wwarning(_("bad option value %s in WindowPlacement. Using default value"), str);
 156         return 0;
 157 }
 158
 159 static void showData(_Panel * panel)
 160 {
 161         char *str;
 162         WMPropList *arr;
 163         int x, y;
 164
 165         str = GetStringForKey("WindowPlacement");
 166
 167         WMSetPopUpButtonSelectedItem(panel->placP, getPlacement(str));
 168
 169         arr = GetObjectForKey("WindowPlaceOrigin");
 170
 171         x = 0;
 172         y = 0;
 173         if (arr && (!WMIsPLArray(arr) || WMGetPropListItemCount(arr) != 2)) {
 174                 wwarning(_("invalid data in option WindowPlaceOrigin. Using default (0,0)"));
 175         } else {
 176                 if (arr) {
 177                         x = atoi(WMGetFromPLString(WMGetFromPLArray(arr, 0)));
 178                         y = atoi(WMGetFromPLString(WMGetFromPLArray(arr, 1)));
 179                 }
 180         }
 181
 182         WMSetSliderValue(panel->hsli, x);
 183         WMSetSliderValue(panel->vsli, y);
 184
 185         sliderCallback(NULL, panel);
 186
 187         x = GetIntegerForKey("EdgeResistance");
 188         WMSetSliderValue(panel->resS, x);
 189         resistanceCallback(NULL, panel);
 190
 191         x = GetIntegerForKey("ResizeIncrement");
 192         WMSetSliderValue(panel->resizeS, x);
 193         resizeCallback(NULL, panel);
 194
 195         WMSetButtonSelected(panel->tranB, GetBoolForKey("OpenTransientOnOwnerWorkspace"));
 196
 197         WMSetButtonSelected(panel->opaqB, GetBoolForKey("OpaqueMove"));
 198
 199         WMSetButtonSelected(panel->opaqresizeB, GetBoolForKey("OpaqueResize"));
 200
 201         WMSetButtonSelected(panel->miconB, GetBoolForKey("NoWindowOverIcons"));
 202
 203         WMSetButtonSelected(panel->mdockB, GetBoolForKey("NoWindowOverDock"));
 204
 205         if (GetBoolForKey("Attraction"))
 206                 WMPerformButtonClick(panel->resrB);
 207         else
 208                 WMPerformButtonClick(panel->resaB);
 209 }
 210
 211 static void storeData(_Panel * panel)
 212 {
 213         WMPropList *arr;
 214         char x[16], y[16];
 215
 216         SetBoolForKey(WMGetButtonSelected(panel->miconB), "NoWindowOverIcons");
 217         SetBoolForKey(WMGetButtonSelected(panel->mdockB), "NoWindowOverDock");
 218         SetBoolForKey(WMGetButtonSelected(panel->opaqB), "OpaqueMove");
 219         SetBoolForKey(WMGetButtonSelected(panel->opaqresizeB), "OpaqueResize");
 220         SetBoolForKey(WMGetButtonSelected(panel->tranB), "OpenTransientOnOwnerWorkspace");
 221         SetStringForKey(placements[WMGetPopUpButtonSelectedItem(panel->placP)], "WindowPlacement");
 222         sprintf(x, "%i", WMGetSliderValue(panel->hsli));
 223         sprintf(y, "%i", WMGetSliderValue(panel->vsli));
 224         arr = WMCreatePLArray(WMCreatePLString(x), WMCreatePLString(y), NULL);
 225         SetObjectForKey(arr, "WindowPlaceOrigin");
 226         SetIntegerForKey(WMGetSliderValue(panel->resS), "EdgeResistance");
 227         SetIntegerForKey(WMGetSliderValue(panel->resizeS), "ResizeIncrement");
 228         SetBoolForKey(WMGetButtonSelected(panel->resrB), "Attraction");
 229         WMReleasePropList(arr);
 230 }
 231
 232 static void createPanel(Panel * p)
 233 {
 234         _Panel *panel = (Panel *) p;
 235         WMScreen *scr = WMWidgetScreen(panel->parent);
 236         WMColor *color;
 237         WMPixmap *pixmap;
 238         int width, height;
 239         int swidth, sheight;
 240         char *path;
 241         WMBox *hbox;
 242
 243         panel->box = WMCreateBox(panel->parent);
 244         WMSetViewExpandsToParent(WMWidgetView(panel->box), 2, 2, 2, 2);
 245         WMSetBoxHorizontal(panel->box, False);
 246         WMSetBoxBorderWidth(panel->box, 8);
 247
 248         hbox = WMCreateBox(panel->box);
 249         WMSetBoxHorizontal(hbox, True);
 250         WMAddBoxSubview(panel->box, WMWidgetView(hbox), False, True, 110, 0, 10);
 251
 252     /************** Window Placement ***************/
 253         panel->placF = WMCreateFrame(hbox);
 254         WMMapWidget(panel->placF);
 255         WMAddBoxSubview(hbox, WMWidgetView(panel->placF), True, True, 100, 0, 10);
 256
 257         WMSetFrameTitle(panel->placF, _("Window Placement"));
 258         WMSetBalloonTextForView(_("How to place windows when they are first put\n"
 259                                   "on screen."), WMWidgetView(panel->placF));
 260
 261         panel->placP = WMCreatePopUpButton(panel->placF);
 262         WMResizeWidget(panel->placP, 105, 20);
 263         WMMoveWidget(panel->placP, 15, 20);
 264         WMAddPopUpButtonItem(panel->placP, _("Automatic"));
 265         WMAddPopUpButtonItem(panel->placP, _("Random"));
 266         WMAddPopUpButtonItem(panel->placP, _("Manual"));
 267         WMAddPopUpButtonItem(panel->placP, _("Cascade"));
 268         WMAddPopUpButtonItem(panel->placP, _("Smart"));
 269
 270         panel->porigL = WMCreateLabel(panel->placF);
 271         WMResizeWidget(panel->porigL, 120, 32);
 272         WMMoveWidget(panel->porigL, 5, 45);
 273         WMSetLabelTextAlignment(panel->porigL, WACenter);
 274         WMSetLabelText(panel->porigL, _("Placement Origin"));
 275
 276         panel->porigvL = WMCreateLabel(panel->placF);
 277         WMResizeWidget(panel->porigvL, 80, 20);
 278         WMMoveWidget(panel->porigvL, 30, 75);
 279         WMSetLabelTextAlignment(panel->porigvL, WACenter);
 280
 281         color = WMCreateRGBColor(scr, 0x5100, 0x5100, 0x7100, True);
 282         panel->porigF = WMCreateFrame(panel->placF);
 283         WMSetWidgetBackgroundColor(panel->porigF, color);
 284         WMReleaseColor(color);
 285         WMSetFrameRelief(panel->porigF, WRSunken);
 286
 287         swidth = WidthOfScreen(DefaultScreenOfDisplay(WMScreenDisplay(scr)));
 288         sheight = HeightOfScreen(DefaultScreenOfDisplay(WMScreenDisplay(scr)));
 289
 290         if (sheight > swidth) {
 291                 height = 70;
 292                 width = 70 * swidth / sheight;
 293                 if (width > 240)
 294                         width = 240;
 295                 height = 240 * sheight / swidth;
 296         } else {
 297                 width = 240;
 298                 height = 240 * sheight / swidth;
 299                 if (height > 70)
 300                         height = 70;
 301                 width = 70 * swidth / sheight;
 302         }
 303         WMResizeWidget(panel->porigF, width, height);
 304         WMMoveWidget(panel->porigF, 130 + (240 - width) / 2, 20 + (70 - height) / 2);
 305
 306         panel->porigW = WMCreateLabel(panel->porigF);
 307         WMResizeWidget(panel->porigW, THUMB_SIZE, THUMB_SIZE);
 308         WMMoveWidget(panel->porigW, 2, 2);
 309         WMSetLabelRelief(panel->porigW, WRRaised);
 310
 311         panel->hsli = WMCreateSlider(panel->placF);
 312         WMResizeWidget(panel->hsli, width, 12);
 313         WMMoveWidget(panel->hsli, 130 + (240 - width) / 2, 20 + (70 - height) / 2 + height + 2);
 314         WMSetSliderAction(panel->hsli, sliderCallback, panel);
 315         WMSetSliderMinValue(panel->hsli, 0);
 316         WMSetSliderMaxValue(panel->hsli, swidth);
 317
 318         panel->vsli = WMCreateSlider(panel->placF);
 319         WMResizeWidget(panel->vsli, 12, height);
 320         WMMoveWidget(panel->vsli, 130 + (240 - width) / 2 + width + 2, 20 + (70 - height) / 2);
 321         WMSetSliderAction(panel->vsli, sliderCallback, panel);
 322         WMSetSliderMinValue(panel->vsli, 0);
 323         WMSetSliderMaxValue(panel->vsli, sheight);
 324
 325         WMMapSubwidgets(panel->porigF);
 326
 327         WMMapSubwidgets(panel->placF);
 328
 329     /************** Opaque Move, Resize ***************/
 330         panel->opaqF = WMCreateFrame(hbox);
 331         WMMapWidget(panel->opaqF);
 332         WMAddBoxSubview(hbox, WMWidgetView(panel->opaqF), False, True, 122, 0, 0);
 333
 334         WMSetFrameTitle(panel->opaqF, _("Opaque Move/Resize"));
 335         WMSetBalloonTextForView(_("Whether the window contents or only a frame should\n"
 336                                   "be displayed during a move or resize.\n"),
 337                                 WMWidgetView(panel->opaqF));
 338
 339         panel->opaqB = WMCreateButton(panel->opaqF, WBTToggle);
 340         WMResizeWidget(panel->opaqB, 48,48);
 341         WMMoveWidget(panel->opaqB, 7, 35);
 342         WMSetButtonImagePosition(panel->opaqB, WIPImageOnly);
 343
 344         path = LocateImage(NON_OPAQUE_MOVE_PIXMAP);
 345         if (path) {
 346                 pixmap = WMCreatePixmapFromFile(scr, path);
 347                 if (pixmap) {
 348                         WMSetButtonImage(panel->opaqB, pixmap);
 349                         WMReleasePixmap(pixmap);
 350                 } else {
 351                         wwarning(_("could not load icon %s"), path);
 352                 }
 353                 wfree(path);
 354         }
 355
 356         path = LocateImage(OPAQUE_MOVE_PIXMAP);
 357         if (path) {
 358                 pixmap = WMCreatePixmapFromFile(scr, path);
 359                 if (pixmap) {
 360                         WMSetButtonAltImage(panel->opaqB, pixmap);
 361                         WMReleasePixmap(pixmap);
 362                 } else {
 363                         wwarning(_("could not load icon %s"), path);
 364                 }
 365                 wfree(path);
 366         }
 367
 368
 369
 370         panel->opaqresizeB = WMCreateButton(panel->opaqF, WBTToggle);
 371         WMResizeWidget(panel->opaqresizeB, 48,48);
 372         WMMoveWidget(panel->opaqresizeB, 65, 35);
 373         WMSetButtonImagePosition(panel->opaqresizeB, WIPImageOnly);
 374
 375         path = LocateImage(NON_OPAQUE_RESIZE_PIXMAP);
 376         if (path) {
 377                 pixmap = WMCreatePixmapFromFile(scr, path);
 378                 if (pixmap) {
 379                         WMSetButtonImage(panel->opaqresizeB, pixmap);
 380                         WMReleasePixmap(pixmap);
 381                 } else {
 382                         wwarning(_("could not load icon %s"), path);
 383                 }
 384                 wfree(path);
 385         }
 386
 387         path = LocateImage(OPAQUE_RESIZE_PIXMAP);
 388         if (path) {
 389                 pixmap = WMCreatePixmapFromFile(scr, path);
 390                 if (pixmap) {
 391                         WMSetButtonAltImage(panel->opaqresizeB, pixmap);
 392                         WMReleasePixmap(pixmap);
 393                 } else {
 394                         wwarning(_("could not load icon %s"), path);
 395                 }
 396                 wfree(path);
 397         }
 398
 399         WMMapSubwidgets(panel->opaqF);
 400
 401
 402     /**************** Account for Icon/Dock ***************/
 403         panel->maxiF = WMCreateFrame(panel->box);
 404         WMResizeWidget(panel->maxiF, 205, 95);
 405         WMMoveWidget(panel->maxiF, 305, 125);
 406         WMSetFrameTitle(panel->maxiF, _("When maximizing..."));
 407
 408         panel->miconB = WMCreateSwitchButton(panel->maxiF);
 409         WMResizeWidget(panel->miconB, 190, 30);
 410         WMMoveWidget(panel->miconB, 10, 12);
 411         WMSetButtonText(panel->miconB, _("...do not cover icons"));
 412
 413         panel->mdockB = WMCreateSwitchButton(panel->maxiF);
 414         WMResizeWidget(panel->mdockB, 190, 30);
 415         WMMoveWidget(panel->mdockB, 10, 35);
 416
 417         WMSetButtonText(panel->mdockB, _("...do not cover dock"));
 418
 419         panel->resizeS = WMCreateSlider(panel->maxiF);
 420         WMResizeWidget(panel->resizeS, 50, 15);
 421         WMMoveWidget(panel->resizeS, 10, 70);
 422         WMSetSliderMinValue(panel->resizeS, 0);
 423         WMSetSliderMaxValue(panel->resizeS, 100);
 424         WMSetSliderAction(panel->resizeS, resizeCallback, panel);
 425
 426         panel->resizeL = WMCreateLabel(panel->maxiF);
 427         WMResizeWidget(panel->resizeL, 30, 15);
 428         WMMoveWidget(panel->resizeL, 60, 70);
 429
 430         panel->resizeTextL = WMCreateLabel(panel->maxiF);
 431         WMSetLabelText(panel->resizeTextL, "Mod+Wheel\nresize increment");
 432         WMResizeWidget(panel->resizeTextL, 110, 30);
 433         WMMoveWidget(panel->resizeTextL, 90, 62);
 434
 435         WMMapSubwidgets(panel->maxiF);
 436
 437     /**************** Edge Resistance  ****************/
 438
 439         panel->resF = WMCreateFrame(panel->box);
 440         WMResizeWidget(panel->resF, 285, 45);
 441         WMMoveWidget(panel->resF, 8, 125);
 442         WMSetFrameTitle(panel->resF, _("Edge Resistance"));
 443
 444         WMSetBalloonTextForView(_("Edge resistance will make windows `resist'\n"
 445                                   "being moved further for the defined threshold\n"
 446                                   "when moved against other windows or the edges\n"
 447                                   "of the screen."), WMWidgetView(panel->resF));
 448
 449         panel->resS = WMCreateSlider(panel->resF);
 450         WMResizeWidget(panel->resS, 80, 15);
 451         WMMoveWidget(panel->resS, 10, 20);
 452         WMSetSliderMinValue(panel->resS, 0);
 453         WMSetSliderMaxValue(panel->resS, 80);
 454         WMSetSliderAction(panel->resS, resistanceCallback, panel);
 455
 456         panel->resL = WMCreateLabel(panel->resF);
 457         WMResizeWidget(panel->resL, 30, 15);
 458         WMMoveWidget(panel->resL, 95, 20);
 459
 460         panel->resaB = WMCreateRadioButton(panel->resF);
 461         WMMoveWidget(panel->resaB, 130, 15);
 462         WMResizeWidget(panel->resaB, 70, 25);
 463         WMSetButtonText(panel->resaB, _("Resist"));
 464
 465         panel->resrB = WMCreateRadioButton(panel->resF);
 466         WMMoveWidget(panel->resrB, 200, 15);
 467         WMResizeWidget(panel->resrB, 70, 25);
 468         WMSetButtonText(panel->resrB, _("Attract"));
 469         WMGroupButtons(panel->resrB, panel->resaB);
 470
 471         WMMapSubwidgets(panel->resF);
 472
 473     /**************** Transients on Parent Workspace ****************/
 474
 475         panel->tranF = WMCreateFrame(panel->box);
 476         WMResizeWidget(panel->tranF, 285, 40);
 477         WMMoveWidget(panel->tranF, 8, 180);
 478
 479         panel->tranB = WMCreateSwitchButton(panel->tranF);
 480         WMMoveWidget(panel->tranB, 10, 5);
 481         WMResizeWidget(panel->tranB, 250, 30);
 482         WMSetButtonText(panel->tranB, _("Open dialogs in the same workspace\nas their owners"));
 483
 484         WMMapSubwidgets(panel->tranF);
 485
 486         WMRealizeWidget(panel->box);
 487         WMMapSubwidgets(panel->box);
 488
 489         /* show the config data */
 490         showData(panel);
 491 }
 492
 493 static void undo(_Panel * panel)
 494 {
 495         showData(panel);
 496 }
 497
 498 Panel *InitWindowHandling(WMScreen * scr, WMWidget * parent)
 499 {
 500         _Panel *panel;
 501
 502         panel = wmalloc(sizeof(_Panel));
 503         memset(panel, 0, sizeof(_Panel));
 504
 505         panel->sectionName = _("Window Handling Preferences");
 506
 507         panel->description = _("Window handling options. Initial placement style\n"
 508                                "edge resistance, opaque move etc.");
 509
 510         panel->parent = parent;
 511
 512         panel->callbacks.createWidgets = createPanel;
 513         panel->callbacks.updateDomain = storeData;
 514         panel->callbacks.undoChanges = undo;
 515
 516         AddSection(panel, ICON_FILE);
 517
 518         return panel;
 519 }