fvwm/schedule.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 #include "config.h"
  18
  19 #include <stdio.h>
  20
  21 #include "libs/fvwmlib.h"
  22 #include "libs/queue.h"
  23 #include "libs/charmap.h"
  24 #include "libs/wcontext.h"
  25 #include "libs/Parse.h"
  26 #include "fvwm.h"
  27 #include "externs.h"
  28 #include "colorset.h"
  29 #include "bindings.h"
  30 #include "misc.h"
  31 #include "cursor.h"
  32 #include "functions.h"
  33 #include "commands.h"
  34 #include "screen.h"
  35
  36 typedef struct
  37 {
  38         int id;
  39         Time time_to_execute;
  40         Window window;
  41         char *command;
  42         int period; /* in milliseconds */
  43 } sq_object_type;
  44
  45 static int last_schedule_id = 0;
  46 static int next_schedule_id = -1;
  47 static fqueue sq = FQUEUE_INIT;
  48
  49 static int cmp_times(Time t1, Time t2)
  50 {
  51         unsigned long ul1 = (unsigned long)t1;
  52         unsigned long ul2 = (unsigned long)t2;
  53         unsigned long diff;
  54         signed long udiff;
  55
  56         diff = ul1 - ul2;
  57         udiff = *(signed long *)&diff;
  58         if (udiff > 0)
  59         {
  60                 return 1;
  61         }
  62         else if (udiff < 0)
  63         {
  64                 return -1;
  65         }
  66         else
  67         {
  68                 return 0;
  69         }
  70 }
  71
  72 static int cmp_object_time(void *object1, void *object2, void *args)
  73 {
  74         sq_object_type *so1 = (sq_object_type *)object1;
  75         sq_object_type *so2 = (sq_object_type *)object2;
  76
  77         return cmp_times(so1->time_to_execute, so2->time_to_execute);
  78 }
  79
  80 static int check_deschedule_obj_func(void *object, void *args)
  81 {
  82         sq_object_type *obj = object;
  83
  84         return (obj->id == *(int *)args);
  85 }
  86
  87 static void destroy_obj_func(void *object)
  88 {
  89         sq_object_type *obj = object;
  90
  91         if (obj->command != NULL)
  92         {
  93                 free(obj->command);
  94         }
  95         free(obj);
  96
  97         return;
  98 }
  99
 100 static void deschedule(int *pid)
 101 {
 102         int id;
 103
 104         if (FQUEUE_IS_EMPTY(&sq))
 105         {
 106                 return;
 107         }
 108         /* get the job group id to deschedule */
 109         if (pid != NULL)
 110         {
 111                 id = *pid;
 112         }
 113         else
 114         {
 115                 id = last_schedule_id;
 116         }
 117         /* deschedule matching jobs */
 118         fqueue_remove_or_operate_all(
 119                 &sq, check_deschedule_obj_func, NULL, destroy_obj_func,
 120                 (void *)&id);
 121
 122         return;
 123 }
 124
 125 static void schedule(
 126         Window window, char *command, Time time_to_execute, int *pid,
 127         int period)
 128 {
 129         sq_object_type *new_obj;
 130
 131         if (command == NULL || *command == 0)
 132         {
 133                 return;
 134         }
 135         /* create the new object */
 136         new_obj = (sq_object_type *)safemalloc(sizeof(sq_object_type));
 137         memset(new_obj, 0, sizeof(sq_object_type));
 138         new_obj->window = window;
 139         new_obj->command = safestrdup(command);
 140         new_obj->time_to_execute = time_to_execute;
 141         new_obj->period = period; /* 0 if this is not a periodic command */
 142         /* set the job group id */
 143         if (pid != NULL)
 144         {
 145                 new_obj->id = *pid;
 146         }
 147         else
 148         {
 149                 new_obj->id = next_schedule_id;
 150                 next_schedule_id--;
 151                 if (next_schedule_id >= 0)
 152                 {
 153                         /* wrapped around */
 154                         next_schedule_id = -1;
 155                 }
 156         }
 157         last_schedule_id = new_obj->id;
 158         /* insert into schedule queue */
 159         fqueue_add_inside(&sq, new_obj, cmp_object_time, NULL);
 160
 161         return;
 162 }
 163
 164 static int check_execute_obj_func(void *object, void *args)
 165 {
 166         sq_object_type *obj = object;
 167         Time *ptime = (Time *)args;
 168
 169         return (cmp_times(*ptime, obj->time_to_execute) >= 0);
 170 }
 171
 172 static void execute_obj_func(void *object, void *args)
 173 {
 174         sq_object_type *obj = object;
 175
 176         if (obj->command != NULL)
 177         {
 178                 /* execute the command */
 179                 const exec_context_t *exc;
 180                 exec_context_changes_t ecc;
 181                 exec_context_change_mask_t mask = ECC_TYPE | ECC_WCONTEXT;
 182
 183                 ecc.type = EXCT_SCHEDULE;
 184                 ecc.w.wcontext = C_ROOT;
 185                 if (XFindContext(
 186                             dpy, obj->window, FvwmContext,
 187                             (caddr_t *)&ecc.w.fw) != XCNOENT)
 188                 {
 189                         ecc.w.wcontext = C_WINDOW;
 190                         mask |= ECC_FW;
 191                 }
 192                 exc = exc_create_context(&ecc, mask);
 193                 execute_function(NULL, exc, obj->command, 0);
 194                 exc_destroy_context(exc);
 195         }
 196         if (obj->period > 0)
 197         {
 198                 /* This is a periodic function, so reschedule it. */
 199                 sq_object_type *new_obj = (sq_object_type *)safemalloc(sizeof(sq_object_type));
 200                 memcpy(new_obj, obj, sizeof(sq_object_type));
 201                 obj->command = NULL; /* new_obj->command now points to cmd. */
 202                 new_obj->time_to_execute = fev_get_evtime() + new_obj->period;
 203                 /* insert into schedule queue */
 204                 fqueue_add_inside(&sq, new_obj, cmp_object_time, NULL);
 205         }
 206         XFlush(dpy);
 207
 208         return;
 209 }
 210
 211 /* executes all scheduled commands that are due for execution */
 212 void squeue_execute(void)
 213 {
 214         Time current_time;
 215
 216         if (FQUEUE_IS_EMPTY(&sq))
 217         {
 218                 return;
 219         }
 220         current_time = get_server_time();
 221         fqueue_remove_or_operate_all(
 222                 &sq, check_execute_obj_func, execute_obj_func,
 223                 destroy_obj_func, &current_time);
 224
 225         return;
 226 }
 227
 228 /* returns the time in milliseconds to wait before next queue command must be
 229  * executed or -1 if none is queued */
 230 int squeue_get_next_ms(void)
 231 {
 232         int ms;
 233         sq_object_type *obj;
 234
 235         if (fqueue_get_first(&sq, (void **)&obj) == 0)
 236         {
 237                 return -1;
 238         }
 239         if (cmp_times(fev_get_evtime(), obj->time_to_execute) >= 0)
 240         {
 241                 /* jobs pending to be executed immediately */
 242                 ms = 0;
 243         }
 244         else
 245         {
 246                 /* execute jobs later */
 247                 ms =  obj->time_to_execute - fev_get_evtime();
 248         }
 249
 250         return ms;
 251 }
 252
 253 int squeue_get_next_id(void)
 254 {
 255         return next_schedule_id;
 256 }
 257
 258 int squeue_get_last_id(void)
 259 {
 260         return last_schedule_id;
 261 }
 262
 263 void CMD_Schedule(F_CMD_ARGS)
 264 {
 265         Window xw;
 266         Time time;
 267         Time current_time;
 268         char *taction;
 269         char *token;
 270         char *next;
 271         int ms;
 272         int id;
 273         int *pid;
 274         int n;
 275         FvwmWindow * const fw = exc->w.fw;
 276         Bool is_periodic = False;
 277
 278         token = PeekToken(action, &next);
 279         if (token && strcasecmp(token, "periodic") == 0)
 280         {
 281                 is_periodic = True;
 282                 action = next;
 283         }
 284         /* get the time to execute */
 285         n = GetIntegerArguments(action, &action, &ms, 1);
 286         if (n <= 0)
 287         {
 288                 fvwm_msg(ERR, "CMD_Schedule",
 289                          "Requires time to schedule as argument");
 290                 return;
 291         }
 292         if (ms < 0)
 293         {
 294                 ms = 0;
 295         }
 296 #if 0
 297         /* eats up way too much cpu if schedule is used excessively */
 298         current_time = get_server_time();
 299 #else
 300         /* with this version, scheduled commands may be executed earlier than
 301          * intended. */
 302         current_time = fev_get_evtime();
 303 #endif
 304         time = current_time + (Time)ms;
 305         /* get the job group id to schedule */
 306         n = GetIntegerArgumentsAnyBase(action, &taction, &id, 1);
 307         if (n >= 1)
 308         {
 309                 pid = &id;
 310                 action = taction;
 311         }
 312         else
 313         {
 314                 pid = NULL;
 315         }
 316         /* get the window to operate on */
 317         if (fw != NULL)
 318         {
 319                 xw = FW_W(fw);
 320         }
 321         else
 322         {
 323                 xw = None;
 324         }
 325         /* schedule the job */
 326         schedule(xw, action, time, pid, (is_periodic == True ? ms : 0));
 327
 328         return;
 329 }
 330
 331 void CMD_Deschedule(F_CMD_ARGS)
 332 {
 333         int id;
 334         int *pid;
 335         int n;
 336
 337         /* get the job group id to deschedule */
 338         n = GetIntegerArgumentsAnyBase(action, &action, &id, 1);
 339         if (n <= 0)
 340         {
 341                 /* none, use default */
 342                 pid = NULL;
 343         }
 344         else
 345         {
 346                 pid = &id;
 347         }
 348         /* deschedule matching jobs */
 349         deschedule(pid);
 350
 351         return;
 352 }