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