mod_menu/menu.c

   1 /*
   2  * ion/mod_menu/menu.c
   3  *
   4  * Copyright (c) Tuomo Valkonen 1999-2009.
   5  *
   6  * See the included file LICENSE for details.
   7  */
   8
   9 #include <string.h>
  10 #include <limits.h>
  11
  12 #include <libtu/minmax.h>
  13 #include <libtu/objp.h>
  14 #include <libtu/obj.h>
  15 #include <libmainloop/defer.h>
  16 #include <libmainloop/signal.h>
  17
  18 #include <ioncore/common.h>
  19 #include <ioncore/window.h>
  20 #include <ioncore/global.h>
  21 #include <ioncore/regbind.h>
  22 #include <ioncore/strings.h>
  23 #include <ioncore/pointer.h>
  24 #include <ioncore/focus.h>
  25 #include <ioncore/event.h>
  26 #include <ioncore/xwindow.h>
  27 #include <ioncore/names.h>
  28 #include <ioncore/gr.h>
  29 #include <ioncore/gr-util.h>
  30 #include <ioncore/sizehint.h>
  31 #include <ioncore/resize.h>
  32 #include "menu.h"
  33 #include "main.h"
  34
  35
  36 #define MENU_WIN(MENU) ((MENU)->win.win)
  37
  38
  39 /*{{{ Helpers */
  40
  41
  42 static bool extl_table_getis(ExtlTab tab, int i, const char *s, char c,
  43                              void *p)
  44 {
  45     ExtlTab sub;
  46     bool ret;
  47
  48     if(!extl_table_geti_t(tab, i, &sub))
  49         return FALSE;
  50     ret=extl_table_get(sub, 's', c, s, p);
  51     extl_unref_table(sub);
  52     return ret;
  53 }
  54
  55
  56 /*}}}*/
  57
  58
  59 /*{{{ Drawing routines */
  60
  61
  62 static void get_outer_geom(WMenu *menu, WRectangle *geom)
  63 {
  64     geom->x=0;
  65     geom->y=0;
  66     geom->w=REGION_GEOM(menu).w;
  67     geom->h=REGION_GEOM(menu).h;
  68 }
  69
  70
  71 static void get_inner_geom(WMenu *menu, WRectangle *geom)
  72 {
  73     GrBorderWidths bdw;
  74
  75     get_outer_geom(menu, geom);
  76
  77     if(menu->brush!=NULL){
  78         grbrush_get_border_widths(menu->brush, &bdw);
  79         geom->x+=bdw.left;
  80         geom->y+=bdw.top;
  81         geom->w-=bdw.left+bdw.right;
  82         geom->h-=bdw.top+bdw.bottom;
  83         geom->w=MAXOF(0, geom->w);
  84         geom->h=MAXOF(0, geom->h);
  85     }
  86 }
  87
  88
  89 GR_DEFATTR(active);
  90 GR_DEFATTR(inactive);
  91 GR_DEFATTR(selected);
  92 GR_DEFATTR(unselected);
  93 GR_DEFATTR(normal);
  94 GR_DEFATTR(submenu);
  95
  96
  97 static void init_attr()
  98 {
  99     GR_ALLOCATTR_BEGIN;
 100     GR_ALLOCATTR(active);
 101     GR_ALLOCATTR(inactive);
 102     GR_ALLOCATTR(selected);
 103     GR_ALLOCATTR(unselected);
 104     GR_ALLOCATTR(normal);
 105     GR_ALLOCATTR(submenu);
 106     GR_ALLOCATTR_END;
 107 }
 108
 109
 110 static void menu_draw_entry(WMenu *menu, int i, const WRectangle *igeom,
 111                             bool complete)
 112 {
 113     WRectangle geom;
 114     GrAttr sa, aa;
 115
 116     aa=(REGION_IS_ACTIVE(menu) ? GR_ATTR(active) : GR_ATTR(inactive));
 117     sa=(menu->selected_entry==i ? GR_ATTR(selected) : GR_ATTR(unselected));
 118
 119     if(menu->entry_brush==NULL)
 120         return;
 121
 122     geom=*igeom;
 123     geom.h=menu->entry_h;
 124     geom.y+=(i-menu->first_entry)*(menu->entry_h+menu->entry_spacing);
 125
 126     grbrush_begin(menu->entry_brush, &geom, GRBRUSH_AMEND|GRBRUSH_KEEP_ATTR);
 127
 128     grbrush_init_attr(menu->entry_brush, &menu->entries[i].attr);
 129
 130     grbrush_set_attr(menu->entry_brush, aa);
 131     grbrush_set_attr(menu->entry_brush, sa);
 132
 133     grbrush_draw_textbox(menu->entry_brush, &geom, menu->entries[i].title,
 134                          complete);
 135
 136     grbrush_end(menu->entry_brush);
 137 }
 138
 139
 140 void menu_draw_entries(WMenu *menu, bool complete)
 141 {
 142     WRectangle igeom;
 143     int i, mx;
 144
 145     if(menu->entry_brush==NULL)
 146         return;
 147
 148     get_inner_geom(menu, &igeom);
 149
 150     mx=menu->first_entry+menu->vis_entries;
 151     mx=(mx < menu->n_entries ? mx : menu->n_entries);
 152
 153     for(i=menu->first_entry; i<mx; i++)
 154         menu_draw_entry(menu, i, &igeom, complete);
 155 }
 156
 157
 158 void menu_draw(WMenu *menu, bool complete)
 159 {
 160     GrAttr aa=(REGION_IS_ACTIVE(menu) ? GR_ATTR(active) : GR_ATTR(inactive));
 161     WRectangle geom;
 162
 163     if(menu->brush==NULL)
 164         return;
 165
 166     get_outer_geom(menu, &geom);
 167
 168     grbrush_begin(menu->brush, &geom,
 169                   (complete ? 0 : GRBRUSH_NO_CLEAR_OK));
 170
 171     grbrush_set_attr(menu->brush, aa);
 172
 173     grbrush_draw_border(menu->brush, &geom);
 174
 175     menu_draw_entries(menu, FALSE);
 176
 177     grbrush_end(menu->brush);
 178 }
 179
 180
 181 /*}}}*/
 182
 183
 184 /*{{{ Resize */
 185
 186
 187 static void menu_calc_size(WMenu *menu, bool maxexact,
 188                            int maxw, int maxh,
 189                            int *w_ret, int *h_ret)
 190 {
 191     GrBorderWidths bdw, e_bdw;
 192     char *str;
 193     int i;
 194     int bdh, maxew=menu->max_entry_w;
 195
 196     grbrush_get_border_widths(menu->brush, &bdw);
 197     grbrush_get_border_widths(menu->entry_brush, &e_bdw);
 198
 199     if(maxexact || maxew>maxw-(int)bdw.left-(int)bdw.right){
 200         maxew=maxw-bdw.left-bdw.right;
 201         *w_ret=maxw;
 202     }else{
 203         *w_ret=maxew+bdw.left+bdw.right;
 204     }
 205
 206     bdh=bdw.top+bdw.bottom;
 207
 208     if(menu->n_entries==0){
 209         *h_ret=(maxexact ? maxh : bdh);
 210         menu->first_entry=0;
 211         menu->vis_entries=0;
 212     }else{
 213         int vis=(maxh-bdh+e_bdw.spacing)/(e_bdw.spacing+menu->entry_h);
 214         if(vis>menu->n_entries){
 215             vis=menu->n_entries;
 216             menu->first_entry=0;
 217         }else if(menu->selected_entry>=0){
 218             if(menu->selected_entry<menu->first_entry)
 219                 menu->first_entry=menu->selected_entry;
 220             else if(menu->selected_entry>=menu->first_entry+vis)
 221                 menu->first_entry=menu->selected_entry-vis+1;
 222         }
 223         if(vis<=0)
 224             vis=1;
 225         menu->vis_entries=vis;
 226         if(maxexact)
 227             *h_ret=maxh;
 228         else
 229             *h_ret=vis*menu->entry_h+(vis-1)*e_bdw.spacing+bdh;
 230     }
 231
 232     /* Calculate new shortened entry names */
 233     maxew-=e_bdw.left+e_bdw.right;
 234
 235     for(i=0; i<menu->n_entries; i++){
 236         if(menu->entries[i].title){
 237             free(menu->entries[i].title);
 238             menu->entries[i].title=NULL;
 239         }
 240         if(maxew<=0)
 241             continue;
 242
 243         if(extl_table_getis(menu->tab, i+1, "name", 's', &str)){
 244             menu->entries[i].title=grbrush_make_label(menu->entry_brush,
 245                                                       str, maxew);
 246             free(str);
 247         }
 248     }
 249 }
 250
 251
 252 void calc_size(WMenu *menu, int *w, int *h)
 253 {
 254     if(menu->pmenu_mode){
 255         menu_calc_size(menu, FALSE, INT_MAX, INT_MAX, w, h);
 256     }else{
 257         menu_calc_size(menu, !(menu->last_fp.mode&REGION_FIT_BOUNDS),
 258                        menu->last_fp.g.w, menu->last_fp.g.h, w, h);
 259     }
 260 }
 261
 262
 263 /* Return offset from bottom-left corner of containing mplex or top-right
 264  * corner of  parent menu for the respective corner of menu.
 265  */
 266 static void get_placement_offs(WMenu *menu, int *xoff, int *yoff)
 267 {
 268     GrBorderWidths bdw;
 269
 270     *xoff=0;
 271     *yoff=0;
 272
 273     if(menu->brush!=NULL){
 274         grbrush_get_border_widths(menu->brush, &bdw);
 275         *xoff+=bdw.right;
 276         *yoff+=bdw.top;
 277     }
 278
 279     if(menu->entry_brush!=NULL){
 280         grbrush_get_border_widths(menu->entry_brush, &bdw);
 281         *xoff+=bdw.right;
 282         *yoff+=bdw.top;
 283     }
 284 }
 285
 286
 287 #define MINIMUM_Y_VISIBILITY 20
 288 #define POINTER_OFFSET 5
 289
 290 static void menu_firstfit(WMenu *menu, bool submenu, const WRectangle *refg)
 291 {
 292     WRectangle geom;
 293
 294     calc_size(menu, &(geom.w), &(geom.h));
 295
 296     if(!(menu->last_fp.mode&REGION_FIT_BOUNDS)){
 297         geom.x=menu->last_fp.g.x;
 298         geom.y=menu->last_fp.g.y;
 299     }else if(menu->pmenu_mode){
 300         geom.x=refg->x;
 301         geom.y=refg->y;
 302
 303         if(!submenu){
 304             const WRectangle *maxg =
 305                 &REGION_GEOM(REGION_PARENT((WRegion*)menu));
 306
 307             geom.x-=geom.w/2;
 308             geom.y+=POINTER_OFFSET;
 309
 310             if(geom.y+MINIMUM_Y_VISIBILITY>maxg->y+maxg->h){
 311                 geom.y=maxg->y+maxg->h-MINIMUM_Y_VISIBILITY;
 312                 geom.x=refg->x+POINTER_OFFSET;
 313                 if(geom.x+geom.w>maxg->x+maxg->w)
 314                     geom.x=refg->x-geom.w-POINTER_OFFSET;
 315             }else{
 316                 if(geom.x<0)
 317                     geom.x=0;
 318                 else if(geom.x+geom.w>maxg->x+maxg->w)
 319                     geom.x=maxg->x+maxg->w-geom.w;
 320             }
 321         }
 322     }else{
 323         const WRectangle *maxg=&(menu->last_fp.g);
 324         if(submenu){
 325             int l, r, t, b, xoff, yoff;
 326
 327             get_placement_offs(menu, &xoff, &yoff);
 328             l=refg->x+xoff;
 329             r=refg->x+refg->w+xoff;
 330             t=refg->y-yoff;
 331             b=refg->y+refg->h-yoff;
 332
 333             geom.x=MAXOF(l, r-geom.w);
 334             if(geom.x+geom.w>maxg->x+maxg->w)
 335                 geom.x=maxg->x;
 336
 337             geom.y=MINOF(b-geom.h, t);
 338             if(geom.y<maxg->y)
 339                 geom.y=maxg->y;
 340         }else{
 341             geom.x=maxg->x;
 342             geom.y=maxg->y+maxg->h-geom.h;
 343         }
 344     }
 345
 346     window_do_fitrep(&menu->win, NULL, &geom);
 347 }
 348
 349
 350 static void menu_do_refit(WMenu *menu, WWindow *par, const WFitParams *oldfp)
 351 {
 352     WRectangle geom;
 353
 354     calc_size(menu, &(geom.w), &(geom.h));
 355
 356     if(!(menu->last_fp.mode&REGION_FIT_BOUNDS)){
 357         geom.x=menu->last_fp.g.x;
 358         geom.y=menu->last_fp.g.y;
 359     }else if(menu->pmenu_mode){
 360         geom.x=REGION_GEOM(menu).x;
 361         geom.y=REGION_GEOM(menu).y;
 362     }else{
 363         const WRectangle *maxg=&(menu->last_fp.g);
 364         int xdiff=REGION_GEOM(menu).x-oldfp->g.x;
 365         int ydiff=(REGION_GEOM(menu).y+REGION_GEOM(menu).h
 366                    -(oldfp->g.y+oldfp->g.h));
 367         geom.x=MAXOF(0, MINOF(maxg->x+xdiff, maxg->x+maxg->w-geom.w));
 368         geom.y=MAXOF(0, MINOF(maxg->y+maxg->h+ydiff, maxg->y+maxg->h)-geom.h);
 369     }
 370
 371     window_do_fitrep(&menu->win, par, &geom);
 372 }
 373
 374
 375 bool menu_fitrep(WMenu *menu, WWindow *par, const WFitParams *fp)
 376 {
 377     WFitParams oldfp;
 378
 379     if(par!=NULL && !region_same_rootwin((WRegion*)par, (WRegion*)menu))
 380         return FALSE;
 381
 382     oldfp=menu->last_fp;
 383     menu->last_fp=*fp;
 384     menu_do_refit(menu, par, &oldfp);
 385
 386     if(menu->submenu!=NULL && !menu->pmenu_mode)
 387         region_fitrep((WRegion*)(menu->submenu), par, fp);
 388
 389     return TRUE;
 390 }
 391
 392
 393 void menu_size_hints(WMenu *menu, WSizeHints *hints_ret)
 394 {
 395     int n=menu->n_entries;
 396     int w=menu->max_entry_w;
 397     int h=menu->entry_h*n + menu->entry_spacing*MAXOF(0, n-1);
 398
 399     if(menu->brush!=NULL){
 400         GrBorderWidths bdw;
 401         grbrush_get_border_widths(menu->brush, &bdw);
 402
 403         w+=bdw.left+bdw.right;
 404         h+=bdw.top+bdw.bottom;
 405     }
 406
 407     hints_ret->min_set=TRUE;
 408     hints_ret->min_width=w;
 409     hints_ret->min_height=h;
 410 }
 411
 412
 413 /*}}}*/
 414
 415
 416 /*{{{ Brush update */
 417
 418
 419 static void calc_entry_dimens(WMenu *menu)
 420 {
 421     int i, n=extl_table_get_n(menu->tab);
 422     GrFontExtents fnte;
 423     GrBorderWidths bdw;
 424     int maxw=0;
 425     char *str;
 426
 427 #if 0
 428     if(extl_table_gets_s(menu->tab, title, &str)){
 429         maxw=grbrush_get_text_width(title_brush, str, strlen(str));
 430         free(str);
 431     }
 432 #endif
 433
 434     for(i=1; i<=n; i++){
 435         if(extl_table_getis(menu->tab, i, "name", 's', &str)){
 436             int w=grbrush_get_text_width(menu->entry_brush,
 437                                          str, strlen(str));
 438             if(w>maxw)
 439                 maxw=w;
 440             free(str);
 441         }
 442     }
 443
 444     grbrush_get_border_widths(menu->entry_brush, &bdw);
 445     grbrush_get_font_extents(menu->entry_brush, &fnte);
 446
 447     menu->max_entry_w=maxw+bdw.left+bdw.right;
 448     menu->entry_h=fnte.max_height+bdw.top+bdw.bottom;
 449     menu->entry_spacing=bdw.spacing;
 450 }
 451
 452
 453 static bool menu_init_gr(WMenu *menu, WRootWin *rootwin, Window win)
 454 {
 455     GrBrush *brush, *entry_brush;
 456     const char *style=(menu->big_mode
 457                        ? "input-menu-big"
 458                        : (menu->pmenu_mode
 459                           ? "input-menu-pmenu"
 460                           : "input-menu-normal"));
 461
 462     const char *entry_style=(menu->big_mode
 463                                    ? "tab-menuentry-big"
 464                                    : (menu->pmenu_mode
 465                                       ? "tab-menuentry-pmenu"
 466                                       : "tab-menuentry-normal"));
 467
 468     brush=gr_get_brush(win, rootwin, style);
 469
 470     if(brush==NULL)
 471         return FALSE;
 472
 473     entry_brush=grbrush_get_slave(brush, rootwin, entry_style);
 474
 475     if(entry_brush==NULL){
 476         grbrush_release(brush);
 477         return FALSE;
 478     }
 479
 480     if(menu->entry_brush!=NULL)
 481         grbrush_release(menu->entry_brush);
 482     if(menu->brush!=NULL)
 483         grbrush_release(menu->brush);
 484
 485     menu->brush=brush;
 486     menu->entry_brush=entry_brush;
 487
 488     calc_entry_dimens(menu);
 489
 490     return TRUE;
 491 }
 492
 493
 494 void menu_updategr(WMenu *menu)
 495 {
 496     if(!menu_init_gr(menu, region_rootwin_of((WRegion*)menu),
 497                      MENU_WIN(menu))){
 498         return;
 499     }
 500
 501     menu_do_refit(menu, NULL, &(menu->last_fp));
 502
 503     region_updategr_default((WRegion*)menu);
 504
 505     window_draw((WWindow*)menu, TRUE);
 506 }
 507
 508
 509 static void menu_release_gr(WMenu *menu)
 510 {
 511     if(menu->entry_brush!=NULL){
 512         grbrush_release(menu->entry_brush);
 513         menu->entry_brush=NULL;
 514     }
 515     if(menu->brush!=NULL){
 516         grbrush_release(menu->brush);
 517         menu->brush=NULL;
 518     }
 519 }
 520
 521
 522 /*}}}*/
 523
 524
 525 /*{{{ Init/deinit */
 526
 527
 528 static WMenuEntry *preprocess_menu(ExtlTab tab, int *n_entries)
 529 {
 530     WMenuEntry *entries;
 531     ExtlTab entry;
 532     int i, n;
 533
 534     n=extl_table_get_n(tab);
 535     *n_entries=n;
 536
 537     if(n<=0)
 538         return NULL;
 539
 540     entries=ALLOC_N(WMenuEntry, n);
 541
 542     if(entries==NULL)
 543         return NULL;
 544
 545     init_attr();
 546
 547     /* Initialise entries and check submenus */
 548     for(i=1; i<=n; i++){
 549         WMenuEntry *ent=&entries[i-1];
 550
 551         ent->title=NULL;
 552         ent->flags=0;
 553
 554         gr_stylespec_init(&ent->attr);
 555
 556         if(extl_table_geti_t(tab, i, &entry)){
 557             char *attr;
 558             ExtlTab sub;
 559             ExtlFn fn;
 560
 561             if(extl_table_gets_s(entry, "attr", &attr)){
 562                 gr_stylespec_load_(&ent->attr, attr, TRUE);
 563                 free(attr);
 564             }
 565
 566             if(extl_table_gets_f(entry, "submenu_fn", &fn)){
 567                 ent->flags|=WMENUENTRY_SUBMENU;
 568                 extl_unref_fn(fn);
 569             }else if(extl_table_gets_t(entry, "submenu", &sub)){
 570                 ent->flags|=WMENUENTRY_SUBMENU;
 571                 extl_unref_table(sub);
 572             }
 573
 574             if(ent->flags&WMENUENTRY_SUBMENU)
 575                 gr_stylespec_set(&ent->attr, GR_ATTR(submenu));
 576
 577             extl_unref_table(entry);
 578         }
 579     }
 580
 581     return entries;
 582 }
 583
 584
 585 static void deinit_entries(WMenu *menu);
 586
 587
 588 bool menu_init(WMenu *menu, WWindow *par, const WFitParams *fp,
 589                const WMenuCreateParams *params)
 590 {
 591     Window win;
 592
 593     menu->entries=preprocess_menu(params->tab, &(menu->n_entries));
 594
 595     if(menu->entries==NULL){
 596         warn(TR("Empty menu."));
 597         return FALSE;
 598     }
 599
 600     menu->tab=extl_ref_table(params->tab);
 601     menu->handler=extl_ref_fn(params->handler);
 602     menu->pmenu_mode=params->pmenu_mode;
 603     menu->big_mode=params->big_mode;
 604     /*menu->cycle_bindmap=NULL;*/
 605
 606     menu->last_fp=*fp;
 607
 608     if(params->pmenu_mode){
 609         menu->selected_entry=-1;
 610     }else{
 611         menu->selected_entry=params->initial-1;
 612         if(menu->selected_entry<0)
 613            menu->selected_entry=0;
 614         if(params->initial > menu->n_entries)
 615            menu->selected_entry=0;
 616     }
 617
 618     menu->max_entry_w=0;
 619     menu->entry_h=0;
 620     menu->brush=NULL;
 621     menu->entry_brush=NULL;
 622     menu->entry_spacing=0;
 623     menu->vis_entries=menu->n_entries;
 624     menu->first_entry=0;
 625     menu->submenu=NULL;
 626     menu->typeahead=NULL;
 627
 628     menu->gm_kcb=0;
 629     menu->gm_state=0;
 630
 631     if(!window_init((WWindow*)menu, par, fp, "WMenu"))
 632         goto fail;
 633
 634     win=menu->win.win;
 635
 636     if(!menu_init_gr(menu, region_rootwin_of((WRegion*)par), win))
 637         goto fail2;
 638
 639     init_attr();
 640
 641     menu_firstfit(menu, params->submenu_mode, &(params->refg));
 642
 643     window_select_input(&(menu->win), IONCORE_EVENTMASK_NORMAL);
 644
 645     region_add_bindmap((WRegion*)menu, mod_menu_menu_bindmap);
 646
 647     region_register((WRegion*)menu);
 648
 649     return TRUE;
 650
 651 fail2:
 652     window_deinit((WWindow*)menu);
 653 fail:
 654     extl_unref_table(menu->tab);
 655     extl_unref_fn(menu->handler);
 656     deinit_entries(menu);
 657     return FALSE;
 658 }
 659
 660
 661 WMenu *create_menu(WWindow *par, const WFitParams *fp,
 662                    const WMenuCreateParams *params)
 663 {
 664     CREATEOBJ_IMPL(WMenu, menu, (p, par, fp, params));
 665 }
 666
 667
 668 static void deinit_entries(WMenu *menu)
 669 {
 670     int i;
 671
 672     for(i=0; i<menu->n_entries; i++){
 673         gr_stylespec_unalloc(&menu->entries[i].attr);
 674         if(menu->entries[i].title!=NULL)
 675             free(menu->entries[i].title);
 676     }
 677
 678     free(menu->entries);
 679 }
 680
 681
 682 void menu_deinit(WMenu *menu)
 683 {
 684     menu_typeahead_clear(menu);
 685
 686     if(menu->submenu!=NULL)
 687         destroy_obj((Obj*)menu->submenu);
 688
 689     /*if(menu->cycle_bindmap!=NULL)
 690         bindmap_destroy(menu->cycle_bindmap);*/
 691
 692     extl_unref_table(menu->tab);
 693     extl_unref_fn(menu->handler);
 694
 695     deinit_entries(menu);
 696
 697     menu_release_gr(menu);
 698
 699     window_deinit((WWindow*)menu);
 700 }
 701
 702
 703 /*}}}*/
 704
 705
 706 /*{{{ Focus  */
 707
 708
 709 static void menu_inactivated(WMenu *menu)
 710 {
 711     window_draw((WWindow*)menu, FALSE);
 712 }
 713
 714
 715 static void menu_activated(WMenu *menu)
 716 {
 717     window_draw((WWindow*)menu, FALSE);
 718 }
 719
 720
 721 /*}}}*/
 722
 723
 724 /*{{{ Submenus */
 725
 726
 727 static WMenu *menu_head(WMenu *menu)
 728 {
 729     WMenu *m=REGION_MANAGER_CHK(menu, WMenu);
 730     return (m==NULL ? menu : menu_head(m));
 731 }
 732
 733
 734 static WMenu *menu_tail(WMenu *menu)
 735 {
 736     return (menu->submenu==NULL ? menu : menu_tail(menu->submenu));
 737 }
 738
 739
 740 static void menu_managed_remove(WMenu *menu, WRegion *sub)
 741 {
 742     bool mcf=region_may_control_focus((WRegion*)menu);
 743
 744     if(sub!=(WRegion*)menu->submenu)
 745         return;
 746
 747     menu->submenu=NULL;
 748
 749     region_unset_manager(sub, (WRegion*)menu);
 750
 751     if(mcf)
 752         region_do_set_focus((WRegion*)menu, FALSE);
 753 }
 754
 755
 756 int get_sub_y_off(WMenu *menu, int n)
 757 {
 758     /* top + sum of above entries and spacings - top_of_sub */
 759     return (menu->entry_h+menu->entry_spacing)*(n-menu->first_entry);
 760 }
 761
 762
 763 static void show_sub(WMenu *menu, int n)
 764 {
 765     WFitParams fp;
 766     WMenuCreateParams fnp;
 767     WMenu *submenu;
 768     WWindow *par;
 769
 770     par=REGION_PARENT(menu);
 771
 772     if(par==NULL)
 773         return;
 774
 775     fp=menu->last_fp;
 776
 777     fnp.pmenu_mode=menu->pmenu_mode;
 778     fnp.big_mode=menu->big_mode;
 779     fnp.submenu_mode=TRUE;
 780
 781     if(menu->pmenu_mode){
 782         fnp.refg.x=REGION_GEOM(menu).x+REGION_GEOM(menu).w;
 783         fnp.refg.y=REGION_GEOM(menu).y+get_sub_y_off(menu, n);
 784         fnp.refg.w=0;
 785         fnp.refg.h=0;
 786     }else{
 787         fnp.refg=REGION_GEOM(menu);
 788     }
 789
 790     fnp.tab=extl_table_none();
 791     {
 792         ExtlFn fn;
 793         if(extl_table_getis(menu->tab, n+1, "submenu_fn", 'f', &fn)){
 794             extl_protect(NULL);
 795             extl_call(fn, NULL, "t", &(fnp.tab));
 796             extl_unprotect(NULL);
 797             extl_unref_fn(fn);
 798         }else{
 799             extl_table_getis(menu->tab, n+1, "submenu", 't', &(fnp.tab));
 800         }
 801         if(fnp.tab==extl_table_none())
 802             return;
 803     }
 804
 805     fnp.handler=extl_ref_fn(menu->handler);
 806
 807     fnp.initial=0;
 808     {
 809         ExtlFn fn;
 810         if(extl_table_getis(menu->tab, n+1, "initial", 'f', &fn)){
 811             extl_protect(NULL);
 812             extl_call(fn, NULL, "i", &(fnp.initial));
 813             extl_unprotect(NULL);
 814             extl_unref_fn(fn);
 815         }else{
 816             extl_table_getis(menu->tab, n+1, "initial", 'i', &(fnp.initial));
 817         }
 818     }
 819
 820     submenu=create_menu(par, &fp, &fnp);
 821
 822     if(submenu==NULL)
 823         return;
 824
 825     menu->submenu=submenu;
 826     region_set_manager((WRegion*)submenu, (WRegion*)menu);
 827
 828     region_restack((WRegion*)submenu, MENU_WIN(menu), Above);
 829     region_map((WRegion*)submenu);
 830
 831     if(!menu->pmenu_mode && region_may_control_focus((WRegion*)menu))
 832         region_do_set_focus((WRegion*)submenu, FALSE);
 833 }
 834
 835
 836 static void menu_do_set_focus(WMenu *menu, bool warp)
 837 {
 838     if(menu->submenu!=NULL)
 839         region_do_set_focus((WRegion*)menu->submenu, warp);
 840     else
 841         window_do_set_focus((WWindow*)menu, warp);
 842 }
 843
 844
 845 void menu_restack(WMenu *menu, Window other, int mode)
 846 {
 847     xwindow_restack(MENU_WIN(menu), other, mode);
 848     if(menu->submenu!=NULL)
 849         region_restack((WRegion*)(menu->submenu), MENU_WIN(menu), Above);
 850 }
 851
 852
 853 void menu_stacking(WMenu *menu, Window *bottomret, Window *topret)
 854 {
 855     *topret=None;
 856
 857     if(menu->submenu!=NULL)
 858         region_stacking((WRegion*)(menu->submenu), bottomret, topret);
 859
 860     *bottomret=MENU_WIN(menu);
 861     if(*topret==None)
 862         *topret=MENU_WIN(menu);
 863
 864 }
 865
 866
 867 /*}}}*/
 868
 869
 870 /*{{{ Exports */
 871
 872
 873 static void menu_do_select_nth(WMenu *menu, int n)
 874 {
 875     int oldn=menu->selected_entry;
 876     bool drawfull=FALSE;
 877
 878     if(oldn==n)
 879         return;
 880
 881     if(menu->submenu!=NULL)
 882         destroy_obj((Obj*)menu->submenu);
 883
 884     assert(menu->submenu==NULL);
 885
 886     menu->selected_entry=n;
 887
 888     if(n>=0){
 889         if(n<menu->first_entry){
 890             menu->first_entry=n;
 891             drawfull=TRUE;
 892         }else if(n>=menu->first_entry+menu->vis_entries){
 893             menu->first_entry=n-menu->vis_entries+1;
 894             drawfull=TRUE;
 895         }
 896
 897         if(menu->entries[n].flags&WMENUENTRY_SUBMENU &&
 898            menu->pmenu_mode){
 899             show_sub(menu, n);
 900         }
 901     }
 902
 903     if(drawfull){
 904         menu_draw_entries(menu, TRUE);
 905     }else{
 906         /* redraw new and old selected entry */
 907         WRectangle igeom;
 908         get_inner_geom(menu, &igeom);
 909
 910         /* !!!BEGIN!!! */
 911         if(oldn!=-1)
 912             menu_draw_entry(menu, oldn, &igeom, TRUE);
 913         if(n!=-1)
 914             menu_draw_entry(menu, n, &igeom, TRUE);
 915     }
 916 }
 917
 918
 919 /*EXTL_DOC
 920  * Select \var{n}:th entry in menu.
 921  */
 922 EXTL_EXPORT_MEMBER
 923 void menu_select_nth(WMenu *menu, int n)
 924 {
 925     if(n<0)
 926         n=0;
 927     if(n>=menu->n_entries)
 928         n=menu->n_entries-1;
 929
 930     menu_typeahead_clear(menu);
 931     menu_do_select_nth(menu, n);
 932 }
 933
 934
 935 /*EXTL_DOC
 936  * Select previous entry in menu.
 937  */
 938 EXTL_EXPORT_MEMBER
 939 void menu_select_prev(WMenu *menu)
 940 {
 941     menu_select_nth(menu, (menu->selected_entry<=0
 942                            ? menu->n_entries-1
 943                            : menu->selected_entry-1));
 944 }
 945
 946
 947 /*EXTL_DOC
 948  * Select next entry in menu.
 949  */
 950 EXTL_EXPORT_MEMBER
 951 void menu_select_next(WMenu *menu)
 952 {
 953     menu_select_nth(menu, (menu->selected_entry+1)%menu->n_entries);
 954 }
 955
 956
 957 static void menu_do_finish(WMenu *menu)
 958 {
 959     ExtlFn handler;
 960     ExtlTab tab;
 961     bool ok;
 962     WMenu *head=menu_head(menu);
 963
 964     handler=menu->handler;
 965     menu->handler=extl_fn_none();
 966
 967     ok=extl_table_geti_t(menu->tab, menu->selected_entry+1, &tab);
 968
 969     if(!region_rqdispose((WRegion*)head)){
 970         if(head->submenu!=NULL)
 971             destroy_obj((Obj*)head->submenu);
 972     }
 973
 974     if(ok)
 975         extl_call(handler, "t", NULL, tab);
 976
 977     extl_unref_fn(handler);
 978     extl_unref_table(tab);
 979 }
 980
 981
 982 /*EXTL_DOC
 983  * If selected entry is a submenu, display that.
 984  * Otherwise destroy the menu and call handler for selected entry.
 985  */
 986 EXTL_EXPORT_MEMBER
 987 void menu_finish(WMenu *menu)
 988 {
 989     menu_typeahead_clear(menu);
 990
 991     if(!menu->pmenu_mode && menu->selected_entry>=0 &&
 992        menu->entries[menu->selected_entry].flags&WMENUENTRY_SUBMENU){
 993         show_sub(menu, menu->selected_entry);
 994         return;
 995     }
 996
 997     mainloop_defer_action((Obj*)menu, (WDeferredAction*)menu_do_finish);
 998 }
 999
