443 lines
13 KiB
C
443 lines
13 KiB
C
/*
|
|
* awesome.c - awesome main functions
|
|
*
|
|
* Copyright © 2007-2008 Julien Danjou <julien@danjou.info>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along
|
|
* with this program; if not, write to the Free Software Foundation, Inc.,
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
*/
|
|
|
|
#define _GNU_SOURCE
|
|
#include <getopt.h>
|
|
|
|
#include <errno.h>
|
|
#include <locale.h>
|
|
#include <stdio.h>
|
|
#include <unistd.h>
|
|
#include <sys/select.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/un.h>
|
|
#include <fcntl.h>
|
|
#include <signal.h>
|
|
#include <X11/cursorfont.h>
|
|
#include <X11/keysym.h>
|
|
#include <X11/Xatom.h>
|
|
#include <X11/Xproto.h>
|
|
#include <X11/Xutil.h>
|
|
#include <X11/extensions/shape.h>
|
|
#include <X11/extensions/Xrandr.h>
|
|
|
|
#include "config.h"
|
|
#include "awesome.h"
|
|
#include "event.h"
|
|
#include "layout.h"
|
|
#include "screen.h"
|
|
#include "statusbar.h"
|
|
#include "uicb.h"
|
|
#include "window.h"
|
|
#include "client.h"
|
|
#include "focus.h"
|
|
#include "ewmh.h"
|
|
#include "tag.h"
|
|
#include "common/socket.h"
|
|
#include "common/util.h"
|
|
#include "common/version.h"
|
|
#include "common/configopts.h"
|
|
#include "common/xscreen.h"
|
|
|
|
static int (*xerrorxlib) (Display *, XErrorEvent *);
|
|
static Bool running = True;
|
|
|
|
AwesomeConf globalconf;
|
|
|
|
/** Scan X to find windows to manage
|
|
*/
|
|
static void
|
|
scan()
|
|
{
|
|
unsigned int i, num;
|
|
int screen, real_screen;
|
|
Window *wins = NULL, d1, d2;
|
|
XWindowAttributes wa;
|
|
|
|
for(screen = 0; screen < ScreenCount(globalconf.display); screen++)
|
|
{
|
|
if(XQueryTree(globalconf.display, RootWindow(globalconf.display, screen), &d1, &d2, &wins, &num))
|
|
for(i = 0; i < num; i++)
|
|
/* XGetWindowAttributes return 1 on success */
|
|
if(XGetWindowAttributes(globalconf.display, wins[i], &wa)
|
|
&& !wa.override_redirect
|
|
&& (wa.map_state == IsViewable || window_getstate(wins[i]) == IconicState))
|
|
{
|
|
real_screen = screen_get_bycoord(globalconf.screens_info, screen, wa.x, wa.y);
|
|
client_manage(wins[i], &wa, real_screen);
|
|
}
|
|
if(wins)
|
|
XFree(wins);
|
|
}
|
|
}
|
|
|
|
/** Startup Error handler to check if another window manager
|
|
* is already running.
|
|
* \param disp Display
|
|
* \param ee Error event
|
|
*/
|
|
static int __attribute__ ((noreturn))
|
|
xerrorstart(Display * disp __attribute__ ((unused)),
|
|
XErrorEvent * ee __attribute__ ((unused)))
|
|
{
|
|
eprint("another window manager is already running\n");
|
|
}
|
|
|
|
/** Quit awesome.
|
|
* \param screen Screen ID
|
|
* \param arg nothing
|
|
* \ingroup ui_callback
|
|
*/
|
|
void
|
|
uicb_quit(int screen __attribute__ ((unused)), char *arg __attribute__ ((unused)))
|
|
{
|
|
running = False;
|
|
}
|
|
|
|
static void
|
|
exit_on_signal(int sig __attribute__ ((unused)))
|
|
{
|
|
running = False;
|
|
}
|
|
|
|
/** \brief awesome xerror function
|
|
* There's no way to check accesses to destroyed windows, thus those cases are
|
|
* ignored (especially on UnmapNotify's). Other types of errors call Xlibs
|
|
* default error handler, which may call exit.
|
|
* \param edpy display ref
|
|
* \param ee XErrorEvent event
|
|
* \return 0 if no error, or xerror's xlib return status
|
|
*/
|
|
static int
|
|
xerror(Display *edpy, XErrorEvent *ee)
|
|
{
|
|
if(ee->error_code == BadWindow
|
|
|| (ee->error_code == BadMatch && ee->request_code == X_SetInputFocus)
|
|
|| (ee->error_code == BadValue && ee->request_code == X_KillClient)
|
|
|| (ee->request_code == X_ConfigureWindow && ee->error_code == BadMatch))
|
|
return 0;
|
|
warn("fatal error: request code=%d, error code=%d\n", ee->request_code, ee->error_code);
|
|
return xerrorxlib(edpy, ee); /* may call exit */
|
|
}
|
|
|
|
/** Print help and exit(2) with given exit_code.
|
|
*/
|
|
static void __attribute__ ((noreturn))
|
|
exit_help(int exit_code)
|
|
{
|
|
FILE *outfile = (exit_code == EXIT_SUCCESS) ? stdout : stderr;
|
|
fprintf(outfile,
|
|
"Usage: awesome [OPTION]\n\
|
|
-h, --help show help\n\
|
|
-v, --version show version\n\
|
|
-c, --config FILE configuration file to use\n\
|
|
-k, --check check configuration file syntax\n\
|
|
-s --sync enable synchronization (X debug)\n");
|
|
exit(exit_code);
|
|
}
|
|
|
|
/** Hello, this is main
|
|
* \param argc who knows
|
|
* \param argv who knows
|
|
* \return EXIT_SUCCESS I hope
|
|
*/
|
|
typedef void event_handler (XEvent *);
|
|
int
|
|
main(int argc, char *argv[])
|
|
{
|
|
char buf[1024];
|
|
const char *confpath = NULL;
|
|
int r, xfd, e_dummy, csfd, shape_event, randr_event_base, i, screen, opt;
|
|
ssize_t cmdlen = 1;
|
|
Statusbar *statusbar;
|
|
fd_set rd;
|
|
XEvent ev;
|
|
Display * dpy;
|
|
event_handler **handler;
|
|
struct sockaddr_un *addr;
|
|
Client *c;
|
|
XSetWindowAttributes wa;
|
|
Bool xsync = False, confcheck = False;
|
|
static struct option long_options[] =
|
|
{
|
|
{"help", 0, NULL, 'h'},
|
|
{"version", 0, NULL, 'v'},
|
|
{"check", 0, NULL, 'k'},
|
|
{"config", 1, NULL, 'c'},
|
|
{"sync", 0, NULL, 's'},
|
|
{NULL, 0, NULL, 0}
|
|
};
|
|
|
|
/* save argv */
|
|
for(i = 0; i < argc; i++)
|
|
cmdlen += a_strlen(argv[i]) + 1;
|
|
|
|
globalconf.argv = p_new(char, cmdlen);
|
|
a_strcpy(globalconf.argv, cmdlen, argv[0]);
|
|
|
|
for(i = 1; i < argc; i++)
|
|
{
|
|
a_strcat(globalconf.argv, cmdlen, " ");
|
|
a_strcat(globalconf.argv, cmdlen, argv[i]);
|
|
}
|
|
|
|
/* check args */
|
|
while((opt = getopt_long(argc, argv, "vhkc:s",
|
|
long_options, NULL)) != -1)
|
|
switch(opt)
|
|
{
|
|
case 'v':
|
|
eprint_version("awesome");
|
|
break;
|
|
case 'h':
|
|
exit_help(EXIT_SUCCESS);
|
|
break;
|
|
case 'c':
|
|
if(a_strlen(optarg))
|
|
confpath = a_strdup(optarg);
|
|
else
|
|
eprint("-c option requires a file name\n");
|
|
break;
|
|
case 'k':
|
|
confcheck = True;
|
|
break;
|
|
case 's':
|
|
xsync = True;
|
|
break;
|
|
}
|
|
|
|
/* Text won't be printed correctly otherwise */
|
|
setlocale(LC_CTYPE, "");
|
|
|
|
if(confcheck)
|
|
return config_check(confpath);
|
|
|
|
/* X stuff */
|
|
if(!(dpy = XOpenDisplay(NULL)))
|
|
eprint("cannot open display\n");
|
|
|
|
xfd = ConnectionNumber(dpy);
|
|
|
|
XSetErrorHandler(xerrorstart);
|
|
for(screen = 0; screen < ScreenCount(dpy); screen++)
|
|
/* this causes an error if some other window manager is running */
|
|
XSelectInput(dpy, RootWindow(dpy, screen), SubstructureRedirectMask);
|
|
|
|
/* need to XSync to validate errorhandler */
|
|
XSync(dpy, False);
|
|
XSetErrorHandler(NULL);
|
|
xerrorxlib = XSetErrorHandler(xerror);
|
|
XSync(dpy, False);
|
|
|
|
if(xsync)
|
|
XSynchronize(dpy, True);
|
|
|
|
/* store display */
|
|
globalconf.display = dpy;
|
|
|
|
/* init EWMH atoms */
|
|
ewmh_init_atoms();
|
|
|
|
/* init screens struct */
|
|
globalconf.screens_info = screensinfo_new(dpy);
|
|
globalconf.screens = p_new(VirtScreen, globalconf.screens_info->nscreen);
|
|
focus_add_client(NULL);
|
|
|
|
/* parse config */
|
|
config_parse(confpath);
|
|
|
|
/* init cursors */
|
|
globalconf.cursor[CurNormal] = XCreateFontCursor(globalconf.display, XC_left_ptr);
|
|
globalconf.cursor[CurResize] = XCreateFontCursor(globalconf.display, XC_sizing);
|
|
globalconf.cursor[CurMove] = XCreateFontCursor(globalconf.display, XC_fleur);
|
|
|
|
/* for each virtual screen */
|
|
for(screen = 0; screen < globalconf.screens_info->nscreen; screen++)
|
|
{
|
|
/* view at least one tag */
|
|
tag_view(globalconf.screens[screen].tags, True);
|
|
|
|
for(statusbar = globalconf.screens[screen].statusbar; statusbar; statusbar = statusbar->next)
|
|
statusbar_init(statusbar);
|
|
}
|
|
|
|
/* select for events */
|
|
wa.event_mask = SubstructureRedirectMask | SubstructureNotifyMask
|
|
| EnterWindowMask | LeaveWindowMask | StructureNotifyMask;
|
|
wa.cursor = globalconf.cursor[CurNormal];
|
|
|
|
/* do this only for real screen */
|
|
for(screen = 0; screen < ScreenCount(dpy); screen++)
|
|
{
|
|
XChangeWindowAttributes(globalconf.display,
|
|
RootWindow(globalconf.display, screen),
|
|
CWEventMask | CWCursor, &wa);
|
|
XSelectInput(globalconf.display,
|
|
RootWindow(globalconf.display, screen),
|
|
wa.event_mask);
|
|
ewmh_set_supported_hints(screen);
|
|
/* call this to at least grab root window clicks */
|
|
window_root_grabbuttons(screen);
|
|
window_root_grabkeys(screen);
|
|
}
|
|
|
|
/* scan existing windows */
|
|
scan();
|
|
|
|
handler = p_new(event_handler *, LASTEvent);
|
|
handler[ButtonPress] = event_handle_buttonpress;
|
|
handler[ConfigureRequest] = event_handle_configurerequest;
|
|
handler[ConfigureNotify] = event_handle_configurenotify;
|
|
handler[DestroyNotify] = event_handle_destroynotify;
|
|
handler[EnterNotify] = event_handle_enternotify;
|
|
handler[Expose] = event_handle_expose;
|
|
handler[KeyPress] = event_handle_keypress;
|
|
handler[MappingNotify] = event_handle_mappingnotify;
|
|
handler[MapRequest] = event_handle_maprequest;
|
|
handler[PropertyNotify] = event_handle_propertynotify;
|
|
handler[UnmapNotify] = event_handle_unmapnotify;
|
|
handler[ClientMessage] = event_handle_clientmessage;
|
|
|
|
/* check for shape extension */
|
|
if((globalconf.have_shape = XShapeQueryExtension(dpy, &shape_event, &e_dummy)))
|
|
{
|
|
p_realloc(&handler, shape_event + 1);
|
|
handler[shape_event] = event_handle_shape;
|
|
}
|
|
|
|
/* check for randr extension */
|
|
if((globalconf.have_randr = XRRQueryExtension(dpy, &randr_event_base, &e_dummy)))
|
|
{
|
|
p_realloc(&handler, randr_event_base + RRScreenChangeNotify + 1);
|
|
handler[randr_event_base + RRScreenChangeNotify] = event_handle_randr_screen_change_notify;
|
|
}
|
|
|
|
XSync(dpy, False);
|
|
|
|
/* get socket fd */
|
|
csfd = socket_getclient();
|
|
addr = socket_getaddr(getenv("DISPLAY"));
|
|
|
|
/* Needed for some Solaris */
|
|
#ifndef SUN_LEN
|
|
#define SUN_LEN(ptr) ((size_t) (((struct sockaddr_un *) 0)->sun_path) + strlen ((ptr)->sun_path))
|
|
#endif
|
|
|
|
if(bind(csfd, (const struct sockaddr *) addr, SUN_LEN(addr)))
|
|
{
|
|
if(errno == EADDRINUSE)
|
|
{
|
|
if(unlink(addr->sun_path))
|
|
warn("error unlinking existing file: %s\n", strerror(errno));
|
|
if(bind(csfd, (const struct sockaddr *) addr, SUN_LEN(addr)))
|
|
warn("error binding UNIX domain socket: %s\n", strerror(errno));
|
|
}
|
|
else
|
|
warn("error binding UNIX domain socket: %s\n", strerror(errno));
|
|
}
|
|
|
|
/* register function for signals */
|
|
signal(SIGINT, &exit_on_signal);
|
|
signal(SIGTERM, &exit_on_signal);
|
|
signal(SIGHUP, &exit_on_signal);
|
|
|
|
/* refresh everything before waiting events */
|
|
statusbar_refresh();
|
|
layout_refresh();
|
|
|
|
/* main event loop, also reads status text from socket */
|
|
while(running)
|
|
{
|
|
FD_ZERO(&rd);
|
|
if(csfd >= 0)
|
|
FD_SET(csfd, &rd);
|
|
FD_SET(xfd, &rd);
|
|
if(select(MAX(xfd, csfd) + 1, &rd, NULL, NULL, NULL) == -1)
|
|
{
|
|
if(errno == EINTR)
|
|
continue;
|
|
eprint("select failed\n");
|
|
}
|
|
if(csfd >= 0 && FD_ISSET(csfd, &rd))
|
|
switch (r = recv(csfd, buf, sizeof(buf)-1, MSG_TRUNC))
|
|
{
|
|
case -1:
|
|
warn("error reading UNIX domain socket: %s\n", strerror(errno));
|
|
csfd = -1;
|
|
break;
|
|
case 0:
|
|
break;
|
|
default:
|
|
if(r >= ssizeof(buf))
|
|
break;
|
|
buf[r] = '\0';
|
|
parse_control(buf);
|
|
statusbar_refresh();
|
|
layout_refresh();
|
|
}
|
|
/* two level XPending:
|
|
* we need to first check we have XEvent to handle
|
|
* and if so, we handle them all in a round.
|
|
* Then when we have refresh()'ed stuff so maybe new XEvent
|
|
* are available and select() won't tell us, so let's check
|
|
* with XPending() again.
|
|
*/
|
|
while(XPending(dpy))
|
|
{
|
|
while(XPending(dpy))
|
|
{
|
|
XNextEvent(dpy, &ev);
|
|
if(handler[ev.type])
|
|
handler[ev.type](&ev);
|
|
|
|
/* need to resync */
|
|
XSync(dpy, False);
|
|
}
|
|
|
|
statusbar_refresh();
|
|
layout_refresh();
|
|
|
|
/* need to resync */
|
|
XSync(dpy, False);
|
|
}
|
|
}
|
|
|
|
|
|
if(csfd > 0 && close(csfd))
|
|
warn("error closing UNIX domain socket: %s\n", strerror(errno));
|
|
if(unlink(addr->sun_path))
|
|
warn("error unlinking UNIX domain socket: %s\n", strerror(errno));
|
|
p_delete(&addr);
|
|
|
|
/* remap all clients since some WM won't handle them otherwise */
|
|
for(c = globalconf.clients; c; c = c->next)
|
|
client_unban(c);
|
|
|
|
XSync(globalconf.display, False);
|
|
|
|
XCloseDisplay(dpy);
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|
|
// vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=80
|