wmgen

main.c (6450B)

---

 #include <X11/Xresource.h>
 #include <X11/Xutil.h>
 #include <WMaker.h>
 #include <WINGs/WINGs.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <unistd.h>
 
 #include "app.h"
 #include "infopanel.h"
 #include "mainwindow.h"
 #include "menu.h"
 #include "windowmanager.h"
 
 #include "config.h"
 
 void
 debug_print_state(struct WMNewApp* wma)
 {
 	WMLog(wma, "State dump:\n");
 	WMLog(wma, "===================================\n");
 	WMLog(wma, "dirty:\t\t%s\n", wma->state.dirty ? "YES" : "NO");
 	WMLog(wma, "filename:\t[%s]\n", wma->state.filename);
 	WMLog(wma, "file_open:\t[%s]\n", wma->state.file_open ? "YES" : "NO");
 }
 
 int
 error(const int code, const char* msg, ...)
 {
 	va_list arg;
 
 	va_start(arg, msg);
 	vfprintf(stderr, msg, arg);
 	va_end(arg);
 
 	return code;
 }
 
 static void
 do_exit(struct WMNewApp* wma)
 {
 	exit(0);
 }
 
 void
 exit_action(WMWidget* self, void* data)
 {
 	struct WMNewApp* wma = (struct WMNewApp*)data;
 	WMLog(wma, "exit_action called\n");
 	if (!wma->state.dirty)
 		do_exit(wma);
 
 	switch (WMRunAlertPanel(wma->scr, NULL, "Confirm",
 		"Document %s is modified. Save changes?", "Yes", "No", "Cancel"))
 	{
 	case 0:
 		WMLog(wma, "Saving changes!\n");
 		do_exit(wma);
 		break;
 	case 1:
 		WMLog(wma, "NOT saving changes!\n");
 		do_exit(wma);
 		break;
 	default:
 		WMLog(wma, "Canceled exit!\n");
 	}
 }
 
 void
 exit_menu_action(void* data, int code, Time timestamp)
 {
 	struct WMNewApp* wma = (struct WMNewApp*)data;
 	WMLog(wma, "exit_menu_action called\n");
 	exit_action(wma->mainwin->window, wma);
 }
 
 void
 handle_keypress(XEvent* event, void* data)
 {
 	struct WMNewApp* wma = (struct WMNewApp*)data;
 	int count;
 	char buffer[64];
 	KeySym ksym;
 	int ctrl_pressed  = 0;
 	int meta_pressed  = 0;
 	int shift_pressed = 0;
 
 	WMLog(wma, "handle_keypress called\n");
 
 	count	      = XLookupString(&event->xkey, buffer, 63, &ksym, NULL);
 	buffer[count] = 0;
 
 	WMLog(wma, "\tbuffer: %s\n", buffer);
 	WMLog(wma, "\tksym: 0x%lX\n", ksym);
 	WMLog(wma, "\tstate: %d\n", event->xkey.state);
 
 	ctrl_pressed  = event->xkey.state & ControlMask;
 	meta_pressed  = event->xkey.state & Mod1Mask;
 	shift_pressed = event->xkey.state & ShiftMask;
 
 	WMLog(wma, "\tctrl_pressed: %s\n", ctrl_pressed ? "YES" : "NO");
 	WMLog(wma, "\tmeta_pressed: %s\n", meta_pressed ? "YES" : "NO");
 	WMLog(wma, "\tshift_pressed: %s\n", shift_pressed ? "YES" : "NO");
 
 	switch (ksym)
 	{
 	case XK_F1:
 		info_panel_action(wma->mainwin->window, wma);
 		break;
 	case XK_o:
 		if (ctrl_pressed && !meta_pressed && !shift_pressed)
 			open_action(wma->mainwin->window, wma);
 		break;
 	case XK_s:
 		if (ctrl_pressed && !meta_pressed && !shift_pressed)
 			save_action(wma->mainwin->window, wma);
 		break;
 	case XK_q:
 		if (ctrl_pressed && !meta_pressed && !shift_pressed)
 			exit_action(wma->mainwin->window, wma);
 		break;
 	}
 }
 
 void
 info_panel_action(WMWidget* self, void* data)
 {
 	struct WMNewApp* wma = (struct WMNewApp*)data;
 	WMLog(wma, "info_panel_action called\n");
 	run_info_panel(wma);
 }
 
 void
 info_panel_menu_action(void* data, int code, Time timestamp)
 {
 	struct WMNewApp* wma = (struct WMNewApp*)data;
 	WMLog(wma, "info_menu_action called\n");
 	info_panel_action(wma->mainwin->window, wma);
 }
 
 void
 init_state(struct State* state)
 {
 	state->dirty	 = 0;
 	*state->filename = 0;
 	state->file_open = 0;
 }
 
 void
 not_implemented(WMWidget* self, void* data)
 {
 	struct WMNewApp* wma = (struct WMNewApp*)data;
 	WMRunAlertPanel(wma->scr, NULL, "Sorry",
 		"Function is not yet implemented", "Ok", NULL, NULL);
 }
 
 void
 open_action(WMWidget* self, void* data)
 {
 	struct WMNewApp* wma = (struct WMNewApp*)data;
 	char wd[PATH_MAX];
 	char* filename;
 	char* last_slash;
 
 	WMLog(wma, "open_action called\n");
 	getcwd(wd, PATH_MAX);
 	if (!WMRunModalFilePanelForDirectory(WMGetOpenPanel(wma->scr),
 		    wma->mainwin->window, wd, "Open file", NULL))
 		return;
 	filename   = WMGetFilePanelFileName(WMGetOpenPanel(wma->scr));
 	last_slash = strrchr(filename, '/');
 	if (last_slash)
 		strncpy(wma->state.filename, last_slash + 1, PATH_MAX);
 	else
 		strncpy(wma->state.filename, filename, PATH_MAX);
 	wma->state.file_open = 1;
 	set_mainwin_title(wma);
 	WMLog(wma, "opened file: %s (full path: %s)\n",
 		last_slash ? last_slash + 1 : filename, filename);
 	free(filename);
 }
 
 void
 open_menu_action(void* data, int code, Time timestamp)
 {
 	struct WMNewApp* wma = (struct WMNewApp*)data;
 	WMLog(wma, "open_menu_action called\n");
 	open_action(wma->mainwin->window, wma);
 }
 
 void
 save_action(WMWidget* self, void* data)
 {
 	struct WMNewApp* wma = (struct WMNewApp*)data;
 	WMLog(wma, "save_action called\n");
 	not_implemented(self, wma);
 }
 
 void
 save_menu_action(void* data, int code, Time timestamp)
 {
 	struct WMNewApp* wma = (struct WMNewApp*)data;
 	WMLog(wma, "save_menu_action called\n");
 	save_action(wma->mainwin->window, wma);
 }
 
 void
 usage(const char* arg0)
 {
 	printf("Usage: %s [-d] [-h]\n", arg0);
 	printf("\t-d\tDebug mode\n");
 	printf("\t-h\tPrint this help screen\n");
 }
 
 void
 WMLog(const struct WMNewApp* wma, const char* msg, ...)
 {
 	va_list arg;
 
 	if (!wma->state.debug)
 		return;
 
 	va_start(arg, msg);
 	fprintf(stderr, "%s: ", program_name);
 	vfprintf(stderr, msg, arg);
 	va_end(arg);
 }
 
 int
 main(int argc, char** argv)
 {
 	struct WMNewApp wma;
 	int dbg = 0;
 	int opt;
 
 	while ((opt = getopt(argc, argv, "dh")) != -1)
 	{
 		switch (opt)
 		{
 		case 'd':
 			dbg = 1;
 			break;
 		case 'h':
 			usage(argv[0]);
 			exit(0);
 			break;
 		default:
 			exit(error(1, "Invalid argument: -%c", opt));
 		}
 	}
 
 	init_state(&wma.state);
 	wma.state.debug = dbg;
 	// wma.state.dirty = 1;
 
 	WMInitializeApplication("WMNewApp", &argc, argv);
 
 	if (!(wma.dpy = XOpenDisplay("")))
 		exit(error(1, "XOpenDisplay failed"));
 
 	if (!(wma.scr = WMCreateScreen(wma.dpy, DefaultScreen(wma.dpy))))
 		exit(error(1, "WMCreateScreen failed"));
 
 	create_main_window(&wma);
 
 	wma.app = WMAppCreateWithMain(wma.dpy, DefaultScreen(wma.dpy),
 		WMWidgetXID(wma.mainwin->window));
 	XSetCommand(wma.dpy, WMWidgetXID(wma.mainwin->window), argv, argc);
 	WMSetWindowCloseAction(wma.mainwin->window, exit_action, &wma);
 
 	create_icon(&wma);
 	create_main_menu(&wma);
 	map_main_window(&wma);
 
 	WMSetFocusToWidget(wma.mainwin->window);
 	WMCreateEventHandler(WMWidgetView(wma.mainwin->window), KeyPressMask,
 		handle_keypress, &wma);
 
 	XFlush(wma.dpy);
 
 	while (1)
 	{
 		XEvent event;
 		WMNextEvent(wma.dpy, &event);
 		WMHandleEvent(&event);
 		WMProcessEvent(wma.app, &event);
 	}
 
 	destroy_main_window(&wma);
 
 	return 0;
 }