src/menureader.c

   1 /* menureader.c- root menu definition readers
   2  *
   3  *  Window Maker window manager
   4  *
   5  *  Copyright (c) 2000 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
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  20  *  USA.
  21  */
  22
  23
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <sys/types.h>
  28 #include <unistd.h>
  29
  30 #include "WindowMaker.h"
  31
  32 #include "misc.h"
  33
  34 #include "rootmenu.h"
  35
  36
  37 typedef struct PLMenuReaderData {
  38     WRootMenuReader *reader;
  39
  40     proplist_t pl;
  41     int curIndex;
  42
  43     proplist_t *submenu;
  44     int *curSubIndex;
  45     int submenuDepth;
  46
  47 } PLMenuReaderData;
  48
  49
  50 typedef struct TextMenuReaderData {
  51     WRootMenuReader *reader;
  52
  53     FILE *file;
  54
  55 } TextMenuReaderData;
  56
  57
  58 typedef struct PipeMenuReaderData {
  59     WRootMenuReader *reader;
  60
  61 } PipeMenuReaderData;
  62
  63
  64 typedef struct DirMenuReaderData {
  65     WRootMenuReader *reader;
  66
  67     char **dirList;
  68     int dirCount;
  69
  70 } DirMenuReaderData;
  71
  72 /*
  73 typedef struct GNOMEMenuReaderData {
  74 } GNOMEMenuReaderData;
  75 */
  76
  77
  78
  79
  80
  81 static WRootMenuData *pl_openMenu(proplist_t pl);
  82 static Bool pl_hasMoreData(WRootMenuData *data);
  83 static Bool pl_nextCommand(WRootMenuData *data,
  84                         char **title,
  85                         char **command,
  86                         char **parameter,
  87                         char **shortcut);
  88 static void pl_closeMenuFile(WRootMenuData *data);
  89
  90
  91
  92 static WRootMenuData *text_openMenuFile(char *path);
  93 static Bool text_hasMoreData(WRootMenuData *data);
  94 static Bool text_nextCommand(WRootMenuData *data,
  95                         char **title,
  96                         char **command,
  97                         char **parameter,
  98                         char **shortcut);
  99 static void text_closeMenuFile(WRootMenuData *data);
 100
 101
 102 static WRootMenuData *dir_openMenuFile(char *path);
 103 static Bool dir_hasMoreData(WRootMenuData *data);
 104 static Bool dir_nextCommand(WRootMenuData *data,
 105                         char **title,
 106                         char **command,
 107                         char **parameter,
 108                         char **shortcut);
 109 static void dir_closeMenuFile(WRootMenuData *data);
 110
 111
 112
 113
 114
 115
 116 static WRootMenuReader PLMenuReader = {
 117         pl_hasMoreData,
 118         pl_nextCommand,
 119         pl_closeMenuFile
 120 };
 121
 122 static WRootMenuReader TextMenuReader = {
 123         text_hasMoreData,
 124         text_nextCommand,
 125         text_closeMenuFile
 126 };
 127
 128 static WRootMenuReader DirMenuReaderData = {
 129         dir_hasMoreData,
 130         dir_nextCommand,
 131         dir_closeMenuFile
 132 };
 133
 134 /*
 135 WRootMenuReader GNOMEMenuReaderData = {
 136 };
 137 */
 138
 139
 140
 141
 142 #define LINESIZE 1024
 143
 144 static char linebuf[LINESIZE];
 145
 146
 147
 148 /* ---------- proplist ---------- */
 149
 150
 151 static WRootMenuData *pl_openMenuFile(proplist_t pl)
 152 {
 153     PLRootMenuData *data = wmalloc(sizeof(PLRootMenuData));
 154
 155     data->reader = PLMenuReader;
 156
 157     data->pl = pl;
 158     data->curIndex = 0;
 159
 160     data->submenu = NULL;
 161     data->curSubIndex = NULL;
 162     data->submenuDepth = 0;
 163
 164     return data;
 165 }
 166
 167
 168 static Bool pl_hasMoreData(WRootMenuData *data)
 169 {
 170 }
 171
 172
 173 static Bool pl_nextCommand(WRootMenuData *data,
 174                         char **title,
 175                         char **command,
 176                         char **parameter,
 177                         char **shortcut)
 178 {
 179 }
 180
 181
 182 static void pl_closeMenuFile(WRootMenuData *data)
 183 {
 184     if (data->submenu)
 185         wfree(data->submenu);
 186     if (data->curSubIndex)
 187         wfree(data->curSubIndex);
 188
 189     PLRelease(data->pl);
 190
 191     wfree(data);
 192 }
 193
 194
 195 /* ---------- text ---------- */
 196
 197
 198 static WRootMenuData *text_openMenuFile(char *path)
 199 {
 200     TextMenuReaderData *data;
 201
 202     data = wmalloc(sizeof(TextMenuReaderData));
 203     data->reader = TextMenuReader;
 204
 205     data->file = fopen(path, "r");
 206     if (!data->file) {
 207
 208         return NULL;
 209     }
 210 }
 211
 212
 213 static Bool text_hasMoreData(WRootMenuData *data)
 214 {
 215 }
 216
 217
 218 static Bool text_nextCommand(WRootMenuData *data,
 219                         char **title,
 220                         char **command,
 221                         char **parameter,
 222                         char **shortcut)
 223 {
 224 }
 225
 226
 227 static void text_closeMenuFile(WRootMenuData *data)
 228 {
 229 }
 230
 231
 232 /* ---------- directory ---------- */
 233
 234
 235 static WRootMenuData *dir_openMenuFile(char *paths, time_t *timestamp)
 236 {
 237     DirMenuReaderData *data;
 238     char **dirs;
 239     int dirN;
 240     time_t checksum = 0;
 241     int i, c;
 242
 243     /* timestamp for directory is a "checksum" of the directory times */
 244
 245     wtokensplit(paths, &dirs, &dirN);
 246
 247     if (dirN == 0) {
 248         return NULL;
 249     }
 250
 251     for (c = 0, i = 0; i < dirN; i++) {
 252         char *tmp;
 253
 254         if (strcmp(dirs[i], "-noext")==0) {
 255             i++;
 256             continue;
 257         }
 258
 259         tmp = wexpandpath(dirs[i]);
 260         wfree(dirs[i]);
 261         dirs[i] = tmp;
 262
 263         if (stat(dirs[i], &stat_buf)<0) {
 264             wsyserror(_("%s:could not stat menu"), dirs[i]);
 265             wfree(dirs[i]);
 266             dirs[i] = NULL;
 267         } else {
 268             c++;
 269             checksum += stat_buf.st_mtime;
 270         }
 271     }
 272
 273     if (*timestamp == checksum && *timestamp != 0) {
 274         return NULL;
 275     }
 276
 277     if (c == 0) {
 278         for (i = 0; i < dirN; i++) {
 279             if (dirs[i])
 280                 wfree(dirs[i]);
 281         }
 282         wfree(dirs);
 283
 284         return NULL;
 285     }
 286
 287     data = wmalloc(sizeof(DirMenuReaderData));
 288     data->reader = DirMenuReader;
 289
 290
 291
 292 }
 293
 294
 295 static Bool dir_hasMoreData(WRootMenuData *data)
 296 {
 297 }
 298
 299 static Bool dir_nextCommand(WRootMenuData *data,
 300                         char **title,
 301                         char **command,
 302                         char **parameter,
 303                         char **shortcut)
 304 {
 305 }
 306
 307 static void dir_closeMenuFile(WRootMenuData *data)
 308 {
 309 }
 310
 311
 312
 313
 314
 315 WRootMenuData *OpenMenu(char *path, time_t *menuTime)
 316 {
 317     proplist pl;
 318     struct stat stat_buf;
 319     WRootMenuData *data;
 320
 321     /* check whether it's a piped menu */
 322     if (*path == '|') {
 323         /* piped menus have the following semantics for menuTime:
 324          * if it's 0, then it wasnt loaded yet
 325          * if it's 1, it was already loaded, so do not reload
 326          *      (would be too slow)
 327          * now, menuTime will only be set to 1 if the pipe command is
 328          *      specified as ||command instead of |command
 329          * in other words ||command means force the submenu to always refresh
 330          */
 331         if (*menuTime == 0) {
 332             data = pipe_openMenu(path);
 333         }
 334         if (path[1] != '|') {
 335             *menuTime = 1;
 336         }
 337         return data;
 338     }
 339
 340     if (stat(path, &stat_buf) < 0) {
 341         wsyserror(_("could not stat() menu file '%s'"));
 342         return NULL;
 343     }
 344
 345     /* check whether it's a directory */
 346     if (S_ISDIR(stat_buf.st_mode)) {
 347         return dir_openMenuFile(path, menuTime);
 348     }
 349
 350
 351     if (*menuTime >= stat_buf.st_mtime && *menuTime != 0) {
 352         /* no changes in the menu file */
 353         return NULL;
 354     }
 355
 356     /* then check whether it's a proplist menu */
 357     pl = ReadProplistFromFile(path);
 358     if (pl && PLIsArray(pl)) {
 359         *menuTime = stat_buf.st_mtime;
 360         return pl_openMenu(pl);
 361     }
 362
 363     *menuTime = stat_buf.st_mtime;
 364     /* assume its a plain text menu */
 365     return text_openMenuFile(path);
 366 }
 367
 368
 369
 370 WRootMenuData *ReopenRootMenu(time_t *checkTime,
 371                               char **menuPath,
 372                               time_t *menuTimestamp)
 373 {
 374     proplist pl;
 375     struct stat stat_buf;
 376     char *path;
 377
 378
 379     if (stat(path, &stat_buf) < 0) {
 380         wsyserror(_("could not stat() menu file '%s'"));
 381         return NULL;
 382     }
 383
 384     if (*menuTime >= stat_buf.st_mtime && *checkTime != 0) {
 385         /* no changes in WMRootMenu, see if the contents changed */
 386         if (*menuPath != NULL) {
 387             return OpenMenu(*menuPath, menuTimestamp);
 388         } else {
 389             return NULL;
 390         }
 391     }
 392
 393     *checkTime = stat_buf.st_mtime;
 394
 395     pl = ReadProplistFromFile(path);
 396     if (!pl) {
 397         wwarning(_("could not load domain %s from user defaults database"),
 398                  "WMRootMenu");
 399         return NULL;
 400     }
 401
 402     if (PLIsString(pl)) {
 403         char *tmp;
 404         char *path;
 405         Bool menu_is_default = False;
 406
 407         tmp = wexpandpath(PLGetString(pl));
 408
 409         path = getLocalizedMenuFile(tmp);
 410
 411         if (!path) {
 412             path = wfindfile(DEF_CONFIG_PATHS, tmp);
 413         }
 414
 415         if (!path) {
 416             wwarning(_("could not find menu file '%s' referenced in WMRootMenu"),
 417                      tmp);
 418             path = wfindfile(DEF_CONFIG_PATHS, DEF_MENU_FILE);
 419             menu_is_default = True;
 420         }
 421
 422         if (!path) {
 423             wwarning(_("could not find any usable menu files. Please check '%s'"),
 424                       tmp);
 425             wfree(tmp);
 426             return NULL;
 427         }
 428
 429         wfree(tmp);
 430
 431         if (*menuPath) {
 432             if (strcmp(*menuPath, path) != 0) {
 433                 *menuTimestamp = 0;
 434                 wfree(*menuPath);
 435                 *menuPath = path;
 436
 437                 if (menu_is_default) {
 438                     wwarning(_("using default menu file \"%s\" as the menu referenced in WMRootMenu could not be found "),
 439                              path);
 440                 }
 441             } else {
 442                 /* the menu path didn't change, but the
 443                  * pointed file might have changed, so we don't return
 444                  */
 445             }
 446         } else {
 447             *menuPath = path;
 448         }
 449
 450         return OpenMenu(*menuPath, menuTimestamp);
 451     } else if (PLIsArray(pl)) {
 452
 453         *menuTimestamp = stat_buf.st_mtime;
 454
 455         return pl_openMenu(pl);
 456     } else {
 457         wwarning(_("invalid content in menu file '%s'.\nIt should either be a property list menu or the path to the file, enclosed in \"."),
 458                  path);
 459         return NULL;
 460     }
 461 }
 462
 463
 464