/* * ModuleConfig handles commands starting with "*". * * Each command is added to a list from which modules request playback * thru "sendconfig". * * Some modules request that module config commands be sent to them * as the commands are entered. Send to modules that want it. */ void ModuleConfig(char *action) { int end; fmodule_list_itr moditr; fmodule *module; struct moduleInfoList *new_entry; end = strlen(action) - 1; if (action[end] == '\n') action[end] = '\0'; /* save for config request */ new_entry = AddToModList(action); /* look at all possible pipes */ module_list_itr_init(&moditr); while ( (module = module_list_itr_next(&moditr)) != NULL) { if (IS_MESSAGE_SELECTED(module, M_SENDCONFIG)) { /* module wants config cmds */ char *name = MOD_NAME(module); if (MOD_ALIAS(module)) { name = MOD_ALIAS(module); } SendConfigToModule( module, new_entry, CatString2("*", name), 0); } } return; }
static struct moduleInfoList *AddToModList(char *tline) { struct moduleInfoList *t, *prev, *this; char *rline = tline; char *alias_end = skipModuleAliasToken(tline + 1); /* Find end of list */ t = modlistroot; prev = NULL; while(t != NULL) { prev = t; t = t->next; } this = (struct moduleInfoList *)safemalloc( sizeof(struct moduleInfoList)); this->alias_len = 0; if (alias_end && alias_end[0] == MODULE_CONFIG_DELIM) { /* migo (01-Sep-2000): construct an old-style config line */ char *conf_start = alias_end + 1; while (isspace(*conf_start)) conf_start++; *alias_end = '\0'; rline = CatString2(tline, conf_start); *alias_end = MODULE_CONFIG_DELIM; this->alias_len = alias_end - tline; } this->data = (char *)safemalloc(strlen(rline)+1); strcpy(this->data, rline); this->next = NULL; if(prev == NULL) { modlistroot = this; } else { prev->next = this; } return this; }
int main(int argc, char **argv) { char *temp, *s; commands = (CommandChain*)safemalloc(sizeof(CommandChain)); commands->first = commands->last = NULL; /* Save the program name for error messages and config parsing */ temp = argv[0]; s = strrchr(argv[0], '/'); if (s != NULL) { temp = s + 1; } Module = temp; configPrefix = CatString2("*", Module); if ((argc != 6) && (argc != 7)) { fprintf(stderr, "%s Version %s should only be executed by fvwm!\n", Module, VERSION); exit(1); } fvwm_fd[0] = atoi(argv[1]); fvwm_fd[1] = atoi(argv[2]); /* Grab the X display information now. */ dpy = XOpenDisplay(displayName); if (!dpy) { fprintf(stderr, "%s: unable to open display '%s'\n", Module, XDisplayName (displayName)); exit (2); } screen = DefaultScreen(dpy); root = RootWindow(dpy, screen); MyDisplayHeight = DisplayHeight(dpy, screen); MyDisplayWidth = DisplayWidth(dpy, screen); XSetErrorHandler(ErrorHandler); flib_init_graphics(dpy); XA_XSETROOT_ID = XInternAtom(dpy, "_XSETROOT_ID", False); XA_ESETROOT_PMAP_ID = XInternAtom(dpy, "ESETROOT_PMAP_ID", False); XA_XROOTPMAP_ID = XInternAtom(dpy, "_XROOTPMAP_ID", False); signal (SIGPIPE, DeadPipe); /* Parse the config file */ ParseConfig(); SetMessageMask(fvwm_fd, M_NEW_PAGE | M_NEW_DESK | M_CONFIG_INFO | M_END_CONFIG_INFO | M_SENDCONFIG); /* ** we really only want the current desk/page, and window list sends it */ SendInfo(fvwm_fd, "Send_WindowList", 0); /* tell fvwm we're running */ SendFinishedStartupNotification(fvwm_fd); /* Recieve all messages from fvwm */ EndLessLoop(); /* Should never get here! */ return 1; }
/* * delete from module configuration */ void CMD_DestroyModuleConfig(F_CMD_ARGS) { struct moduleInfoList *current, *next, *prev; char *info; /* info to be deleted - may contain wildcards */ char *mi; char *alias_end; int alias_len = 0; while (isspace(*action)) { action++; } alias_end = skipModuleAliasToken(action); if (alias_end && alias_end[0] == MODULE_CONFIG_DELIM) { /* migo: construct an old-style config line */ char *conf_start = alias_end + 1; while (isspace(*conf_start)) conf_start++; *alias_end = '\0'; GetNextToken(conf_start, &conf_start); if (conf_start == NULL) { return; } info = stripcpy(CatString2(action, conf_start)); *alias_end = MODULE_CONFIG_DELIM; /* +1 for a leading '*' */ alias_len = alias_end - action + 1; free(conf_start); } else { GetNextToken(action, &info); if (info == NULL) { return; } } current = modlistroot; prev = NULL; while (current != NULL) { GetNextToken(current->data, &mi); next = current->next; if ((!alias_len || !current->alias_len || alias_len == current->alias_len) && matchWildcards(info, mi+1)) { free(current->data); free(current); if( prev ) { prev->next = next; } else { modlistroot = next; } } else { prev = current; } current = next; if (mi) { free(mi); } } free(info); return; }
/* * * Procedure: * main - start of module * */ int main(int argc, char **argv) { /* The struct holding the module info */ static ModuleArgs* module; char *enter_fn="Silent Raise"; /* default */ char *leave_fn=NULL; char *buf; int len; unsigned long m_mask; unsigned long mx_mask; unsigned long last_win = 0; /* last window handled */ unsigned long focus_win = 0; /* current focus */ unsigned long raised_win = 0; fd_set_size_t fd_width; int fd[2]; int timeout; int sec = 0; int usec = 0; int n; struct timeval value; struct timeval *delay; fd_set in_fdset; Bool do_pass_id = False; Bool use_enter_mode = False; Bool use_leave_mode = False; #ifdef DEBUG int count = 0; #endif #ifdef DEBUGTOFILE freopen(".FvwmAutoDebug","w",stderr); #endif module = ParseModuleArgs(argc,argv,0); /* no alias in this module */ if (module==NULL) { fprintf(stderr,"FvwmAuto Version "VERSION" should only be executed by fvwm!\n"); exit(1); } if (module->user_argc < 1 || module->user_argc > 5) { fprintf(stderr,"FvwmAuto can use one to five arguments.\n"); exit(1); } /* Dead pipes mean fvwm died */ #ifdef HAVE_SIGACTION { struct sigaction sigact; sigemptyset(&sigact.sa_mask); sigaddset(&sigact.sa_mask, SIGPIPE); sigaddset(&sigact.sa_mask, SIGINT); sigaddset(&sigact.sa_mask, SIGHUP); sigaddset(&sigact.sa_mask, SIGQUIT); sigaddset(&sigact.sa_mask, SIGTERM); #ifdef SA_RESTART sigact.sa_flags = SA_RESTART; # else sigact.sa_flags = 0; #endif sigact.sa_handler = TerminateHandler; sigaction(SIGPIPE, &sigact, NULL); sigaction(SIGINT, &sigact, NULL); sigaction(SIGHUP, &sigact, NULL); sigaction(SIGQUIT, &sigact, NULL); sigaction(SIGTERM, &sigact, NULL); } #else /* We don't have sigaction(), so fall back to less robust methods. */ #ifdef USE_BSD_SIGNALS fvwmSetSignalMask( sigmask(SIGPIPE) | sigmask(SIGINT) | sigmask(SIGHUP) | sigmask(SIGQUIT) | sigmask(SIGTERM) ); #endif signal(SIGPIPE, TerminateHandler); signal(SIGINT, TerminateHandler); signal(SIGHUP, TerminateHandler); signal(SIGQUIT, TerminateHandler); signal(SIGTERM, TerminateHandler); #ifdef HAVE_SIGINTERRUPT siginterrupt(SIGPIPE, 0); siginterrupt(SIGINT, 0); siginterrupt(SIGHUP, 0); siginterrupt(SIGQUIT, 0); siginterrupt(SIGTERM, 0); #endif #endif fd[0] = module->to_fvwm; fd[1] = module->from_fvwm; if ((timeout = atoi(module->user_argv[0]) )) { sec = timeout / 1000; usec = (timeout % 1000) * 1000; } else { sec = 0; usec = 1000; } delay = &value; n = 1; if (n < module->user_argc && module->user_argv[n]) { char *token; /* -passid option */ if (n < module->user_argc && *module->user_argv[n] && StrEquals(module->user_argv[n], "-passid")) { do_pass_id = True; n++; } if (n < module->user_argc && *module->user_argv[n] && StrEquals(module->user_argv[n], "-menterleave")) { /* enterleave mode */ use_leave_mode = True; use_enter_mode = True; n++; } else if (n < module->user_argc && *module->user_argv[n] && StrEquals(module->user_argv[n], "-menter")) { /* enter mode */ use_leave_mode = False; use_enter_mode = True; n++; } else if (n < module->user_argc && *module->user_argv[n] && StrEquals(module->user_argv[n], "-mfocus")) { /* focus mode */ use_leave_mode = False; use_enter_mode = False; n++; } /*** enter command ***/ if (n < module->user_argc && *module->user_argv[n] && StrEquals(module->user_argv[n], "Nop")) { /* nop */ enter_fn = NULL; n++; } else if (n < module->user_argc) { /* override default */ enter_fn = module->user_argv[n]; n++; } /* This is a hack to prevent user interaction with old configs. */ if (enter_fn) { token = PeekToken(enter_fn, NULL); if (!StrEquals(token, "Silent")) { enter_fn = safestrdup( CatString2("Silent ", enter_fn)); } } /*** leave command ***/ if (n < module->user_argc && module->user_argv[n] && *module->user_argv[n] && StrEquals(module->user_argv[n], "Nop")) { /* nop */ leave_fn = NULL; n++; } else if (n < module->user_argc) { /* leave function specified */ leave_fn=module->user_argv[n]; n++; } if (leave_fn) { token = PeekToken(leave_fn, NULL); if (!StrEquals(token, "Silent")) { leave_fn = safestrdup( CatString2("Silent ", leave_fn)); } } } /* Exit if nothing to do. */ if (!enter_fn && !leave_fn) { return -1; } if (use_enter_mode) { m_mask = 0; mx_mask = MX_ENTER_WINDOW | MX_LEAVE_WINDOW | M_EXTENDED_MSG; } else { mx_mask = M_EXTENDED_MSG; m_mask = M_FOCUS_CHANGE; } /* Disable special raise/lower support on general actions. * * This works as expected in most of cases. */ if (matchWildcards("*Raise*", CatString2(enter_fn, leave_fn)) || matchWildcards("*Lower*", CatString2(enter_fn, leave_fn))) { m_mask |= M_RAISE_WINDOW | M_LOWER_WINDOW; } /* migo (04/May/2000): It is simply incorrect to listen to raise/lower * packets and change the state if the action itself has no raise/lower. * Detecting whether to listen or not by the action name is good enough. m_mask = M_FOCUS_CHANGE | M_RAISE_WINDOW | M_LOWER_WINDOW; */ SetMessageMask(fd, m_mask); SetMessageMask(fd, mx_mask); /* tell fvwm we're running */ SendFinishedStartupNotification(fd); /* tell fvwm that we want to be lock on send */ SetSyncMask(fd, m_mask); SetSyncMask(fd, mx_mask); fd_width = fd[1] + 1; FD_ZERO(&in_fdset); /* create the command buffer */ len = 0; if (enter_fn != 0) { len = strlen(enter_fn); } if (leave_fn != NULL) { len = max(len, strlen(leave_fn)); } if (do_pass_id) { len += 32; } buf = safemalloc(len); while (!isTerminated) { char raise_window_now; static char have_new_window = 0; FD_SET(fd[1], &in_fdset); myfprintf( (stderr, "\nstart %d (hnw = %d, usec = %d)\n", count++, have_new_window, usec)); /* fill in struct - modified by select() */ delay->tv_sec = sec; delay->tv_usec = usec; #ifdef DEBUG { char tmp[32]; sprintf(tmp, "%d usecs", (delay) ? (int)delay->tv_usec : -1); myfprintf((stderr, "select: delay = %s\n", (have_new_window) ? tmp : "infinite" )); } #endif if (fvwmSelect(fd_width, &in_fdset, NULL, NULL, (have_new_window) ? delay : NULL) == -1) { myfprintf( (stderr, "select: error! (%s)\n", strerror(errno))); break; } raise_window_now = 0; if (FD_ISSET(fd[1], &in_fdset)) { FvwmPacket *packet = ReadFvwmPacket(fd[1]); if (packet == NULL) { myfprintf( (stderr, "Leaving because of null packet\n")); break; } myfprintf( (stderr, "pw = 0x%x, fw=0x%x, rw = 0x%x, lw=0x%x\n", (int)packet->body[0], (int)focus_win, (int)raised_win, (int)last_win)); switch (packet->type) { case MX_ENTER_WINDOW: focus_win = packet->body[0]; if (focus_win != raised_win) { myfprintf((stderr, "entered new window\n")); have_new_window = 1; raise_window_now = 0; } else if (focus_win == last_win) { have_new_window = 0; } else { myfprintf((stderr, "entered other window\n")); } break; case MX_LEAVE_WINDOW: if (use_leave_mode) { if (focus_win == raised_win) { focus_win = 0; } myfprintf((stderr, "left raised window\n")); have_new_window = 1; raise_window_now = 0; } break; case M_FOCUS_CHANGE: /* it's a focus package */ focus_win = packet->body[0]; if (focus_win != raised_win) { myfprintf((stderr, "focus on new window\n")); have_new_window = 1; raise_window_now = 0; } else { myfprintf((stderr, "focus on old window\n")); } break; case M_RAISE_WINDOW: myfprintf( (stderr, "raise packet 0x%x\n", (int)packet->body[0])); raised_win = packet->body[0]; if (have_new_window && focus_win == raised_win) { myfprintf( (stderr, "its the old window:" " don't raise\n")); have_new_window = 0; } break; case M_LOWER_WINDOW: myfprintf( (stderr, "lower packet 0x%x\n", (int)packet->body[0])); if (have_new_window && focus_win == packet->body[0]) { myfprintf( (stderr, "window was explicitly" " lowered, don't raise it" " again\n")); have_new_window = 0; } break; } /* switch */ SendUnlockNotification(fd); } else { if (have_new_window) { myfprintf((stderr, "must raise now\n")); raise_window_now = 1; } } if (raise_window_now) { myfprintf((stderr, "raising 0x%x\n", (int)focus_win)); if (leave_fn && ((last_win && !use_leave_mode) || (raised_win && use_enter_mode))) { /* if focus_win isn't the root */ if (do_pass_id) { sprintf(buf, "%s 0x%x\n", leave_fn, (int)last_win); } else { sprintf(buf, "%s\n", leave_fn); } SendInfo(fd, buf, last_win); if (use_enter_mode) { raised_win = 0; } } if (focus_win && enter_fn) { /* if focus_win isn't the root */ if (do_pass_id) { sprintf(buf, "%s 0x%x\n", enter_fn, (int)focus_win); } else { sprintf(buf, "%s\n", enter_fn); } SendInfo(fd, buf, focus_win); raised_win = focus_win; } else if (focus_win && enter_fn == NULL) { raised_win = focus_win; } /* force fvwm to synchronise on slow X connections to * avoid a race condition. Still possible, but much * less likely. */ SendInfo(fd, "XSync", focus_win); /* switch to wait mode again */ last_win = focus_win; have_new_window = 0; } } /* while */ return 0; }
static char *translit_csname(char *cs) { return CatString2(cs, TRANSLIT_SUFFIX); }