awesome-menu.c

   1 /*
   2  * awesome-menu.c - menu window for awesome
   3  *
   4  * Copyright © 2008 Julien Danjou <julien@danjou.info>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program; if not, write to the Free Software Foundation, Inc.,
  18  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19  *
  20  */
  21
  22 #define _GNU_SOURCE
  23 #include <getopt.h>
  24
  25 #include <signal.h>
  26 #include <unistd.h>
  27 #include <stdlib.h>
  28 #include <dirent.h>
  29 #include <pwd.h>
  30 #include <sys/types.h>
  31
  32 #include <confuse.h>
  33
  34 #include <X11/Xlib.h>
  35 #include <X11/extensions/Xinerama.h>
  36
  37 #include "common/swindow.h"
  38 #include "common/util.h"
  39 #include "common/version.h"
  40 #include "common/configopts.h"
  41 #include "common/xutil.h"
  42
  43 #define PROGNAME "awesome-menu"
  44
  45 #define CLEANMASK(mask) (mask & ~(globalconf.numlockmask | LockMask))
  46
  47 typedef enum
  48 {
  49     STOP = 0,
  50     RUN = 1,
  51     CANCEL = 2
  52 } status_t;
  53
  54 static status_t status = RUN;
  55
  56 /** Import awesome config file format */
  57 extern cfg_opt_t awesome_opts[];
  58
  59 typedef struct item_t item_t;
  60 struct item_t
  61 {
  62     char *data;
  63     item_t *prev, *next;
  64     Bool match;
  65 };
  66
  67 static void
  68 item_delete(item_t **item)
  69 {
  70     p_delete(&(*item)->data);
  71     p_delete(item);
  72 }
  73
  74 DO_SLIST(item_t, item, item_delete);
  75
  76 /** awesome-run global configuration structure */
  77 typedef struct
  78 {
  79     /** Display ref */
  80     Display *display;
  81     /** The window */
  82     SimpleWindow *sw;
  83     /** The draw contet */
  84     DrawCtx *ctx;
  85     /** Font to use */
  86     XftFont *font;
  87     /** Draw shadow_offset under text */
  88     Bool shadow_offset;
  89     /** Foreground color */
  90     XColor fg;
  91     /** Background color */
  92     XColor bg;
  93     /** List background */
  94     XColor fg_focus, bg_focus;
  95     /** Numlock mask */
  96     unsigned int numlockmask;
  97     /** The text */
  98     char text[PATH_MAX];
  99     /** Item list */
 100     item_t *items;
 101     /** Selected item */
 102     item_t *item_selected;
 103     /** What to do with the result text */
 104     char *exec;
 105     /** Prompt */
 106     char *prompt;
 107 } AwesomeMenuConf;
 108
 109 static AwesomeMenuConf globalconf;
 110
 111 static void __attribute__ ((noreturn))
 112 exit_help(int exit_code)
 113 {
 114     FILE *outfile = (exit_code == EXIT_SUCCESS) ? stdout : stderr;
 115     fprintf(outfile, "Usage: %s [-e command] <message>\n",
 116             PROGNAME);
 117     exit(exit_code);
 118 }
 119
 120 static int
 121 config_parse(const char *confpatharg, const char *menu_title, Area *geometry)
 122 {
 123     int ret, i;
 124     char *confpath, *opt;
 125     cfg_t *cfg, *cfg_menu = NULL, *cfg_screen, *cfg_general,
 126           *cfg_colors, *cfg_menu_colors = NULL;
 127
 128     if(!confpatharg)
 129         confpath = config_file();
 130     else
 131         confpath = a_strdup(confpatharg);
 132
 133     cfg = cfg_init(awesome_opts, CFGF_NONE);
 134
 135     switch((ret = cfg_parse(cfg, confpath)))
 136     {
 137       case CFG_FILE_ERROR:
 138         perror("awesome-message: parsing configuration file failed");
 139         break;
 140       case CFG_PARSE_ERROR:
 141         cfg_error(cfg, "awesome: parsing configuration file %s failed.\n", confpath);
 142         break;
 143     }
 144
 145     if(ret)
 146         return ret;
 147
 148     if(menu_title && !(cfg_menu = cfg_gettsec(cfg, "menu", menu_title)))
 149         warn("no definition for menu %s in configuration file: using default\n", menu_title);
 150
 151     /* get global screen section */
 152     if(!(cfg_screen = cfg_getsec(cfg, "screen")))
 153         eprint("parsing configuration file failed, no screen section found\n");
 154
 155     /* get colors and general section */
 156     if(cfg_menu)
 157         cfg_menu_colors = cfg_getsec(cfg_menu, "colors");
 158     cfg_general = cfg_getsec(cfg_screen, "general");
 159     cfg_colors = cfg_getsec(cfg_screen, "colors");
 160
 161     /* colors */
 162     if(!cfg_menu_colors || !(opt = cfg_getstr(cfg_menu_colors, "normal_fg")))
 163        opt = cfg_getstr(cfg_colors, "normal_fg");
 164
 165     draw_color_new(globalconf.display, DefaultScreen(globalconf.display),
 166                    opt, &globalconf.fg);
 167
 168     if(!cfg_menu_colors || !(opt = cfg_getstr(cfg_menu_colors, "normal_bg")))
 169        opt = cfg_getstr(cfg_colors, "normal_bg");
 170
 171     draw_color_new(globalconf.display, DefaultScreen(globalconf.display),
 172                    opt, &globalconf.bg);
 173
 174     if(!cfg_menu_colors || !(opt = cfg_getstr(cfg_menu_colors, "focus_fg")))
 175        opt = cfg_getstr(cfg_colors, "focus_fg");
 176
 177     draw_color_new(globalconf.display, DefaultScreen(globalconf.display),
 178                    opt, &globalconf.fg_focus);
 179
 180     if(!cfg_menu_colors || !(opt = cfg_getstr(cfg_menu_colors, "focus_bg")))
 181        opt = cfg_getstr(cfg_colors, "focus_bg");
 182
 183     draw_color_new(globalconf.display, DefaultScreen(globalconf.display),
 184                    opt, &globalconf.bg_focus);
 185
 186     /* font */
 187     if(!cfg_menu || !(opt = cfg_getstr(cfg_menu, "font")))
 188         opt = cfg_getstr(cfg_general, "font");
 189
 190     globalconf.font = XftFontOpenName(globalconf.display, DefaultScreen(globalconf.display),
 191                                       opt);
 192
 193     globalconf.shadow_offset = cfg_getint(cfg_general, "text_shadow_offset");
 194
 195     if(cfg_menu)
 196     {
 197         if((i = cfg_getint(cfg_menu, "x")) != (int) 0xffffffff)
 198            geometry->x = i;
 199         if((i = cfg_getint(cfg_menu, "y")) != (int) 0xffffffff)
 200            geometry->y = i;
 201         if((i = cfg_getint(cfg_menu, "width")) > 0)
 202            geometry->width = i;
 203         if((i = cfg_getint(cfg_menu, "height")) > 0)
 204            geometry->height = i;
 205     }
 206
 207     p_delete(&confpath);
 208
 209     return ret;
 210 }
 211
 212 static char *
 213 get_last_word(char *text)
 214 {
 215     char *last_word;
 216
 217     if((last_word = strrchr(text, ' ')))
 218         last_word++;
 219     else
 220         last_word = text;
 221
 222     return last_word;
 223 }
 224
 225 static Bool
 226 item_list_fill_file(const char *directory)
 227 {
 228     char cwd[PATH_MAX], *home, *user, *filename;
 229     const char *file;
 230     DIR *dir;
 231     struct dirent *dirinfo;
 232     item_t *item;
 233     ssize_t len, lenfile;
 234     struct passwd *passwd = NULL;
 235     struct stat st;
 236
 237     item_list_wipe(&globalconf.items);
 238
 239     if(!directory)
 240         a_strcpy(cwd, sizeof(cwd), "./");
 241     else if(a_strlen(directory) > 1 && directory[0] == '~')
 242     {
 243         if(directory[1] == '/')
 244         {
 245             if((home = getenv("HOME")))
 246                 a_strcpy(cwd, sizeof(cwd), home);
 247             a_strcat(cwd, sizeof(cwd), directory + 1);
 248         }
 249         else
 250         {
 251             if(!(file = strchr(directory, '/')))
 252                 file = directory + a_strlen(directory);
 253             len = (file - directory) + 1;
 254             user = p_new(char, len);
 255             a_strncpy(user, len, directory + 1, (file - directory) - 1);
 256             if((passwd = getpwnam(user)))
 257             {
 258                 a_strcpy(cwd, sizeof(cwd), passwd->pw_dir);
 259                 a_strcat(cwd, sizeof(cwd), file);
 260                 p_delete(&user);
 261             }
 262             else
 263             {
 264                 p_delete(&user);
 265                 return False;
 266             }
 267         }
 268     }
 269     else
 270         a_strcpy(cwd, sizeof(cwd), directory);
 271
 272     if(!(dir = opendir(cwd)))
 273         return False;
 274
 275     while((dirinfo = readdir(dir)))
 276     {
 277         item = p_new(item_t, 1);
 278
 279         /* + 1 for \0 + 1 for / if directory */
 280         len = a_strlen(directory) + a_strlen(dirinfo->d_name) + 2;
 281
 282         item->data = p_new(char, len);
 283         if(a_strlen(directory))
 284             a_strcpy(item->data, len, directory);
 285         a_strcat(item->data, len, dirinfo->d_name);
 286
 287         lenfile = a_strlen(cwd) + a_strlen(dirinfo->d_name) + 2;
 288
 289         filename = p_new(char, lenfile);
 290         a_strcpy(filename, lenfile, cwd);
 291         a_strcat(filename, lenfile, dirinfo->d_name);
 292
 293         if(!stat(filename, &st) && S_ISDIR(st.st_mode))
 294             a_strcat(item->data, len, "/");
 295
 296         p_delete(&filename);
 297
 298         item_list_push(&globalconf.items, item);
 299     }
 300
 301     closedir(dir);
 302
 303     return True;
 304 }
 305
 306 static void
 307 complete(Bool reverse)
 308 {
 309     char *word;
 310     int loop = 2;
 311     item_t *item = NULL;
 312     item_t *(*item_iter)(item_t **, item_t *) = item_list_next_cycle;
 313
 314     if(reverse)
 315         item_iter = item_list_prev_cycle;
 316
 317     if(globalconf.item_selected)
 318         item = item_iter(&globalconf.items, globalconf.item_selected);
 319     else
 320         item = globalconf.items;
 321
 322     for(; item && loop; item = item_iter(&globalconf.items, item))
 323     {
 324         if(item->match)
 325         {
 326             word = get_last_word(globalconf.text);
 327             a_strcpy(word, sizeof(globalconf.text) - (word - globalconf.text), item->data);
 328             globalconf.item_selected = item;
 329             return;
 330         }
 331         /*
 332          * Since loop is 2, it will be 1 at first iter, and then 0 if we
 333          * get back before matching an item (i.e. no items match) to the
 334          * first elem: so it will break the loop, otherwise it loops for
 335          * ever
 336          */
 337         if(item == globalconf.items)
 338             loop--;
 339     }
 340 }
 341
 342 static void
 343 compute_match(const char *word)
 344 {
 345     ssize_t len = a_strlen(word);
 346     item_t *item;
 347
 348     /* reset the selected item to NULL */
 349     globalconf.item_selected = NULL;
 350
 351     if(len)
 352     {
 353         if(word[len - 1] == '/'
 354            || word[len - 1] == ' ')
 355             item_list_fill_file(word);
 356
 357         for(item = globalconf.items; item; item = item->next)
 358             if(!a_strncmp(word, item->data, a_strlen(word)))
 359                 item->match = True;
 360             else
 361                 item->match = False;
 362     }
 363     else
 364     {
 365         if(a_strlen(globalconf.text))
 366             item_list_fill_file(NULL);
 367         for(item = globalconf.items; item; item = item->next)
 368             item->match = True;
 369     }
 370 }
 371
 372 /* Why not? */
 373 #define MARGIN 10
 374
 375 static void
 376 draw_item(item_t *item, Area geometry)
 377 {
 378     if(item == globalconf.item_selected)
 379         draw_text(globalconf.ctx, geometry, AlignLeft,
 380                   MARGIN / 2, globalconf.font, item->data,
 381                   globalconf.shadow_offset,
 382                   globalconf.fg_focus, globalconf.bg_focus);
 383     else
 384         draw_text(globalconf.ctx, geometry, AlignLeft,
 385                   MARGIN / 2, globalconf.font, item->data,
 386                   globalconf.shadow_offset,
 387                   globalconf.fg, globalconf.bg);
 388 }
 389
 390 static void
 391 redraw(void)
 392 {
 393     item_t *item;
 394     Area geometry = { 0, 0, 0, 0, NULL, NULL };
 395     Bool selected_item_is_drawn = False;
 396     int len, prompt_len, x_of_previous_item;
 397
 398     geometry.width = globalconf.sw->geometry.width;
 399     geometry.height = globalconf.sw->geometry.height;
 400
 401     if(a_strlen(globalconf.prompt))
 402     {
 403         draw_text(globalconf.ctx, geometry, AlignLeft,
 404                   MARGIN, globalconf.font, globalconf.prompt,
 405                   globalconf.shadow_offset,
 406                   globalconf.fg_focus, globalconf.bg_focus);
 407
 408         len = MARGIN * 2 + draw_textwidth(globalconf.display, globalconf.font, globalconf.prompt);
 409         geometry.x += len;
 410         geometry.width -= len;
 411     }
 412
 413     draw_text(globalconf.ctx, geometry, AlignLeft,
 414               MARGIN, globalconf.font, globalconf.text,
 415               globalconf.shadow_offset,
 416               globalconf.fg, globalconf.bg);
 417
 418     len = MARGIN * 2 + MAX(draw_textwidth(globalconf.display, globalconf.font, globalconf.text),
 419                            geometry.width / 20);
 420     geometry.x += len;
 421     geometry.width -= len;
 422     prompt_len = geometry.x;
 423
 424     for(item = globalconf.items; item && geometry.width > 0; item = item->next)
 425         if(item->match)
 426         {
 427             len = MARGIN + draw_textwidth(globalconf.display, globalconf.font, item->data);
 428             if(item == globalconf.item_selected)
 429             {
 430                 if(len > geometry.width)
 431                     break;
 432                 else
 433                     selected_item_is_drawn = True;
 434             }
 435             draw_item(item, geometry);
 436             geometry.x += len;
 437             geometry.width -= len;
 438         }
 439
 440     /* we have an item selected but not drawn, so redraw in the other side */
 441     if(globalconf.item_selected && !selected_item_is_drawn)
 442     {
 443         geometry.x = globalconf.sw->geometry.width;
 444
 445         for(item = globalconf.item_selected; item; item = item_list_prev(&globalconf.items, item))
 446             if(item->match)
 447             {
 448                 x_of_previous_item = geometry.x;
 449                 geometry.width = MARGIN + draw_textwidth(globalconf.display, globalconf.font, item->data);
 450                 geometry.x -= geometry.width;
 451
 452                 if(geometry.x < prompt_len)
 453                     break;
 454
 455                 draw_item(item, geometry);
 456             }
 457
 458         if(item)
 459         {
 460             geometry.x = prompt_len;
 461             geometry.width = x_of_previous_item - prompt_len;
 462             draw_rectangle(globalconf.ctx, geometry, True, globalconf.bg);
 463         }
 464     }
 465     else if(geometry.width)
 466         draw_rectangle(globalconf.ctx, geometry, True, globalconf.bg);
 467
 468     simplewindow_refresh_drawable(globalconf.sw, DefaultScreen(globalconf.display));
 469     XSync(globalconf.display, False);
 470 }
 471
 472 static void
 473 handle_kpress(XKeyEvent *e)
 474 {
 475     char buf[32];
 476     KeySym ksym;
 477     int num;
 478     ssize_t len;
 479
 480     len = a_strlen(globalconf.text);
 481     num = XLookupString(e, buf, sizeof(buf), &ksym, 0);
 482     if(e->state & ControlMask)
 483         switch(ksym)
 484         {
 485           default:
 486             return;
 487           case XK_bracketleft:
 488             ksym = XK_Escape;
 489             break;
 490           case XK_h:
 491           case XK_H:
 492             ksym = XK_BackSpace;
 493             break;
 494           case XK_i:
 495           case XK_I:
 496             ksym = XK_Tab;
 497             break;
 498           case XK_j:
 499           case XK_J:
 500             ksym = XK_Return;
 501             break;
 502           case XK_c:
 503           case XK_C:
 504             status = CANCEL;
 505             break;
 506           case XK_w:
 507           case XK_W:
 508             /* erase word */
 509             if(len)
 510             {
 511                 int i = len - 1;
 512                 while(i >= 0 && globalconf.text[i] == ' ')
 513                     globalconf.text[i--] = '\0';
 514                 while(i >= 0 && globalconf.text[i] != ' ')
 515                     globalconf.text[i--] = '\0';
 516                 compute_match(get_last_word(globalconf.text));
 517                 redraw();
 518             }
 519             return;
 520         }
 521     else if(CLEANMASK(e->state) & Mod1Mask)
 522         switch(ksym)
 523         {
 524           default:
 525             return;
 526           case XK_h:
 527             ksym = XK_Left;
 528             break;
 529           case XK_l:
 530             ksym = XK_Right;
 531             break;
 532         }
 533
 534     switch(ksym)
 535     {
 536       default:
 537         if(num && !iscntrl((int) buf[0]))
 538         {
 539             if(buf[0] != '/' || globalconf.text[len - 1] != '/')
 540             {
 541                 buf[num] = '\0';
 542                 a_strncat(globalconf.text, sizeof(globalconf.text), buf, num);
 543             }
 544             compute_match(get_last_word(globalconf.text));
 545             redraw();
 546         }
 547         break;
 548       case XK_BackSpace:
 549         if(len)
 550         {
 551             globalconf.text[--len] = '\0';
 552             compute_match(get_last_word(globalconf.text));
 553             redraw();
 554         }
 555         break;
 556       case XK_ISO_Left_Tab:
 557       case XK_Left:
 558         complete(True);
 559         redraw();
 560         break;
 561       case XK_Right:
 562       case XK_Tab:
 563         complete(False);
 564         redraw();
 565         break;
 566       case XK_Escape:
 567         status= CANCEL;
 568         break;
 569       case XK_Return:
 570         status = STOP;
 571         break;
 572     }
 573 }
 574
 575 static Bool
 576 item_list_fill_stdin(void)
 577 {
 578     char buf[PATH_MAX];
 579     item_t *newitem;
 580     Bool has_entry = False;
 581
 582     item_list_init(&globalconf.items);
 583
 584     if(fgets(buf, sizeof(buf), stdin))
 585         has_entry = True;
 586
 587     if(has_entry)
 588         do
 589         {
 590             buf[a_strlen(buf) - 1] = '\0';
 591             newitem = p_new(item_t, 1);
 592             newitem->data = a_strdup(buf);
 593             newitem->match = True;
 594             item_list_append(&globalconf.items, newitem);
 595         }
 596         while(fgets(buf, sizeof(buf), stdin));
 597
 598     return has_entry;
 599 }
 600
 601 int
 602 main(int argc, char **argv)
 603 {
 604     Display *disp;
 605     XEvent ev;
 606     int opt, ret;
 607     char *configfile = NULL, *cmd;
 608     ssize_t len;
 609     const char *shell = getenv("SHELL");
 610     Area geometry = { 0, 0, 0, 0, NULL, NULL };
 611     static struct option long_options[] =
 612     {
 613         {"help",    0, NULL, 'h'},
 614         {"version", 0, NULL, 'v'},
 615         {"exec",    0, NULL, 'e'},
 616         {NULL,      0, NULL, 0}
 617     };
 618
 619     if(!(disp = XOpenDisplay(NULL)))
 620         eprint("unable to open display");
 621
 622     globalconf.display = disp;
 623
 624     while((opt = getopt_long(argc, argv, "vhf:b:x:y:n:c:e:",
 625                              long_options, NULL)) != -1)
 626         switch(opt)
 627         {
 628           case 'v':
 629             eprint_version(PROGNAME);
 630             break;
 631           case 'h':
 632             exit_help(EXIT_SUCCESS);
 633             break;
 634           case 'c':
 635             configfile = a_strdup(optarg);
 636             break;
 637           case 'e':
 638             globalconf.exec = a_strdup(optarg);
 639             break;
 640         }
 641
 642     if(argc - optind >= 1)
 643         globalconf.prompt = a_strdup(argv[optind]);
 644
 645     if((ret = config_parse(configfile, globalconf.prompt, &geometry)))
 646         return ret;
 647
 648     /* Get the numlock mask */
 649     globalconf.numlockmask = get_numlockmask(disp);
 650
 651     /* Init the geometry */
 652     if(!geometry.height)
 653         geometry.height = globalconf.font->height * 1.5;
 654
 655     /* XXX this must be replace with a common/ infra */
 656     if(XineramaIsActive(disp))
 657     {
 658         XineramaScreenInfo *si;
 659         int xinerama_screen_number, i, x, y;
 660         unsigned int ui;
 661         Window dummy;
 662
 663         XQueryPointer(disp, RootWindow(disp, DefaultScreen(disp)),
 664                       &dummy, &dummy, &x, &y, &i, &i, &ui);
 665
 666         si = XineramaQueryScreens(disp, &xinerama_screen_number);
 667
 668         /* XXX use screen_get_bycoord() !!! */
 669         for(i = 0; i < xinerama_screen_number; i++)
 670             if((x < 0 || (x >= si[i].x_org && x < si[i].x_org + si[i].width))
 671                && (y < 0 || (y >= si[i].y_org && y < si[i].y_org + si[i].height)))
 672                 break;
 673
 674         if(!geometry.x)
 675             geometry.x = si[i].x_org;
 676         if(!geometry.y)
 677             geometry.y = si[i].y_org;
 678         if(!geometry.width)
 679             geometry.width = si[i].width;
 680
 681         XFree(si);
 682     }
 683     else if(!geometry.width)
 684         geometry.width = DisplayWidth(disp, DefaultScreen(disp));
 685
 686     /* Create the window */
 687     globalconf.sw = simplewindow_new(disp, DefaultScreen(disp),
 688                                      geometry.x, geometry.y, geometry.width, geometry.height, 0);
 689
 690     XStoreName(disp, globalconf.sw->window, PROGNAME);
 691     XMapRaised(disp, globalconf.sw->window);
 692
 693     /* Create the drawing context */
 694     globalconf.ctx = draw_context_new(disp, DefaultScreen(disp),
 695                                       geometry.width, geometry.height,
 696                                       globalconf.sw->drawable);
 697
 698
 699     if(!item_list_fill_stdin())
 700         item_list_fill_file(NULL);
 701
 702     compute_match(NULL);
 703
 704     for(opt = 1000; opt; opt--)
 705     {
 706         if(XGrabKeyboard(disp, DefaultRootWindow(disp), True,
 707                          GrabModeAsync, GrabModeAsync, CurrentTime) == GrabSuccess)
 708             break;
 709         usleep(1000);
 710     }
 711     if(!opt)
 712         eprint("cannot grab keyboard");
 713
 714     redraw();
 715
 716     while(status == RUN)
 717     {
 718         XNextEvent(disp, &ev);
 719         switch(ev.type)
 720         {
 721           case ButtonPress:
 722             status = CANCEL;
 723             break;
 724           case KeyPress:
 725             handle_kpress(&ev.xkey);
 726             break;
 727           case Expose:
 728             if(!ev.xexpose.count)
 729                 simplewindow_refresh_drawable(globalconf.sw, DefaultScreen(disp));
 730             break;
 731           default:
 732             break;
 733         }
 734     }
 735
 736     if(status != CANCEL)
 737     {
 738         if(!globalconf.exec)
 739             printf("%s\n", globalconf.text);
 740         else
 741         {
 742             if(!shell)
 743                 shell = a_strdup("/bin/sh");
 744             len = a_strlen(globalconf.exec) + a_strlen(globalconf.text) + 1;
 745             cmd = p_new(char, len);
 746             a_strcpy(cmd, len, globalconf.exec);
 747             a_strcat(cmd, len, globalconf.text);
 748             execl(shell, shell, "-c", cmd, NULL);
 749         }
 750     }
 751
 752     draw_context_delete(globalconf.ctx);
 753     simplewindow_delete(globalconf.sw);
 754     XCloseDisplay(disp);
 755
 756     return EXIT_SUCCESS;
 757 }
 758
 759 // vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=80