WPrefs.app/MouseSettings.c

   1
   2 /* MouseSettings.c- mouse options (some are equivalent to xset)
   3  *
   4  *  WPrefs - Window Maker Preferences Program
   5  *
   6  *  Copyright (c) 1998 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
  19  *  along with this program; if not, write to the Free Software
  20  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  21  *  USA.
  22  */
  23
  24
  25 #include "WPrefs.h"
  26
  27 #include <X11/Xutil.h>
  28
  29 #include <math.h>
  30
  31 /* double-click tester */
  32 #include "double.h"
  33
  34
  35
  36 #define XSET    "xset"
  37
  38
  39
  40 typedef struct _Panel {
  41     WMFrame *frame;
  42
  43     char *sectionName;
  44
  45     char *description;
  46
  47     CallbackRec callbacks;
  48
  49     WMWindow *win;
  50
  51     WMFrame *speedF;
  52     WMLabel *speedL;
  53     WMSlider *speedS;
  54     WMLabel *acceL;
  55     WMTextField *acceT;
  56     WMLabel *threL;
  57     WMTextField *threT;
  58
  59     WMFrame *ddelaF;
  60     WMButton *ddelaB[5];
  61     WMTextField *ddelaT;
  62     WMLabel *ddelaL;
  63     DoubleTest *tester;
  64
  65     WMFrame *menuF;
  66     WMLabel *listL;
  67     WMLabel *appL;
  68     WMLabel *selL;
  69     WMPopUpButton *listP;
  70     WMPopUpButton *appP;
  71     WMPopUpButton *selP;
  72
  73     WMButton *disaB;
  74
  75     WMFrame *grabF;
  76     WMPopUpButton *grabP;
  77
  78     /**/
  79     int maxThreshold;
  80     float acceleration;
  81 } _Panel;
  82
  83
  84 #define ICON_FILE "mousesettings"
  85
  86 #define SPEED_ICON_FILE "mousespeed"
  87
  88 #define DELAY_ICON "timer%i"
  89 #define DELAY_ICON_S "timer%is"
  90
  91
  92 /* need access to the double click variables */
  93 #include <WINGs/WINGsP.h>
  94
  95
  96
  97 static char *modifierNames[] = {
  98     "Shift",
  99         "Lock",
 100         "Control",
 101         "Mod1",
 102         "Mod2",
 103         "Mod3",
 104         "Mod4",
 105         "Mod5"
 106 };
 107
 108
 109 static char *buttonNames[] = {
 110     "None",
 111         "Btn1 (left)",
 112         "Btn2 (middle)",
 113         "Btn3 (right)",
 114         "Btn4",
 115         "Btn5"
 116 };
 117
 118
 119 #define DELAY(i)                ((i)*75+170)
 120
 121
 122 int ModifierFromKey(Display *dpy, char *key);
 123
 124
 125 static void
 126 setMouseAccel(WMScreen *scr, float accel, int threshold)
 127 {
 128     int n, d;
 129
 130     d = 10;
 131     n = accel*d;
 132
 133     XChangePointerControl(WMScreenDisplay(scr), True, True, n, d, threshold);
 134 }
 135
 136
 137 static void
 138 speedChange(WMWidget *w, void *data)
 139 {
 140     _Panel *panel = (_Panel*)data;
 141     int i;
 142     char buffer[64];
 143     int threshold;
 144     char *tmp;
 145
 146     if (w == NULL) {
 147         float accel;
 148
 149         tmp = WMGetTextFieldText(panel->acceT);
 150         if (sscanf(tmp, "%f", &accel)!=1 || accel < 0) {
 151             WMRunAlertPanel(WMWidgetScreen(panel->acceT), GetWindow(panel),
 152                             _("Error"),
 153                             _("Invalid mouse acceleration value. Must be a positive real value."),
 154                             _("OK"), NULL, NULL);
 155             wfree(tmp);
 156             return;
 157         }
 158         panel->acceleration = accel;
 159         wfree(tmp);
 160     } else {
 161         i = (int)WMGetSliderValue(panel->speedS);
 162
 163         panel->acceleration = 0.25+(i*0.25);
 164
 165         sprintf(buffer, "%.2f", 0.25+(i*0.25));
 166         WMSetTextFieldText(panel->acceT, buffer);
 167     }
 168
 169     tmp = WMGetTextFieldText(panel->threT);
 170     if (sscanf(tmp, "%i", &threshold)!=1 || threshold < 0
 171         || threshold > panel->maxThreshold) {
 172         WMRunAlertPanel(WMWidgetScreen(panel->win), GetWindow(panel), _("Error"),
 173                         _("Invalid mouse acceleration threshold value. Must be the number of pixels to travel before accelerating."),
 174                         _("OK"), NULL, NULL);
 175     } else {
 176         setMouseAccel(WMWidgetScreen(panel->win), panel->acceleration,
 177                       threshold);
 178     }
 179     wfree(tmp);
 180 }
 181
 182
 183 static void
 184 returnPressed(void *observerData, WMNotification *notification)
 185 {
 186     _Panel *panel = (_Panel*)observerData;
 187
 188     speedChange(NULL, panel);
 189 }
 190
 191
 192 static void
 193 doubleClick(WMWidget *w, void *data)
 194 {
 195     _Panel *panel = (_Panel*)data;
 196     int i;
 197     extern _WINGsConfiguration WINGsConfiguration;
 198     char buffer[32];
 199
 200     for (i=0; i<5; i++) {
 201         if (panel->ddelaB[i]==w)
 202             break;
 203     }
 204     WINGsConfiguration.doubleClickDelay = DELAY(i);
 205
 206     sprintf(buffer, "%i", DELAY(i));
 207     WMSetTextFieldText(panel->ddelaT, buffer);
 208 }
 209
 210
 211
 212 int
 213 getbutton(char *str)
 214 {
 215     if (!str)
 216         return -2;
 217
 218     if (strcasecmp(str, "none")==0)
 219         return 0;
 220     else if (strcasecmp(str, "left")==0)
 221         return 1;
 222     else if (strcasecmp(str, "middle")==0)
 223         return 2;
 224     else if (strcasecmp(str, "right")==0)
 225         return 3;
 226     else if (strcasecmp(str, "button1")==0)
 227         return 1;
 228     else if (strcasecmp(str, "button2")==0)
 229         return 2;
 230     else if (strcasecmp(str, "button3")==0)
 231         return 3;
 232     else if (strcasecmp(str, "button4")==0)
 233         return 4;
 234     else if (strcasecmp(str, "button5")==0) {
 235         return 5;
 236     } else {
 237         return -1;
 238     }
 239 }
 240
 241
 242 static void
 243 getMouseParameters(Display *dpy, float *accel, int *thre)
 244 {
 245     int n, d;
 246
 247     XGetPointerControl(dpy, &n, &d, thre);
 248
 249     *accel = (float)n/(float)d;
 250 }
 251
 252
 253
 254 static void
 255 showData(_Panel *panel)
 256 {
 257     char *str;
 258     int i;
 259     int a=-1, b=-1, c=-1;
 260     float accel;
 261     char buffer[32];
 262     Display *dpy = WMScreenDisplay(WMWidgetScreen(panel->win));
 263
 264     str = GetStringForKey("SelectWindowsMouseButton");
 265     if (str) {
 266         i = getbutton(str);
 267         if (i==-1) {
 268             a = 1;
 269             wwarning(_("bad value %s for option %s"),str, "SelectWindowsMouseButton");
 270         } else if (i>=0) {
 271             a = i;
 272         }
 273     } else {
 274         a = 0;
 275     }
 276     WMSetPopUpButtonSelectedItem(panel->selP, a);
 277
 278     str = GetStringForKey("WindowListMouseButton");
 279     if (str) {
 280         i = getbutton(str);
 281         if (i==-1) {
 282             b = 2;
 283             wwarning(_("bad value %s for option %s"), str, "WindowListMouseButton");
 284         } else if (i>=0) {
 285             b = i;
 286         }
 287     } else {
 288         b = 0;
 289     }
 290     WMSetPopUpButtonSelectedItem(panel->listP, b);
 291
 292     str = GetStringForKey("ApplicationMenuMouseButton");
 293     if (str) {
 294         i = getbutton(str);
 295         if (i==-1) {
 296             c = 3;
 297             wwarning(_("bad value %s for option %s"), str, "ApplicationMenuMouseButton");
 298         } else if (i>=0) {
 299             c = i;
 300         }
 301     } else {
 302         c = 0;
 303     }
 304     WMSetPopUpButtonSelectedItem(panel->appP, c);
 305
 306     WMSetButtonSelected(panel->disaB, GetBoolForKey("DisableWSMouseActions"));
 307
 308     /**/
 309     getMouseParameters(dpy, &accel, &a);
 310     panel->maxThreshold = WidthOfScreen(DefaultScreenOfDisplay(dpy));
 311     if (a > panel->maxThreshold) {
 312         panel->maxThreshold = a;
 313     }
 314     sprintf(buffer, "%i", a);
 315     WMSetTextFieldText(panel->threT, buffer);
 316
 317     WMSetSliderValue(panel->speedS, (accel - 0.25)/0.25);
 318
 319     panel->acceleration = accel;
 320     sprintf(buffer, "%.2f", accel);
 321     WMSetTextFieldText(panel->acceT, buffer);
 322
 323     /**/
 324     b = GetIntegerForKey("DoubleClickTime");
 325     /* find best match */
 326     a = -1;
 327     for (i=0; i<5; i++) {
 328         if (DELAY(i) == b)
 329             a = i;
 330     }
 331     if (a >= 0)
 332         WMPerformButtonClick(panel->ddelaB[a]);
 333     sprintf(buffer, "%i", b);
 334     WMSetTextFieldText(panel->ddelaT, buffer);
 335
 336     /**/
 337     str = GetStringForKey("ModifierKey");
 338     if (!str)
 339         str = "mod1";
 340     a = ModifierFromKey(dpy, str);
 341
 342     if (a != -1) {
 343         str = modifierNames[a];
 344
 345         a = 0;
 346         for (i=0; i<WMGetPopUpButtonNumberOfItems(panel->grabP); i++) {
 347             if (strstr(WMGetPopUpButtonItem(panel->grabP, i), str)) {
 348                 WMSetPopUpButtonSelectedItem(panel->grabP, i);
 349                 a = 1;
 350                 break;
 351             }
 352         }
 353     }
 354
 355     if (a < 1) {
 356         sscanf(WMGetPopUpButtonItem(panel->grabP, 0), "%s", buffer);
 357         WMSetPopUpButtonSelectedItem(panel->grabP, 0);
 358         wwarning(_("modifier key %s for option ModifierKey was not recognized. Using %s as default"),
 359                  str, buffer);
 360     }
 361 }
 362
 363
 364
 365 static void
 366 fillModifierPopUp(WMPopUpButton *pop)
 367 {
 368     XModifierKeymap *mapping;
 369     Display *dpy = WMScreenDisplay(WMWidgetScreen(pop));
 370     int i, j;
 371     char *str;
 372     char buffer[64];
 373
 374
 375     mapping = XGetModifierMapping(dpy);
 376
 377     if (!mapping || mapping->max_keypermod==0) {
 378         WMAddPopUpButtonItem(pop, "Mod1");
 379         WMAddPopUpButtonItem(pop, "Mod2");
 380         WMAddPopUpButtonItem(pop, "Mod3");
 381         WMAddPopUpButtonItem(pop, "Mod4");
 382         WMAddPopUpButtonItem(pop, "Mod5");
 383         wwarning(_("could not retrieve keyboard modifier mapping"));
 384         return;
 385     }
 386
 387
 388     for (j=0; j<8; j++) {
 389         int idx;
 390         char *array[8];
 391         int a;
 392         KeySym ksym;
 393         int k;
 394         char *ptr;
 395         char *tmp;
 396
 397         a = 0;
 398         memset(array, 0, sizeof(char*)*8);
 399         for (i=0; i < mapping->max_keypermod; i++) {
 400             idx = i+j*mapping->max_keypermod;
 401             if (mapping->modifiermap[idx]!=0) {
 402                 int l;
 403                 for (l=0; l<4; l++) {
 404                     ksym = XKeycodeToKeysym(dpy, mapping->modifiermap[idx], l);
 405                     if (ksym!=NoSymbol)
 406                         break;
 407                 }
 408                 if (ksym!=NoSymbol)
 409                     str = XKeysymToString(ksym);
 410                 else
 411                     str = NULL;
 412                 if (str && !strstr(str, "_Lock") && !strstr(str, "Shift")
 413                     && !strstr(str, "Control")) {
 414                     array[a++] = wstrdup(str);
 415                 }
 416             }
 417         }
 418
 419         for (k=0; k<a; k++) {
 420             if (array[k]==NULL)
 421                 continue;
 422             tmp = wstrdup(array[k]);
 423             ptr = strstr(tmp, "_L");
 424             if (ptr)
 425                 *ptr = 0;
 426             ptr = strstr(tmp, "_R");
 427             if (ptr)
 428                 *ptr = 0;
 429             sprintf(buffer, "%s (%s)", modifierNames[j], tmp);
 430             /*sprintf(buffer, "%s", tmp);*/
 431             WMAddPopUpButtonItem(pop, buffer);
 432             for (i=k+1; i<a; i++) {
 433                 if (array[i] == NULL)
 434                     continue;
 435                 if (strstr(array[i], tmp)) {
 436                     wfree(array[i]);
 437                     array[i]=NULL;
 438                     break;
 439                 }
 440             }
 441             wfree(tmp);
 442         }
 443
 444         while (--a>0) {
 445             if (array[a])
 446                 wfree(array[a]);
 447         }
 448     }
 449
 450     if (mapping)
 451         XFreeModifiermap(mapping);
 452 }
 453
 454
 455
 456 static void
 457 createPanel(Panel *p)
 458 {
 459     _Panel *panel = (_Panel*)p;
 460     WMScreen *scr = WMWidgetScreen(panel->win);
 461     WMPixmap *icon;
 462     char *buf1, *buf2;
 463     int i;
 464     RColor color;
 465     char *path;
 466
 467     color.red = 0xaa;
 468     color.green = 0xae;
 469     color.blue = 0xaa;
 470
 471     panel->frame = WMCreateFrame(panel->win);
 472     WMResizeWidget(panel->frame, FRAME_WIDTH, FRAME_HEIGHT);
 473     WMMoveWidget(panel->frame, FRAME_LEFT, FRAME_TOP);
 474
 475     /**************** Mouse Speed ****************/
 476     panel->speedF = WMCreateFrame(panel->frame);
 477     WMResizeWidget(panel->speedF, 245, 100);
 478     WMMoveWidget(panel->speedF, 15, 15);
 479     WMSetFrameTitle(panel->speedF, _("Mouse Speed"));
 480
 481     panel->speedL = WMCreateLabel(panel->speedF);
 482     WMResizeWidget(panel->speedL, 40, 46);
 483     WMMoveWidget(panel->speedL, 15, 14);
 484     WMSetLabelImagePosition(panel->speedL, WIPImageOnly);
 485     path = LocateImage(SPEED_ICON_FILE);
 486     if (path) {
 487         icon = WMCreateBlendedPixmapFromFile(scr, path, &color);
 488         if (icon) {
 489             WMSetLabelImage(panel->speedL, icon);
 490             WMReleasePixmap(icon);
 491         } else {
 492             wwarning(_("could not load icon %s"), path);
 493         }
 494         wfree(path);
 495     }
 496
 497     panel->speedS = WMCreateSlider(panel->speedF);
 498     WMResizeWidget(panel->speedS, 160, 15);
 499     WMMoveWidget(panel->speedS, 70, 35);
 500     WMSetSliderMinValue(panel->speedS, 0);
 501     WMSetSliderMaxValue(panel->speedS, 40);
 502     WMSetSliderContinuous(panel->speedS, False);
 503     WMSetSliderAction(panel->speedS, speedChange, panel);
 504
 505     panel->acceL = WMCreateLabel(panel->speedF);
 506     WMResizeWidget(panel->acceL, 70, 16);
 507     WMMoveWidget(panel->acceL, 10, 67);
 508     WMSetLabelTextAlignment(panel->acceL, WARight);
 509     WMSetLabelText(panel->acceL, _("Acceler.:"));
 510
 511     panel->acceT = WMCreateTextField(panel->speedF);
 512     WMResizeWidget(panel->acceT, 40, 20);
 513     WMMoveWidget(panel->acceT, 80, 65);
 514     WMAddNotificationObserver(returnPressed, panel,
 515                               WMTextDidEndEditingNotification, panel->acceT);
 516
 517
 518     panel->threL = WMCreateLabel(panel->speedF);
 519     WMResizeWidget(panel->threL, 80, 16);
 520     WMMoveWidget(panel->threL, 120, 67);
 521     WMSetLabelTextAlignment(panel->threL, WARight);
 522     WMSetLabelText(panel->threL, _("Threshold:"));
 523
 524     panel->threT = WMCreateTextField(panel->speedF);
 525     WMResizeWidget(panel->threT, 30, 20);
 526     WMMoveWidget(panel->threT, 200, 65);
 527     WMAddNotificationObserver(returnPressed, panel,
 528                               WMTextDidEndEditingNotification, panel->threT);
 529
 530     WMMapSubwidgets(panel->speedF);
 531
 532     /***************** Doubleclick Delay ****************/
 533
 534     panel->ddelaF = WMCreateFrame(panel->frame);
 535     WMResizeWidget(panel->ddelaF, 245, 95);
 536     WMMoveWidget(panel->ddelaF, 15, 125);
 537     WMSetFrameTitle(panel->ddelaF, _("Double-Click Delay"));
 538
 539     buf1 = wmalloc(strlen(DELAY_ICON)+2);
 540     buf2 = wmalloc(strlen(DELAY_ICON_S)+2);
 541
 542     for (i = 0; i < 5; i++) {
 543         panel->ddelaB[i] = WMCreateCustomButton(panel->ddelaF,
 544                                                 WBBStateChangeMask);
 545         WMResizeWidget(panel->ddelaB[i], 25, 25);
 546         WMMoveWidget(panel->ddelaB[i], 30+(40*i), 20);
 547         WMSetButtonBordered(panel->ddelaB[i], False);
 548         WMSetButtonImagePosition(panel->ddelaB[i], WIPImageOnly);
 549         WMSetButtonAction(panel->ddelaB[i], doubleClick, panel);
 550         if (i>0) {
 551             WMGroupButtons(panel->ddelaB[0], panel->ddelaB[i]);
 552         }
 553         sprintf(buf1, DELAY_ICON, i+1);
 554         sprintf(buf2, DELAY_ICON_S, i+1);
 555         path = LocateImage(buf1);
 556         if (path) {
 557             icon = WMCreatePixmapFromFile(scr, path);
 558             if (icon) {
 559                 WMSetButtonImage(panel->ddelaB[i], icon);
 560                 WMReleasePixmap(icon);
 561             } else {
 562                 wwarning(_("could not load icon file %s"), path);
 563             }
 564             wfree(path);
 565         }
 566         path = LocateImage(buf2);
 567         if (path) {
 568             icon = WMCreatePixmapFromFile(scr, path);
 569             if (icon) {
 570                 WMSetButtonAltImage(panel->ddelaB[i], icon);
 571                 WMReleasePixmap(icon);
 572             } else {
 573                 wwarning(_("could not load icon file %s"), path);
 574             }
 575             wfree(path);
 576         }
 577     }
 578     wfree(buf1);
 579     wfree(buf2);
 580
 581     panel->tester = CreateDoubleTest(panel->ddelaF, _("Test"));
 582     WMResizeWidget(panel->tester, 84, 29);
 583     WMMoveWidget(panel->tester, 35, 55);
 584
 585     panel->ddelaT = WMCreateTextField(panel->ddelaF);
 586     WMResizeWidget(panel->ddelaT, 40, 20);
 587     WMMoveWidget(panel->ddelaT, 140, 60);
 588
 589     panel->ddelaL = WMCreateLabel(panel->ddelaF);
 590     WMResizeWidget(panel->ddelaL, 40, 16);
 591     WMMoveWidget(panel->ddelaL, 185, 65);
 592     {
 593         WMFont *font;
 594         WMColor *color;
 595
 596         font = WMSystemFontOfSize(scr, 10);
 597         color = WMDarkGrayColor(scr);
 598         WMSetLabelTextColor(panel->ddelaL, color);
 599         WMSetLabelFont(panel->ddelaL, font);
 600         WMReleaseFont(font);
 601         WMReleaseColor(color);
 602     }
 603     WMSetLabelText(panel->ddelaL, "msec");
 604
 605     WMMapSubwidgets(panel->ddelaF);
 606
 607     /* ************** Workspace Action Buttons **************** */
 608     panel->menuF = WMCreateFrame(panel->frame);
 609     WMResizeWidget(panel->menuF, 240, 145);
 610     WMMoveWidget(panel->menuF, 270, 15);
 611     WMSetFrameTitle(panel->menuF, _("Workspace Mouse Actions"));
 612
 613     panel->disaB = WMCreateSwitchButton(panel->menuF);
 614     WMResizeWidget(panel->disaB, 205, 18);
 615     WMMoveWidget(panel->disaB, 10, 20);
 616     WMSetButtonText(panel->disaB, _("Disable mouse actions"));
 617
 618
 619     panel->appL = WMCreateLabel(panel->menuF);
 620     WMResizeWidget(panel->appL, 125, 16);
 621     WMMoveWidget(panel->appL, 5, 45);
 622     WMSetLabelTextAlignment(panel->appL, WARight);
 623     WMSetLabelText(panel->appL, _("Applications menu"));
 624
 625     panel->appP = WMCreatePopUpButton(panel->menuF);
 626     WMResizeWidget(panel->appP, 95, 20);
 627     WMMoveWidget(panel->appP, 135, 45);
 628
 629     panel->listL = WMCreateLabel(panel->menuF);
 630     WMResizeWidget(panel->listL, 125, 16);
 631     WMMoveWidget(panel->listL, 5, 80);
 632     WMSetLabelTextAlignment(panel->listL, WARight);
 633     WMSetLabelText(panel->listL, _("Window list menu"));
 634
 635     panel->listP = WMCreatePopUpButton(panel->menuF);
 636     WMResizeWidget(panel->listP, 95, 20);
 637     WMMoveWidget(panel->listP, 135, 80);
 638
 639
 640     panel->selL = WMCreateLabel(panel->menuF);
 641     WMResizeWidget(panel->selL, 125, 16);
 642     WMMoveWidget(panel->selL, 5, 115);
 643     WMSetLabelTextAlignment(panel->selL, WARight);
 644     WMSetLabelText(panel->selL, _("Select windows"));
 645
 646     panel->selP = WMCreatePopUpButton(panel->menuF);
 647     WMResizeWidget(panel->selP, 95, 20);
 648     WMMoveWidget(panel->selP, 135, 115);
 649
 650     for (i = 0; i < sizeof(buttonNames)/sizeof(char*); i++) {
 651         WMAddPopUpButtonItem(panel->appP, buttonNames[i]);
 652         WMAddPopUpButtonItem(panel->selP, buttonNames[i]);
 653         WMAddPopUpButtonItem(panel->listP, buttonNames[i]);
 654     }
 655
 656     WMMapSubwidgets(panel->menuF);
 657
 658     /* ************** Grab Modifier **************** */
 659     panel->grabF = WMCreateFrame(panel->frame);
 660     WMResizeWidget(panel->grabF, 240, 55);
 661     WMMoveWidget(panel->grabF, 270, 165);
 662     WMSetFrameTitle(panel->grabF, _("Mouse Grab Modifier"));
 663
 664     WMSetBalloonTextForView(_("Keyboard modifier to use for actions that\n"
 665                               "involve dragging windows with the mouse,\n"
 666                               "clicking inside the window."),
 667                             WMWidgetView(panel->grabF));
 668
 669     panel->grabP = WMCreatePopUpButton(panel->grabF);
 670     WMResizeWidget(panel->grabP, 160, 20);
 671     WMMoveWidget(panel->grabP, 40, 25);
 672
 673     fillModifierPopUp(panel->grabP);
 674
 675     WMMapSubwidgets(panel->grabF);
 676
 677     WMRealizeWidget(panel->frame);
 678     WMMapSubwidgets(panel->frame);
 679
 680
 681     showData(panel);
 682 }
 683
 684
 685 static void
 686 storeCommandInScript(char *cmd, char *line)
 687 {
 688     char *path;
 689     FILE *f;
 690     char buffer[128];
 691
 692     path = wstrconcat(wusergnusteppath(), "/Library/WindowMaker/autostart");
 693
 694     f = fopen(path, "r");
 695     if (!f) {
 696         f = fopen(path, "w");
 697         if (!f) {
 698             wsyserror(_("could not create %s"), path);
 699             goto end;
 700         }
 701         fprintf(f, "#!/bin/sh\n");
 702         fputs(line, f);
 703         fputs("\n", f);
 704     } else {
 705         int len = strlen(cmd);
 706         int ok = 0;
 707         char *tmppath;
 708         FILE *fo;
 709
 710         tmppath = wstrconcat(wusergnusteppath(),
 711                              "/Library/WindowMaker/autostart.tmp");
 712         fo = fopen(tmppath, "w");
 713         if (!fo) {
 714             wsyserror(_("could not create temporary file %s"), tmppath);
 715             wfree(tmppath);
 716             goto end;
 717         }
 718
 719         while (!feof(f)) {
 720             if (!fgets(buffer, 127, f)) {
 721                 break;
 722             }
 723             if (buffer[0] == '\n') {
 724                 /* don't write empty lines, else the file will grow
 725                  * indefinitely (one '\n' added at end of file on each save).
 726                  */
 727                 continue;
 728             }
 729             if (strncmp(buffer, cmd, len)==0) {
 730                 if (!ok) {
 731                     fputs(line, fo);
 732                     fputs("\n", fo);
 733                     ok = 1;
 734                 }
 735             } else {
 736                 fputs(buffer, fo);
 737             }
 738         }
 739         if (!ok) {
 740             fputs(line, fo);
 741             fputs("\n", fo);
 742         }
 743         fclose(fo);
 744
 745         if (rename(tmppath, path)!=0) {
 746             wsyserror(_("could not rename file %s to %s\n"), tmppath, path);
 747         }
 748         wfree(tmppath);
 749     }
 750     sprintf(buffer, "chmod u+x %s", path);
 751     system(buffer);
 752
 753 end:
 754     wfree(path);
 755     if (f)
 756         fclose(f);
 757 }
 758
 759
 760 static void
 761 storeData(_Panel *panel)
 762 {
 763     char buffer[64];
 764     int i;
 765     char *tmp, *p;
 766     static char *button[6] = {"None", "left", "middle", "right", "Button4", "Button5"};
 767     WMUserDefaults *udb = WMGetStandardUserDefaults();
 768
 769     if (!WMGetUDBoolForKey(udb, "NoXSetStuff")) {
 770         tmp = WMGetTextFieldText(panel->threT);
 771         if (strlen(tmp)==0) {
 772             wfree(tmp);
 773             tmp = wstrdup("4");
 774         }
 775
 776         sprintf(buffer, XSET" m %i/%i %s\n", (int)(panel->acceleration*10),
 777                 10, tmp);
 778         storeCommandInScript(XSET" m", buffer);
 779
 780         wfree(tmp);
 781     }
 782
 783     tmp = WMGetTextFieldText(panel->ddelaT);
 784     if (sscanf(tmp, "%i", &i) == 1 && i > 0)
 785         SetIntegerForKey(i, "DoubleClickTime");
 786
 787     SetBoolForKey(WMGetButtonSelected(panel->disaB), "DisableWSMouseActions");
 788
 789     i = WMGetPopUpButtonSelectedItem(panel->appP);
 790     SetStringForKey(button[i], "ApplicationMenuMouseButton");
 791
 792     i = WMGetPopUpButtonSelectedItem(panel->listP);
 793     SetStringForKey(button[i], "WindowListMouseButton");
 794
 795     i = WMGetPopUpButtonSelectedItem(panel->selP);
 796     SetStringForKey(button[i], "SelectWindowsMouseButton");
 797
 798     tmp = WMGetPopUpButtonItem(panel->grabP,
 799                                WMGetPopUpButtonSelectedItem(panel->grabP));
 800     tmp = wstrdup(tmp);
 801     p = strchr(tmp, ' ');
 802     *p = 0;
 803
 804     SetStringForKey(tmp, "ModifierKey");
 805
 806     wfree(tmp);
 807 }
 808
 809
 810 Panel*
 811 InitMouseSettings(WMScreen *scr, WMWindow *win)
 812 {
 813     _Panel *panel;
 814
 815     panel = wmalloc(sizeof(_Panel));
 816     memset(panel, 0, sizeof(_Panel));
 817
 818     panel->sectionName = _("Mouse Preferences");
 819
 820     panel->description = _("Mouse speed/acceleration, double click delay,\n"
 821                            "mouse button bindings etc.");
 822
 823     panel->win = win;
 824
 825     panel->callbacks.createWidgets = createPanel;
 826     panel->callbacks.updateDomain = storeData;
 827
 828     AddSection(panel, ICON_FILE);
 829
 830     return panel;
 831 }