Dogcows Code - chaz/openbox/blob - openbox/menuframe.c

   1 #include "menuframe.h"
   2 #include "client.h"
   3 #include "menu.h"
   4 #include "screen.h"
   5 #include "grab.h"
   6 #include "openbox.h"
   7 #include "render/theme.h"
   8
   9 #define SEPARATOR_HEIGHT 5
  10
  11 #define FRAME_EVENTMASK (ButtonPressMask |ButtonMotionMask | EnterWindowMask |\
  12                          LeaveWindowMask)
  13 #define TITLE_EVENTMASK (ButtonPressMask | ButtonMotionMask)
  14 #define ENTRY_EVENTMASK (EnterWindowMask | LeaveWindowMask | \
  15                          ButtonPressMask | ButtonReleaseMask)
  16
  17 GList *menu_frame_visible;
  18
  19 static void menu_frame_render(ObMenuFrame *self);
  20 static void menu_frame_update(ObMenuFrame *self);
  21
  22 static Window createWindow(Window parent, unsigned long mask,
  23                            XSetWindowAttributes *attrib)
  24 {
  25     return XCreateWindow(ob_display, parent, 0, 0, 1, 1, 0,
  26                          RrDepth(ob_rr_inst), InputOutput,
  27                          RrVisual(ob_rr_inst), mask, attrib);
  28
  29 }
  30
  31 ObMenuFrame* menu_frame_new(ObMenu *menu, ObClient *client)
  32 {
  33     ObMenuFrame *self;
  34     XSetWindowAttributes attr;
  35
  36     self = g_new0(ObMenuFrame, 1);
  37     self->type = Window_Menu;
  38     self->menu = menu;
  39     self->selected = NULL;
  40     self->client = client;
  41
  42     attr.event_mask = FRAME_EVENTMASK;
  43     self->window = createWindow(RootWindow(ob_display, ob_screen),
  44                                    CWEventMask, &attr);
  45     attr.event_mask = TITLE_EVENTMASK;
  46     self->title = createWindow(self->window, CWEventMask, &attr);
  47     self->items = createWindow(self->window, 0, NULL);
  48
  49     XMapWindow(ob_display, self->items);
  50
  51     self->a_title = RrAppearanceCopy(ob_rr_theme->a_menu_title);
  52     self->a_items = RrAppearanceCopy(ob_rr_theme->a_menu);
  53
  54     return self;
  55 }
  56
  57 void menu_frame_free(ObMenuFrame *self)
  58 {
  59     if (self) {
  60         XDestroyWindow(ob_display, self->items);
  61         XDestroyWindow(ob_display, self->title);
  62         XDestroyWindow(ob_display, self->window);
  63
  64         RrAppearanceFree(self->a_items);
  65         RrAppearanceFree(self->a_title);
  66
  67         g_free(self);
  68     }
  69 }
  70
  71 ObMenuEntryFrame* menu_entry_frame_new(ObMenuEntry *entry, ObMenuFrame *frame)
  72 {
  73     ObMenuEntryFrame *self;
  74     XSetWindowAttributes attr;
  75
  76     self = g_new0(ObMenuEntryFrame, 1);
  77     self->entry = entry;
  78     self->frame = frame;
  79
  80     attr.event_mask = ENTRY_EVENTMASK;
  81     self->window = createWindow(self->frame->items, CWEventMask, &attr);
  82     self->icon = createWindow(self->window, 0, NULL);
  83     self->text = createWindow(self->window, 0, NULL);
  84     self->bullet = createWindow(self->window, 0, NULL);
  85
  86     XMapWindow(ob_display, self->window);
  87     XMapWindow(ob_display, self->text);
  88
  89     self->a_normal = RrAppearanceCopy(ob_rr_theme->a_menu_item);
  90     self->a_disabled = RrAppearanceCopy(ob_rr_theme->a_menu_disabled);
  91     self->a_selected = RrAppearanceCopy(ob_rr_theme->a_menu_hilite);
  92
  93     self->a_icon = RrAppearanceCopy(ob_rr_theme->a_clear_tex);
  94     self->a_icon->texture[0].type = RR_TEXTURE_RGBA;
  95     self->a_bullet = RrAppearanceCopy(ob_rr_theme->a_menu_bullet);
  96     self->a_bullet->texture[0].type = RR_TEXTURE_MASK;
  97
  98     self->a_text_normal =
  99         RrAppearanceCopy(ob_rr_theme->a_menu_text_item);
 100     self->a_text_disabled =
 101         RrAppearanceCopy(ob_rr_theme->a_menu_text_disabled);
 102     self->a_text_selected =
 103         RrAppearanceCopy(ob_rr_theme->a_menu_text_hilite);
 104
 105     return self;
 106 }
 107
 108 void menu_entry_frame_free(ObMenuEntryFrame *self)
 109 {
 110     if (self) {
 111         XDestroyWindow(ob_display, self->icon);
 112         XDestroyWindow(ob_display, self->text);
 113         XDestroyWindow(ob_display, self->bullet);
 114         XDestroyWindow(ob_display, self->window);
 115
 116         RrAppearanceFree(self->a_normal);
 117         RrAppearanceFree(self->a_disabled);
 118         RrAppearanceFree(self->a_selected);
 119
 120         RrAppearanceFree(self->a_icon);
 121         RrAppearanceFree(self->a_text_normal);
 122         RrAppearanceFree(self->a_text_disabled);
 123         RrAppearanceFree(self->a_text_selected);
 124         RrAppearanceFree(self->a_bullet);
 125
 126         g_free(self);
 127     }
 128 }
 129
 130 void menu_frame_move(ObMenuFrame *self, gint x, gint y)
 131 {
 132     /* XXX screen constraints */
 133     RECT_SET_POINT(self->area, x, y);
 134     XMoveWindow(ob_display, self->window, self->area.x, self->area.y);
 135 }
 136
 137 void menu_frame_move_on_screen(ObMenuFrame *self)
 138 {
 139     Rect *a;
 140     guint i;
 141     gint dx = 0, dy = 0;
 142
 143     for (i = 0; i < screen_num_monitors; ++i) {
 144         a = screen_physical_area_monitor(i);
 145         if (RECT_INTERSECTS_RECT(*a, self->area))
 146             break;
 147     }
 148     if (a) a = screen_physical_area_monitor(0);
 149
 150     dx = MIN(0, (a->x + a->width) - (self->area.x + self->area.width));
 151     dy = MIN(0, (a->y + a->height) - (self->area.y + self->area.height));
 152     if (!dx) dx = MAX(0, a->x - self->area.x);
 153     if (!dy) dy = MAX(0, a->y - self->area.y);
 154
 155     if (dx || dy) {
 156         ObMenuFrame *f;
 157
 158         for (f = self; f; f = f->parent)
 159             menu_frame_move(f, f->area.x + dx, f->area.y + dy);
 160         XWarpPointer(ob_display, None, None, 0, 0, 0, 0, dx, dy);
 161     }
 162 }
 163
 164 static void menu_entry_frame_render(ObMenuEntryFrame *self)
 165 {
 166     RrAppearance *item_a, *text_a;
 167     gint th; /* temp */
 168
 169     item_a = (!self->entry->enabled ?
 170               self->a_disabled :
 171               (self == self->frame->selected ?
 172                self->a_selected :
 173                self->a_normal));
 174     switch (self->entry->type) {
 175     case OB_MENU_ENTRY_TYPE_NORMAL:
 176     case OB_MENU_ENTRY_TYPE_SUBMENU:
 177         th = self->frame->item_h;
 178         break;
 179     case OB_MENU_ENTRY_TYPE_SEPARATOR:
 180         th = SEPARATOR_HEIGHT;
 181         break;
 182     }
 183     RECT_SET_SIZE(self->area, self->frame->inner_w, th);
 184     XResizeWindow(ob_display, self->window,
 185                   self->area.width, self->area.height);
 186     item_a->surface.parent = self->frame->a_items;
 187     item_a->surface.parentx = self->area.x;
 188     item_a->surface.parenty = self->area.y;
 189     RrPaint(item_a, self->window, self->area.width, self->area.height);
 190
 191     text_a = (!self->entry->enabled ?
 192               self->a_text_disabled :
 193               (self == self->frame->selected ?
 194                self->a_text_selected :
 195                self->a_text_normal));
 196     switch (self->entry->type) {
 197     case OB_MENU_ENTRY_TYPE_NORMAL:
 198         text_a->texture[0].data.text.string = self->entry->data.normal.label;
 199         break;
 200     case OB_MENU_ENTRY_TYPE_SUBMENU:
 201         text_a->texture[0].data.text.string =
 202             self->entry->data.submenu.submenu->title;
 203         break;
 204     case OB_MENU_ENTRY_TYPE_SEPARATOR:
 205         break;
 206     }
 207
 208     switch (self->entry->type) {
 209     case OB_MENU_ENTRY_TYPE_NORMAL:
 210     case OB_MENU_ENTRY_TYPE_SUBMENU:
 211         XMoveResizeWindow(ob_display, self->text,
 212                           self->frame->text_x, 0,
 213                           self->frame->text_w, self->frame->item_h);
 214         text_a->surface.parent = item_a;
 215         text_a->surface.parentx = self->frame->text_x;
 216         text_a->surface.parenty = 0;
 217         RrPaint(text_a, self->text, self->frame->text_w, self->frame->item_h);
 218         XMapWindow(ob_display, self->text);
 219         break;
 220     case OB_MENU_ENTRY_TYPE_SEPARATOR:
 221         XUnmapWindow(ob_display, self->text);
 222         break;
 223     }
 224
 225     /* XXX draw icons */
 226     if (0) {
 227         XMoveResizeWindow(ob_display, self->icon, 0, 0,
 228                           self->frame->item_h, self->frame->item_h);
 229         /* XXX set the RGBA surface stuff */
 230         self->a_icon->surface.parent = item_a;
 231         self->a_icon->surface.parentx = 0;
 232         self->a_icon->surface.parenty = 0;
 233         RrPaint(self->a_icon, self->icon,
 234                 self->frame->item_h, self->frame->item_h);
 235         XMapWindow(ob_display, self->icon);
 236     } else
 237         XUnmapWindow(ob_display, self->icon);
 238
 239     if (self->entry->type == OB_MENU_ENTRY_TYPE_SUBMENU) {
 240         XMoveResizeWindow(ob_display, self->bullet,
 241                           self->frame->text_x + self->frame->text_w, 0,
 242                           self->frame->item_h, self->frame->item_h);
 243         self->a_bullet->surface.parent = item_a;
 244         self->a_bullet->surface.parentx =
 245             self->frame->text_x + self->frame->text_w;
 246         self->a_bullet->surface.parenty = 0;
 247         RrPaint(self->a_bullet, self->bullet,
 248                 self->frame->item_h, self->frame->item_h);
 249         XMapWindow(ob_display, self->bullet);
 250     } else
 251         XUnmapWindow(ob_display, self->bullet);
 252 }
 253
 254 static void menu_frame_render(ObMenuFrame *self)
 255 {
 256     gint w = 0, h = 0;
 257     gint allitems_h = 0;
 258     gint tw, th; /* temps */
 259     GList *it;
 260     gboolean has_icon = FALSE, has_bullet = FALSE;
 261
 262     XSetWindowBorderWidth(ob_display, self->window, ob_rr_theme->bwidth);
 263     XSetWindowBorder(ob_display, self->window,
 264                      RrColorPixel(ob_rr_theme->b_color));
 265
 266     if (!self->parent && self->menu->title) {
 267         XMoveWindow(ob_display, self->title,
 268                     -ob_rr_theme->bwidth, h - ob_rr_theme->bwidth);
 269
 270         self->a_title->texture[0].data.text.string = self->menu->title;
 271         RrMinsize(self->a_title, &tw, &th);
 272         w = MAX(w, tw);
 273         h += (self->title_h = th + ob_rr_theme->bwidth);
 274
 275         XSetWindowBorderWidth(ob_display, self->title, ob_rr_theme->bwidth);
 276         XSetWindowBorder(ob_display, self->title,
 277                          RrColorPixel(ob_rr_theme->b_color));
 278     }
 279
 280     XMoveWindow(ob_display, self->items, 0, h);
 281
 282     if (self->entries) {
 283         ObMenuEntryFrame *e = self->entries->data;
 284         e->a_text_normal->texture[0].data.text.string = "";
 285         RrMinsize(e->a_text_normal, &tw, &th);
 286         self->item_h = th;
 287     } else
 288         self->item_h = 0;
 289
 290     for (it = self->entries; it; it = g_list_next(it)) {
 291         RrAppearance *text_a;
 292         ObMenuEntryFrame *e = it->data;
 293
 294         RECT_SET_POINT(e->area, 0, allitems_h);
 295         XMoveWindow(ob_display, e->window, 0, e->area.y);
 296
 297         text_a = (!e->entry->enabled ?
 298                   e->a_text_disabled :
 299                   (e == self->selected ?
 300                    e->a_text_selected :
 301                    e->a_text_normal));
 302         switch (e->entry->type) {
 303         case OB_MENU_ENTRY_TYPE_NORMAL:
 304             text_a->texture[0].data.text.string = e->entry->data.normal.label;
 305             RrMinsize(text_a, &tw, &th);
 306
 307             /* XXX has_icon = TRUE; */
 308             break;
 309         case OB_MENU_ENTRY_TYPE_SUBMENU:
 310             text_a->texture[0].data.text.string =
 311                 e->entry->data.submenu.submenu->title;
 312             RrMinsize(text_a, &tw, &th);
 313
 314             has_bullet = TRUE;
 315             break;
 316         case OB_MENU_ENTRY_TYPE_SEPARATOR:
 317             tw = 0;
 318             th = SEPARATOR_HEIGHT;
 319             break;
 320         }
 321         w = MAX(w, tw);
 322         h += th;
 323         allitems_h += th;
 324     }
 325
 326     self->text_x = 0;
 327     self->text_w = w;
 328
 329     if (self->entries) {
 330         if (has_bullet)
 331             w += self->item_h;
 332         if (has_icon) {
 333             w += self->item_h;
 334             self->text_x += self->item_h;
 335         }
 336     }
 337
 338     if (!w) w = 10;
 339     if (!allitems_h) allitems_h = 3;
 340     if (!h) h = 3;
 341
 342     XResizeWindow(ob_display, self->window, w, h);
 343     XResizeWindow(ob_display, self->items, w, allitems_h);
 344
 345     self->inner_w = w;
 346
 347     if (!self->parent && self->title) {
 348         XResizeWindow(ob_display, self->title,
 349                       w, self->title_h - ob_rr_theme->bwidth);
 350         RrPaint(self->a_title, self->title,
 351                 w, self->title_h - ob_rr_theme->bwidth);
 352         XMapWindow(ob_display, self->title);
 353     } else
 354         XUnmapWindow(ob_display, self->title);
 355
 356     RrPaint(self->a_items, self->items, w, allitems_h);
 357
 358     for (it = self->entries; it; it = g_list_next(it))
 359         menu_entry_frame_render(it->data);
 360
 361     w += ob_rr_theme->bwidth * 2;
 362     h += ob_rr_theme->bwidth * 2;
 363
 364     RECT_SET_SIZE(self->area, w, h);
 365 }
 366
 367 static void menu_frame_update(ObMenuFrame *self)
 368 {
 369     GList *mit, *fit;
 370
 371     self->selected = NULL;
 372
 373     for (mit = self->menu->entries, fit = self->entries; mit && fit;
 374          mit = g_list_next(mit), fit = g_list_next(fit))
 375     {
 376         ObMenuEntryFrame *f = fit->data;
 377         f->entry = mit->data;
 378     }
 379
 380     while (mit) {
 381         ObMenuEntryFrame *e = menu_entry_frame_new(mit->data, self);
 382         self->entries = g_list_append(self->entries, e);
 383         mit = g_list_next(mit);
 384     }
 385
 386     while (fit) {
 387         GList *n = g_list_next(fit);
 388         menu_entry_frame_free(fit->data);
 389         self->entries = g_list_delete_link(self->entries, fit);
 390         fit = n;
 391     }
 392
 393     menu_frame_render(self);
 394 }
 395
 396 void menu_frame_show(ObMenuFrame *self, ObMenuFrame *parent)
 397 {
 398     if (parent) {
 399         if (parent->child)
 400             menu_frame_hide(parent->child);
 401         parent->child = self;
 402     }
 403     self->parent = parent;
 404
 405     if (menu_frame_visible == NULL) {
 406         /* no menus shown yet */
 407         grab_pointer(TRUE, None);
 408         grab_keyboard(TRUE);
 409     }
 410
 411     if (!g_list_find(menu_frame_visible, self)) {
 412         menu_frame_visible = g_list_prepend(menu_frame_visible, self);
 413
 414         menu_frame_update(self);
 415     }
 416
 417     menu_frame_move_on_screen(self);
 418
 419     XMapWindow(ob_display, self->window);
 420 }
 421
 422 void menu_frame_hide(ObMenuFrame *self)
 423 {
 424     menu_frame_visible = g_list_remove(menu_frame_visible, self);
 425
 426     if (self->child)
 427         menu_frame_hide(self->child);
 428
 429     if (self->parent)
 430         self->parent->child = NULL;
 431     self->parent = NULL;
 432
 433     if (menu_frame_visible == NULL) {
 434         /* last menu shown */
 435         grab_pointer(FALSE, None);
 436         grab_keyboard(FALSE);
 437     }
 438
 439     XUnmapWindow(ob_display, self->window);
 440
 441     menu_frame_free(self);
 442 }
 443
 444 void menu_frame_hide_all()
 445 {
 446     while (menu_frame_visible)
 447         menu_frame_hide(menu_frame_visible->data);
 448 }
 449
 450 ObMenuFrame* menu_frame_under(gint x, gint y)
 451 {
 452     ObMenuFrame *ret = NULL;
 453     GList *it;
 454
 455     for (it = menu_frame_visible; it; it = g_list_next(it)) {
 456         ObMenuFrame *f = it->data;
 457
 458         if (RECT_CONTAINS(f->area, x, y)) {
 459             ret = f;
 460             break;
 461         }
 462     }
 463     return ret;
 464 }
 465
 466 ObMenuEntryFrame* menu_entry_frame_under(gint x, gint y)
 467 {
 468     ObMenuFrame *frame;
 469     ObMenuEntryFrame *ret = NULL;
 470     GList *it;
 471
 472     if ((frame = menu_frame_under(x, y))) {
 473         x -= ob_rr_theme->bwidth + frame->area.x;
 474         y -= frame->title_h + ob_rr_theme->bwidth + frame->area.y;
 475
 476         for (it = frame->entries; it; it = g_list_next(it)) {
 477             ObMenuEntryFrame *e = it->data;
 478
 479             if (RECT_CONTAINS(e->area, x, y)) {
 480                 ret = e;
 481                 break;
 482             }
 483         }
 484     }
 485     return ret;
 486 }
 487
 488 void menu_frame_select(ObMenuFrame *self, ObMenuEntryFrame *entry)
 489 {
 490     ObMenuEntryFrame *old = self->selected;
 491
 492     if (old == entry) return;
 493
 494     if (entry && entry->entry->type != OB_MENU_ENTRY_TYPE_SEPARATOR)
 495         self->selected = entry;
 496     else
 497         self->selected = NULL;
 498
 499     if (old) {
 500         menu_entry_frame_render(old);
 501         if (old->entry->type == OB_MENU_ENTRY_TYPE_SUBMENU)
 502             menu_frame_hide(self->child);
 503     }
 504     if (self->selected) {
 505         menu_entry_frame_render(self->selected);
 506
 507         if (self->selected->entry->type == OB_MENU_ENTRY_TYPE_SUBMENU)
 508             menu_entry_frame_show_submenu(self->selected);
 509     }
 510 }
 511
 512 void menu_entry_frame_show_submenu(ObMenuEntryFrame *self)
 513 {
 514     ObMenuFrame *f;
 515
 516     f = menu_frame_new(self->entry->data.submenu.submenu,
 517                        self->frame->client);
 518     menu_frame_move(f,
 519                     self->frame->area.x + self->frame->area.width
 520                     - ob_rr_theme->menu_overlap,
 521                     self->frame->area.y + self->frame->title_h +
 522                     self->area.y);
 523     menu_frame_show(f, self->frame);
 524 }
 525
 526 void menu_entry_frame_execute(ObMenuEntryFrame *self)
 527 {
 528     if (self->entry->type == OB_MENU_ENTRY_TYPE_NORMAL) {
 529         GSList *it;
 530
 531         for (it = self->entry->data.normal.actions; it;
 532              it = g_slist_next(it))
 533         {
 534             ObAction *act = it->data;
 535             act->data.any.c = self->frame->client;
 536             act->func(&act->data);
 537         }
 538         menu_frame_hide_all();
 539     }
 540 }