modules/FvwmTaskBar/Start.c

   1 /* -*-c-*- */
   2 /* This program is free software; you can redistribute it and/or modify
   3  * it under the terms of the GNU General Public License as published by
   4  * the Free Software Foundation; either version 2 of the License, or
   5  * (at your option) any later version.
   6  *
   7  * This program is distributed in the hope that it will be useful,
   8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  * GNU General Public License for more details.
  11  *
  12  * You should have received a copy of the GNU General Public License
  13  * along with this program; if not, write to the Free Software
  14  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  15  */
  16
  17 /* Start ;-) button handling */
  18
  19 #include "config.h"
  20
  21 #include <X11/Xlib.h>
  22 #include <stdio.h>
  23
  24 #include "libs/fvwmlib.h"
  25 #include "libs/Flocale.h"
  26 #include "libs/Picture.h"
  27 #include "libs/Module.h"
  28 #include "libs/Parse.h"
  29 #include "libs/Strings.h"
  30 #include "ButtonArray.h"
  31 #include "Mallocs.h"
  32 #include "Start.h"
  33
  34 extern Display *dpy;
  35 extern Window Root, win;
  36 extern FlocaleFont *FButtonFont, *FSelButtonFont;
  37 extern ModuleArgs *module;
  38 extern char *ImagePath;
  39
  40 Button *StartButton;
  41 Bool NoDefaultStartButton = False;
  42 int StartAndLaunchButtonsWidth = 0;
  43 int StartAndLaunchButtonsHeight = 0;
  44 int WindowButtonsLeftMargin = 4;    /* default value is 4 */
  45 int WindowButtonsRightMargin = 2;   /* default value is 2 */
  46 int StartButtonRightMargin = 0;     /* default value is 0 */
  47 int has_wb_left_margin = 0;
  48 int has_wb_right_margin = 0;
  49 Bool StartButtonOpensAboveTaskBar = False;
  50 char *StartName     = NULL,
  51      *StartCommand  = NULL,
  52      *StartPopup    = NULL,
  53      *StartIconName = NULL;
  54
  55 StartAndLaunchButtonItem *First_Start_Button = NULL;
  56 StartAndLaunchButtonItem *Last_Start_Button = NULL;
  57
  58 static char *startopts[] =
  59 {
  60   "StartName",
  61   "StartMenu",
  62   "StartIcon",
  63   "StartCommand",
  64   "NoDefaultStartButton",
  65   "Button",
  66   "WindowButtonsLeftMargin",
  67   "WindowButtonsRightMargin",
  68   "StartButtonRightMargin",
  69   NULL
  70 };
  71
  72 Bool StartButtonParseConfig(char *tline)
  73 {
  74         char *rest;
  75         char *option;
  76         int i, j, k;
  77         int titleRecorded = 0, iconRecorded = 0;
  78         char *tokens[100];  /* This seems really big */
  79         StartAndLaunchButtonItem *tempPtr;
  80         int mouseButton;
  81         char **tmpStrPtr;
  82
  83         option = tline + module->namelen+1;
  84         i = GetTokenIndex(option, startopts, -1, &rest);
  85         while (*rest && *rest != '\n' && isspace(*rest))
  86         {
  87                 rest++;
  88         }
  89         switch(i)
  90         {
  91         case 0: /* StartName */
  92                 if (First_Start_Button == NULL)
  93                 {
  94                         First_Start_Button = Last_Start_Button =
  95                                 (StartAndLaunchButtonItem*)safemalloc(
  96                                         sizeof(StartAndLaunchButtonItem));
  97                         StartAndLaunchButtonItemInit(First_Start_Button);
  98                         First_Start_Button->isStartButton = True;
  99                 }
 100                 else if (First_Start_Button->isStartButton == False)
 101                 {
 102                         /* shortcut button has been declared before start
 103                          * button */
 104                         tempPtr = (StartAndLaunchButtonItem*)safemalloc(
 105                                 sizeof(StartAndLaunchButtonItem));
 106                         StartAndLaunchButtonItemInit(tempPtr);
 107                         tempPtr->tail = First_Start_Button;
 108                         First_Start_Button = tempPtr;
 109                         First_Start_Button->isStartButton = True;
 110                 }
 111                 else if (First_Start_Button->buttonCaption != NULL)
 112                 {
 113                         /* declarin caption twice, ignore */
 114                         break;
 115                 }
 116                 CopyString(&(First_Start_Button->buttonCaption), rest);
 117                 break;
 118         case 1: /* StartMenu */
 119                 rest = ParseButtonOptions(rest, &mouseButton);
 120                 if (First_Start_Button == NULL)
 121                 {
 122                         First_Start_Button = Last_Start_Button =
 123                                 (StartAndLaunchButtonItem*)safemalloc(
 124                                         sizeof(StartAndLaunchButtonItem));
 125                         StartAndLaunchButtonItemInit(First_Start_Button);
 126                         First_Start_Button->isStartButton = True;
 127                 }
 128                 else if (First_Start_Button->isStartButton == False)
 129                 {
 130                         /* shortcut button has been declared before start
 131                          * button */
 132                         tempPtr = (StartAndLaunchButtonItem*) safemalloc(
 133                                 sizeof(StartAndLaunchButtonItem));
 134                         StartAndLaunchButtonItemInit(tempPtr);
 135                         tempPtr->tail = First_Start_Button;
 136                         First_Start_Button = tempPtr;
 137                         First_Start_Button->isStartButton = True;
 138                 }
 139                 tmpStrPtr = (mouseButton ?
 140                              &(First_Start_Button->buttonCommands[mouseButton-1])
 141                              :
 142                              &(First_Start_Button->buttonCommand));
 143                 if (*tmpStrPtr)
 144                 {
 145                         /* declaring command twice, ignore */
 146                         break;
 147                 }
 148                 CopyString(tmpStrPtr, rest);
 149                 break;
 150         case 2: /* StartIcon */
 151                 if (First_Start_Button == NULL)
 152                 {
 153                         First_Start_Button = Last_Start_Button =
 154                                 (StartAndLaunchButtonItem*)safemalloc(
 155                                         sizeof(StartAndLaunchButtonItem));
 156                         StartAndLaunchButtonItemInit(First_Start_Button);
 157                         First_Start_Button->isStartButton = True;
 158                 }
 159                 else if (First_Start_Button->isStartButton == False)
 160                 {
 161                         /* shortcut button has been declared before start
 162                          * button */
 163                         tempPtr = (StartAndLaunchButtonItem*) safemalloc(
 164                                 sizeof(StartAndLaunchButtonItem));
 165                         StartAndLaunchButtonItemInit(tempPtr);
 166                         tempPtr->tail = First_Start_Button;
 167                         First_Start_Button = tempPtr;
 168                         First_Start_Button->isStartButton = True;
 169                 }
 170                 else if (First_Start_Button->buttonIconFileName != NULL)
 171                 {
 172                         /* declaring icon twice, ignore */
 173                         break;
 174                 }
 175                 CopyString(&(First_Start_Button->buttonIconFileName), rest);
 176                 break;
 177         case 3: /* StartCommand */
 178                 rest = ParseButtonOptions(rest, &mouseButton);
 179                 if (First_Start_Button == NULL)
 180                 {
 181                         First_Start_Button = Last_Start_Button =
 182                                 (StartAndLaunchButtonItem*)safemalloc(
 183                                         sizeof(StartAndLaunchButtonItem));
 184                         StartAndLaunchButtonItemInit(First_Start_Button);
 185                         First_Start_Button->isStartButton = True;
 186                 }
 187                 else if (First_Start_Button->isStartButton == False)
 188                 {
 189                         /* shortcut button has been declared before start
 190                          * button */
 191                         tempPtr = (StartAndLaunchButtonItem*)safemalloc(
 192                                 sizeof(StartAndLaunchButtonItem));
 193                         StartAndLaunchButtonItemInit(tempPtr);
 194                         tempPtr->tail = First_Start_Button;
 195                         First_Start_Button = tempPtr;
 196                         First_Start_Button->isStartButton = True;
 197                 }
 198                 tmpStrPtr =
 199                         (mouseButton ?
 200                          &(First_Start_Button->buttonStartCommands[mouseButton-1]) :
 201                          &(First_Start_Button->buttonStartCommand));
 202                 if (*tmpStrPtr)
 203                 {
 204                         /* declaring command twice, ignore */
 205                         break;
 206                 }
 207                 CopyString(tmpStrPtr, rest);
 208                 break;
 209         case 4: /* NoDefaultStartButton */
 210                 NoDefaultStartButton = True;
 211                 break;
 212         case 5: /* Button */
 213                 if (Last_Start_Button == NULL)
 214                 {
 215                         First_Start_Button = Last_Start_Button =
 216                                 (StartAndLaunchButtonItem*)safemalloc(
 217                                         sizeof(StartAndLaunchButtonItem));
 218                 }
 219                 else
 220                 {
 221                         Last_Start_Button->tail =
 222                                 (StartAndLaunchButtonItem*) safemalloc(
 223                                         sizeof(StartAndLaunchButtonItem));
 224                         Last_Start_Button = Last_Start_Button->tail;
 225                 }
 226
 227                 StartAndLaunchButtonItemInit(Last_Start_Button);
 228                 j=0;
 229                 titleRecorded = iconRecorded = 0;
 230                 {
 231                         char *strtok_ptr = 0;
 232
 233                         tokens[j++] = strtok_r(rest, ",", &strtok_ptr);
 234                         while((tokens[j++] = strtok_r(NULL, ",", &strtok_ptr)))
 235                         {
 236                                 while(isspace(*(tokens[j-1])))
 237                                 {
 238                                         tokens[j-1]+=sizeof(char);
 239                                 }
 240                         }
 241                 }
 242                 j--;
 243
 244                 for(k=0;k<j;k++)
 245                 {
 246                         if (strncasecmp(tokens[k], "Title", 5)==0)
 247                         {
 248                                 tokens[j+1] = tokens[k] + ((sizeof(char))*5);
 249                                 while(*(tokens[j+1])==' ')
 250                                         tokens[j+1]+=sizeof(char);
 251                                 CopyString(
 252                                         &(Last_Start_Button->buttonCaption),
 253                                         tokens[j+1]);
 254                                 titleRecorded=1;
 255                         }
 256                         else if (strncasecmp(tokens[k], "Icon", 4)==0)
 257                         {
 258                                 tokens[j+1] = tokens[k] + ((sizeof(char))*4);
 259                                 while(*(tokens[j+1])==' ')
 260                                         tokens[j+1]+=sizeof(char);
 261                                 CopyString(
 262                                         &(Last_Start_Button->buttonIconFileName),
 263                                         tokens[j+1] );
 264                                 iconRecorded = 1;
 265                         }
 266                         else if (strncasecmp(tokens[k], "Action", 6)==0)
 267                         {
 268                                 rest = tokens[k] + ((sizeof(char))*6);
 269                                 rest = ParseButtonOptions(rest, &mouseButton);
 270                                 tokens[j+1] = rest;
 271                                 if (mouseButton)
 272                                 {
 273                                         tmpStrPtr =
 274                                                 &(Last_Start_Button->
 275                                                   buttonStartCommands
 276                                                   [mouseButton-1]);
 277                                 }
 278                                 else
 279                                 {
 280                                         tmpStrPtr =
 281                                                 &(Last_Start_Button->
 282                                                   buttonStartCommand);
 283                                 }
 284                                 if (!(*tmpStrPtr))
 285                                 {
 286                                         /* don't let them set the same action
 287                                          * twice */
 288                                         CopyString(tmpStrPtr, tokens[j+1]);
 289                                 }
 290                         }
 291                 }
 292                 if (titleRecorded==0)
 293                 {
 294                         CopyString(&(Last_Start_Button->buttonCaption), "\0");
 295                 }
 296                 if (iconRecorded==0)
 297                 {
 298                         CopyString(
 299                                 &(Last_Start_Button->buttonIconFileName),
 300                                 "\0");
 301                 }
 302                 break;
 303
 304         case 6: /* WindowButtonsLeftMargin */
 305                 if(atoi(rest)>=0)
 306                 {
 307                         WindowButtonsLeftMargin = atoi(rest);
 308                         has_wb_left_margin = 1;
 309                 }
 310                 break;
 311         case 7: /* WindowButtonsRightMargin */
 312                 if(atoi(rest)>=0)
 313                 {
 314                         WindowButtonsRightMargin = atoi(rest);
 315                         has_wb_right_margin = 1;
 316                 }
 317                 break;
 318         case 8: /* StartButtonRightMargin */
 319                 if(atoi(rest)>=0)
 320                 {
 321                         StartButtonRightMargin = atoi(rest);
 322                 }
 323                 break;
 324         default:
 325                 /* unknown option */
 326                 return False;
 327         } /* switch */
 328
 329         return True;
 330 }
 331
 332 /* Parse and set options for this taskbar button (start or launcher). This
 333  * will check for a string of the form (<opt1>,<opt2>...), similar to options
 334  * for an FvwmButtons button. The return value is a pointer to the rest of the
 335  * config line.
 336  *
 337  * Currently this sets just one option, mouseButton. If no "Mouse <n>" option
 338  * is found, mouseButton will be set to 0.
 339  */
 340 char *ParseButtonOptions(char *pos, int *mouseButton)
 341 {
 342   char *token = NULL;
 343   char *rest;
 344   int i;
 345   static char *buttonOptions[] = {"Mouse", NULL};
 346
 347   *mouseButton = 0;
 348   while (*pos && isspace(*pos))
 349     pos++;
 350   if (*pos != '(')
 351     return pos;
 352   pos++;
 353   while (*pos && isspace(*pos))
 354     pos++;
 355
 356   while (*pos && *pos != ')')
 357   {
 358     pos = GetNextToken(pos, &token);
 359     if (!token)
 360         break;
 361     i = GetTokenIndex(token, buttonOptions, 0, NULL);
 362     switch (i)
 363     {
 364     case 0:   /* Mouse */
 365       *mouseButton = strtol(pos, &rest, 10);
 366       pos = rest;
 367       if (*mouseButton < 1 || *mouseButton > NUMBER_OF_EXTENDED_MOUSE_BUTTONS)
 368       {
 369         fprintf(stderr,"%s: Invalid mouse button %d", module->name,
 370                 *mouseButton);
 371         *mouseButton = 0;
 372       }
 373       break;
 374
 375     default:
 376       fprintf(stderr,"%s: Invalid taskbar button option '%s'", module->name,
 377               token);
 378     }
 379     while (*pos && *pos != ',' && *pos != ')')
 380       pos++;
 381     if (*pos == ',') {
 382       pos++;
 383       while (*pos && *pos != ',' && *pos != ')')
 384         pos++;
 385     }
 386     free(token);
 387   }
 388
 389   if (*pos)
 390     pos++;
 391   while (*pos && isspace(*pos))
 392     pos++;
 393   return pos;
 394 }
 395
 396 void StartButtonInit(int height)
 397 {
 398   FvwmPicture *p = NULL;
 399   int pw;
 400   FvwmPictureAttributes fpa;
 401   StartAndLaunchButtonItem *tempPtr;
 402
 403   fpa.mask = FPAM_NO_ALLOC_PIXELS;
 404
 405   /* if no start button params were specified, trick the program into
 406    * thinking that they were */
 407   if (First_Start_Button == NULL && !NoDefaultStartButton)
 408   {
 409     StartButtonParseConfig("*FvwmTaskBarStartName Start");
 410     StartButtonParseConfig("*FvwmTaskBarStartMenu RootMenu");
 411     StartButtonParseConfig("*FvwmTaskBarStartIcon mini.start.xpm");
 412   }
 413   /* some defaults */
 414   if (First_Start_Button && First_Start_Button->isStartButton == True)
 415   {
 416     if (First_Start_Button->buttonCaption == NULL)
 417       UpdateString(&(First_Start_Button->buttonCaption), "Start");
 418     if (First_Start_Button->buttonIconFileName == NULL)
 419       UpdateString(&(First_Start_Button->buttonIconFileName), "mini-start.xpm");
 420   }
 421
 422   tempPtr = First_Start_Button;
 423
 424   while(tempPtr != NULL)
 425   {
 426           p = PGetFvwmPicture(
 427                   dpy, win, ImagePath, tempPtr->buttonIconFileName, fpa);
 428           if (p != NULL && strlen(tempPtr->buttonCaption) != 0)
 429           {
 430                   /* icon and title */
 431                   pw = p->width + 12;
 432           }
 433           else if (p != NULL)
 434           {
 435                   /* just icon */
 436                   pw = p->width + 8;
 437           }
 438           else
 439           {
 440                   /* just title */
 441                   pw = 10;
 442           }
 443
 444     tempPtr->buttonItem = (Button *)ButtonNew(
 445             tempPtr->buttonCaption, p, BUTTON_UP,0);
 446     if (tempPtr->isStartButton)
 447     {
 448             StartButton = tempPtr->buttonItem;
 449             tempPtr->width = FlocaleTextWidth(
 450                     FSelButtonFont, tempPtr->buttonCaption,
 451                     strlen(tempPtr->buttonCaption)) + pw;
 452     }
 453     else
 454     {
 455             tempPtr->width = FlocaleTextWidth(
 456                     FButtonFont, tempPtr->buttonCaption,
 457                     strlen(tempPtr->buttonCaption)) + pw;
 458     }
 459     tempPtr->height = height;
 460     StartAndLaunchButtonsWidth += tempPtr->width;
 461     tempPtr=tempPtr->tail;
 462     PFreeFvwmPictureData(p); /* should not destroy of course */
 463   }
 464   if (First_Start_Button)
 465   {
 466           StartAndLaunchButtonsWidth += StartButtonRightMargin;
 467           First_Start_Button->height = height;
 468           StartAndLaunchButtonsHeight = First_Start_Button->height;
 469   }
 470   else
 471   {
 472     StartAndLaunchButtonsWidth = 0;
 473     StartButtonRightMargin = 0;
 474     if (has_wb_left_margin == 0)
 475     {
 476       WindowButtonsLeftMargin = 0;
 477     }
 478     if (has_wb_right_margin == 0)
 479     {
 480       WindowButtonsRightMargin = 0;
 481     }
 482   }
 483 }
 484
 485 int StartButtonUpdate(const char *title, int index, int state)
 486 {
 487   int i=0;
 488   StartAndLaunchButtonItem *tempPtr = First_Start_Button;
 489 #if 0
 490   if (title != NULL)
 491     ConsoleMessage("Updating StartTitle not supported yet...\n");
 492   if(index != -1)
 493   {
 494     for(i=0; i<index; i++)
 495       tempPtr = tempPtr->tail;
 496     ButtonUpdate(tempPtr->buttonItem, title, state);
 497   }
 498   else
 499     while(tempPtr != NULL)
 500     {
 501       ButtonUpdate(tempPtr->buttonItem, title, state);
 502       tempPtr = tempPtr->tail;
 503     }
 504
 505 #else
 506
 507   if (!First_Start_Button)
 508   {
 509           return 0;
 510   }
 511
 512   if(index != -1)
 513   {
 514     for(i=0; i<index; i++)
 515       tempPtr = tempPtr->tail;
 516     ButtonUpdate(tempPtr->buttonItem, title, state);
 517   }
 518   else
 519     while(tempPtr != NULL)
 520     {
 521       ButtonUpdate(tempPtr->buttonItem, title, state);
 522       tempPtr = tempPtr->tail;
 523     }
 524
 525 #endif
 526   tempPtr = First_Start_Button;
 527   while(tempPtr != NULL)
 528   {
 529     if (tempPtr->buttonItem->needsupdate)
 530       return 1;
 531     tempPtr = tempPtr->tail;
 532   }
 533   return 0;
 534 }
 535
 536
 537 void StartButtonDraw(int force, XEvent *evp)
 538 {
 539         int tempsum, j, i = 0;
 540         StartAndLaunchButtonItem *tempPtr = First_Start_Button;
 541         StartAndLaunchButtonItem *tempPtr2 = First_Start_Button;
 542
 543         if (!First_Start_Button)
 544         {
 545                 return;
 546         }
 547
 548         while(tempPtr != NULL)
 549         {
 550                 if(tempPtr->buttonItem->needsupdate || force)
 551                 {
 552                         tempsum = 0;
 553                         j=0;
 554                         tempPtr2 = First_Start_Button;
 555                         while((tempPtr2 != NULL) && (j<i))
 556                         {
 557                                 tempsum+=tempPtr2->width;
 558                                 tempPtr2 = tempPtr2->tail;
 559                                 j++;
 560                         }
 561                         if (!(tempPtr->isStartButton))
 562                                 ButtonDraw(
 563                                         tempPtr->buttonItem,
 564                                         tempsum+StartButtonRightMargin, 0,
 565                                         tempPtr->width,
 566                                         First_Start_Button->height, evp);
 567                         else
 568                                 ButtonDraw(
 569                                         tempPtr->buttonItem,
 570                                         tempsum, 0, tempPtr->width,
 571                                         First_Start_Button->height, evp);
 572                 }
 573                 tempPtr = tempPtr->tail;
 574                 i++;
 575         }
 576 }
 577
 578 /* Returns 1 if in the start or a minibutton, 0 if not; index of button
 579  * pressed put in startButtonPressed */
 580 int MouseInStartButton(int x, int y, int *whichButton,
 581                        Bool *startButtonPressed, int *button_x)
 582 {
 583   int i = 0;
 584   int tempsum = 0;
 585
 586   StartAndLaunchButtonItem *tempPtr = First_Start_Button;
 587   *startButtonPressed = False;
 588
 589   while(tempPtr != NULL)
 590     {
 591       if (x >= tempsum && x < tempsum+tempPtr->width && y > 0 && y < First_Start_Button->height)
 592       {
 593         *whichButton = i;
 594         if (button_x)
 595         {
 596                 *button_x = tempsum;
 597         }
 598         if(tempPtr->isStartButton)
 599           *startButtonPressed = True;
 600         return 1;
 601       }
 602       tempsum += tempPtr->width;
 603       tempPtr = tempPtr->tail;
 604       i++;
 605     }
 606   *whichButton = -1;
 607   return 0;
 608 }
 609
 610 void getButtonCommand(int whichButton, char *tmp, int mouseButton)
 611 {
 612   int i=0;
 613   StartAndLaunchButtonItem *tempPtr = First_Start_Button;
 614
 615   if (!First_Start_Button)
 616   {
 617           return;
 618   }
 619
 620   for(i=0; i<whichButton; i++)
 621     tempPtr = tempPtr->tail;
 622   mouseButton--;
 623
 624   if (mouseButton < NUMBER_OF_EXTENDED_MOUSE_BUTTONS &&
 625       tempPtr->buttonCommands[mouseButton])
 626     sprintf(tmp, "Popup %s rectangle $widthx$height+$left+$top 0 -100m",
 627             tempPtr->buttonCommands[mouseButton]);
 628   else if (mouseButton < NUMBER_OF_EXTENDED_MOUSE_BUTTONS &&
 629            tempPtr->buttonStartCommands[mouseButton])
 630     sprintf(tmp, "%s", tempPtr->buttonStartCommands[mouseButton]);
 631   else if (tempPtr->buttonCommand)
 632     sprintf(tmp, "Popup %s rectangle $widthx$height+$left+$top 0 -100m",
 633             tempPtr->buttonCommand);
 634   else if (tempPtr->buttonStartCommand)
 635     sprintf(tmp, "%s", tempPtr->buttonStartCommand);
 636   else if (tempPtr->isStartButton)
 637     sprintf(tmp, "Popup StartMenu");
 638   else
 639     sprintf(tmp, "Nop");
 640 }
 641
 642 void StartAndLaunchButtonItemInit(StartAndLaunchButtonItem *item)
 643 {
 644   int i;
 645
 646   item->head = NULL;
 647   item->tail = NULL;
 648   item->index = 0;
 649   item->width = 0;
 650   item->height = 0;
 651   item->isStartButton = False;
 652   item->buttonItem = NULL;
 653   item->buttonCommand = NULL;
 654   item->buttonStartCommand = NULL;
 655   item->buttonCaption = NULL;
 656   item->buttonIconFileName = NULL;
 657   item->buttonToolTip = NULL;
 658   for (i=0; i < NUMBER_OF_EXTENDED_MOUSE_BUTTONS; i++)
 659   {
 660     item->buttonCommands[i] = NULL;
 661     item->buttonStartCommands[i] = NULL;
 662   }
 663 }