1000
1001
1002 /*EXTL_DOC
1003  * Close \var{menu} not calling any possible finish handlers.
1004  */
1005 EXTL_EXPORT_MEMBER
1006 void menu_cancel(WMenu *menu)
1007 {
1008     region_defer_rqdispose((WRegion*)menu);
1009 }
1010
1011
1012 /*}}}*/
1013
1014
1015 /*{{{ Scroll */
1016
1017 static int scroll_time=20;
1018 static int scroll_amount=3;
1019 static WTimer *scroll_timer=NULL;
1020
1021
1022 static void reset_scroll_timer()
1023 {
1024     if(scroll_timer!=NULL){
1025         destroy_obj((Obj*)scroll_timer);
1026         scroll_timer=NULL;
1027     }
1028 }
1029
1030
1031 /*EXTL_DOC
1032  * Set module basic settings. The parameter table may contain the
1033  * following fields:
1034  *
1035  * \begin{tabularx}{\linewidth}{lX}
1036  *  \tabhead{Field & Description}
1037  *  \var{scroll_amount} & Number of pixels to scroll at a time in
1038  *                        pointer-controlled menus when one extends
1039  *                        beyond a border of the screen and the pointer
1040  *                        touches that border. \\
1041  *  \var{scroll_delay}  & Time between such scrolling events in
1042  *                        milliseconds.
1043  * \end{tabularx}
1044  */
1045 EXTL_EXPORT
1046 void mod_menu_set(ExtlTab tab)
1047 {
1048     int a, t;
1049
1050     if(extl_table_gets_i(tab, "scroll_amount", &a))
1051         scroll_amount=MAXOF(0, a);
1052     if(extl_table_gets_i(tab, "scroll_delay", &t))
1053         scroll_time=MAXOF(0, t);
1054 }
1055
1056
1057 /*EXTL_DOC
1058  * Get module basic settings. For details, see \fnref{mod_menu.set}.
1059  */
1060 EXTL_SAFE
1061 EXTL_EXPORT
1062 ExtlTab mod_menu_get()
1063 {
1064     ExtlTab tab=extl_create_table();
1065     extl_table_sets_i(tab, "scroll_amount", scroll_amount);
1066     extl_table_sets_i(tab, "scroll_delay", scroll_time);
1067     return tab;
1068 }
1069
1070
1071 enum{
1072     D_LEFT,
1073     D_RIGHT,
1074     D_DOWN,
1075     D_UP
1076 };
1077
1078
1079 static int calc_diff(const WRectangle *mg, const WRectangle *pg, int d)
1080 {
1081     switch(d){
1082     case D_LEFT:
1083         return mg->x+mg->w-pg->w;
1084     case D_UP:
1085         return mg->y+mg->h-pg->h;
1086     case D_RIGHT:
1087         return -mg->x;
1088     case D_DOWN:
1089         return -mg->y;
1090     }
1091     return 0;
1092 }
1093
1094
1095 static int scrolld_subs(WMenu *menu, int d)
1096 {
1097     int diff=0;
1098     WRegion *p=REGION_PARENT_REG(menu);
1099     const WRectangle *pg;
1100
1101     if(p==NULL)
1102         return 0;
1103
1104     pg=&REGION_GEOM(p);
1105
1106     while(menu!=NULL){
1107         int new_diff = calc_diff(&REGION_GEOM(menu), pg, d);
1108         diff=MAXOF(diff, new_diff);
1109         menu=menu->submenu;
1110     }
1111
1112     return MINOF(MAXOF(0, diff), scroll_amount);
1113 }
1114
1115
1116 static void menu_select_entry_at(WMenu *menu, int px, int py);
1117
1118
1119 static void do_scroll(WMenu *menu, int xd, int yd)
1120 {
1121     WRectangle g;
1122     int px=-1, py=-1;
1123
1124     xwindow_pointer_pos(region_root_of((WRegion*)menu), &px, &py);
1125
1126     while(menu!=NULL){
1127         g=REGION_GEOM(menu);
1128         g.x+=xd;
1129         g.y+=yd;
1130
1131         window_do_fitrep((WWindow*)menu, NULL, &g);
1132
1133         menu_select_entry_at(menu, px, py);
1134
1135         menu=menu->submenu;
1136     }
1137 }
1138
1139
1140 static void scroll_left(WTimer *timer, WMenu *menu)
1141 {
1142     if(menu!=NULL){
1143         do_scroll(menu, -scrolld_subs(menu, D_LEFT), 0);
1144         if(scrolld_subs(menu, D_LEFT)>0){
1145             timer_set(timer, scroll_time, (WTimerHandler*)scroll_left,
1146                       (Obj*)menu);
1147             return;
1148         }
1149     }
1150 }
1151
1152
1153 static void scroll_up(WTimer *timer, WMenu *menu)
1154 {
1155     if(menu!=NULL){
1156         do_scroll(menu, 0, -scrolld_subs(menu, D_UP));
1157         if(scrolld_subs(menu, D_UP)>0){
1158             timer_set(timer, scroll_time, (WTimerHandler*)scroll_up,
1159                       (Obj*)menu);
1160
1161             return;
1162         }
1163     }
1164 }
1165
1166
1167 static void scroll_right(WTimer *timer, WMenu *menu)
1168 {
1169     if(menu!=NULL){
1170         do_scroll(menu, scrolld_subs(menu, D_RIGHT), 0);
1171         if(scrolld_subs(menu, D_RIGHT)>0){
1172             timer_set(timer, scroll_time, (WTimerHandler*)scroll_right,
1173                       (Obj*)menu);
1174             return;
1175         }
1176     }
1177 }
1178
1179
1180 static void scroll_down(WTimer *timer, WMenu *menu)
1181 {
1182     if(menu!=NULL){
1183         do_scroll(menu, 0, scrolld_subs(menu, D_DOWN));
1184         if(scrolld_subs(menu, D_DOWN)>0){
1185             timer_set(timer, scroll_time, (WTimerHandler*)scroll_down,
1186                       (Obj*)menu);
1187             return;
1188         }
1189     }
1190 }
1191
1192
1193 static void end_scroll(WMenu *menu)
1194 {
1195     reset_scroll_timer();
1196 }
1197
1198 #define SCROLL_OFFSET 10
1199
1200 static void check_scroll(WMenu *menu, int x, int y)
1201 {
1202     WRegion *parent=REGION_PARENT_REG(menu);
1203     int rx, ry;
1204     WTimerHandler *fn=NULL;
1205
1206     if(!menu->pmenu_mode)
1207         return;
1208
1209     if(parent==NULL){
1210         end_scroll(menu);
1211         return;
1212     }
1213
1214     region_rootpos(parent, &rx, &ry);
1215     x-=rx;
1216     y-=ry;
1217
1218     if(x<=SCROLL_OFFSET){
1219         fn=(WTimerHandler*)scroll_right;
1220     }else if(y<=SCROLL_OFFSET){
1221         fn=(WTimerHandler*)scroll_down;
1222     }else if(x>=REGION_GEOM(parent).w-SCROLL_OFFSET){
1223         fn=(WTimerHandler*)scroll_left;
1224     }else if(y>=REGION_GEOM(parent).h-SCROLL_OFFSET){
1225         fn=(WTimerHandler*)scroll_up;
1226     }else{
1227         end_scroll(menu);
1228         return;
1229     }
1230
1231     assert(fn!=NULL);
1232
1233     if(scroll_timer!=NULL){
1234         if(scroll_timer->handler==(WTimerHandler*)fn &&
1235            timer_is_set(scroll_timer)){
1236             return;
1237         }
1238     }else{
1239         scroll_timer=create_timer();
1240         if(scroll_timer==NULL)
1241             return;
1242     }
1243
1244     fn(scroll_timer, (Obj*)menu_head(menu));
1245 }
1246
1247
1248 /*}}}*/
1249
1250
1251 /*{{{ Pointer handlers */
1252
1253
1254 int menu_entry_at_root(WMenu *menu, int root_x, int root_y)
1255 {
1256     int rx, ry, x, y, entry;
1257     WRectangle ig;
1258     region_rootpos((WRegion*)menu, &rx, &ry);
1259
1260     get_inner_geom(menu, &ig);
1261
1262     x=root_x-rx-ig.x;
1263     y=root_y-ry-ig.y;
1264
1265     if(x<0 || x>=ig.w || y<0  || y>=ig.h)
1266         return -1;
1267
1268     entry=y/(menu->entry_h+menu->entry_spacing);
1269     if(entry<0 || entry>=menu->vis_entries)
1270         return -1;
1271     return entry+menu->first_entry;
1272 }
1273
1274
1275 int menu_entry_at_root_tree(WMenu *menu, int root_x, int root_y,
1276                             WMenu **realmenu)
1277 {
1278     int entry=-1;
1279
1280     menu=menu_tail(menu);
1281
1282     *realmenu=menu;
1283
1284     if(!menu->pmenu_mode)
1285         return menu_entry_at_root(menu, root_x, root_y);
1286
1287     while(menu!=NULL){
1288         entry=menu_entry_at_root(menu, root_x, root_y);
1289         if(entry>=0){
1290             *realmenu=menu;
1291             break;
1292         }
1293         menu=REGION_MANAGER_CHK(menu, WMenu);
1294     }
1295
1296     return entry;
1297 }
1298
1299
1300 static void menu_select_entry_at(WMenu *menu, int px, int py)
1301 {
1302     int entry=menu_entry_at_root_tree(menu, px, py, &menu);
1303     if(entry>=0)
1304         menu_do_select_nth(menu, entry);
1305 }
1306
1307
1308 void menu_release(WMenu *menu, XButtonEvent *ev)
1309 {
1310     int entry=menu_entry_at_root_tree(menu, ev->x_root, ev->y_root, &menu);
1311     end_scroll(menu);
1312     if(entry>=0){
1313         menu_select_nth(menu, entry);
1314         menu_finish(menu);
1315     }else if(menu->pmenu_mode){
1316         menu_cancel(menu_head(menu));
1317     }
1318 }
1319
1320
1321 void menu_motion(WMenu *menu, XMotionEvent *ev, int UNUSED(dx), int UNUSED(dy))
1322 {
1323     menu_select_entry_at(menu, ev->x_root, ev->y_root);
1324     check_scroll(menu, ev->x_root, ev->y_root);
1325 }
1326
1327
1328 void menu_button(WMenu *menu, XButtonEvent *ev)
1329 {
1330     int entry=menu_entry_at_root_tree(menu, ev->x_root, ev->y_root, &menu);
1331     if(entry>=0)
1332         menu_select_nth(menu, entry);
1333 }
1334
1335
1336 int menu_press(WMenu *menu, XButtonEvent *ev, WRegion **UNUSED(reg_ret))
1337 {
1338     menu_button(menu, ev);
1339     menu=menu_head(menu);
1340     ioncore_set_drag_handlers((WRegion*)menu,
1341                         NULL,
1342                         (WMotionHandler*)menu_motion,
1343                         (WButtonHandler*)menu_release,
1344                         NULL,
1345                         NULL);
1346     return 0;
1347 }
1348
1349
1350 /*}}}*/
1351
1352
1353 /*{{{ Typeahead find */
1354
1355
1356 static void menu_insstr(WMenu *menu, const char *buf, size_t n)
1357 {
1358     size_t oldlen=(menu->typeahead==NULL ? 0 : strlen(menu->typeahead));
1359     char *newta=(char*)malloc(oldlen+n+1);
1360     char *newta_orig;
1361     int entry;
1362
1363     if(newta==NULL)
1364         return;
1365
1366     if(oldlen!=0)
1367         memcpy(newta, menu->typeahead, oldlen);
1368     if(n!=0)
1369         memcpy(newta+oldlen, buf, n);
1370     newta[oldlen+n]='\0';
1371     newta_orig=newta;
1372
1373     while(*newta!='\0'){
1374         bool found=FALSE;
1375         entry=menu->selected_entry;
1376         do{
1377             if(menu->entries[entry].title!=NULL){
1378                 if(libtu_strcasestr(menu->entries[entry].title, newta)){
1379                     found=TRUE;
1380                     break;
1381                 }
1382             }
1383             entry=(entry+1)%menu->n_entries;
1384         }while(entry!=menu->selected_entry);
1385         if(found){
1386             menu_do_select_nth(menu, entry);
1387             break;
1388         }
1389         newta++;
1390     }
1391
1392     if(newta_orig!=newta){
1393         if(*newta=='\0'){
1394             free(newta_orig);
1395             newta=NULL;
1396         }else{
1397             char *p=scopy(newta);
1398             free(newta_orig);
1399             newta=p;
1400         }
1401     }
1402     if(menu->typeahead!=NULL)
1403         free(menu->typeahead);
1404     menu->typeahead=newta;
1405 }
1406
1407
1408 /*EXTL_DOC
1409  * Clear typeahead buffer.
1410  */
1411 EXTL_EXPORT_MEMBER
1412 void menu_typeahead_clear(WMenu *menu)
1413 {
1414     if(menu->typeahead!=NULL){
1415         free(menu->typeahead);
1416         menu->typeahead=NULL;
1417     }
1418 }
1419
1420
1421 /*}}}*/
1422
1423
1424 /*{{{ Dynamic function table and class implementation */
1425
1426
1427 static DynFunTab menu_dynfuntab[]={
1428     {(DynFun*)region_fitrep, (DynFun*)menu_fitrep},
1429     {region_updategr, menu_updategr},
1430     {window_draw, menu_draw},
1431     {(DynFun*)window_press, (DynFun*)menu_press},
1432     {region_managed_remove, menu_managed_remove},
1433     {region_do_set_focus, menu_do_set_focus},
1434     {region_activated, menu_activated},
1435     {region_inactivated, menu_inactivated},
1436     {window_insstr, menu_insstr},
1437     {region_restack, menu_restack},
1438     {region_stacking, menu_stacking},
1439     {region_size_hints, menu_size_hints},
1440     END_DYNFUNTAB
1441 };
1442
1443
1444 EXTL_EXPORT
1445 IMPLCLASS(WMenu, WWindow, menu_deinit, menu_dynfuntab);
1446
1447
1448 /*}}}*/
1449
1450