mod_statusbar/statusbar.c

   1 /*
   2  * ion/mod_statusbar/statusbar.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/objp.h>
  13 #include <libtu/minmax.h>
  14 #include <libtu/ptrlist.h>
  15 #include <libtu/misc.h>
  16 #include <ioncore/common.h>
  17 #include <ioncore/global.h>
  18 #include <ioncore/window.h>
  19 #include <ioncore/binding.h>
  20 #include <ioncore/regbind.h>
  21 #include <ioncore/event.h>
  22 #include <ioncore/resize.h>
  23 #include <ioncore/gr.h>
  24 #include <ioncore/gr-util.h>
  25 #include <ioncore/names.h>
  26 #include <ioncore/strings.h>
  27 #include <ioncore/basicpholder.h>
  28 #include <ioncore/sizehint.h>
  29
  30 #include "statusbar.h"
  31 #include "main.h"
  32 #include "draw.h"
  33
  34
  35 static void statusbar_set_elems(WStatusBar *sb, ExtlTab t);
  36 static void statusbar_free_elems(WStatusBar *sb);
  37 static void statusbar_update_natural_size(WStatusBar *p);
  38 static void statusbar_arrange_systray(WStatusBar *p);
  39 static int statusbar_systray_x(WStatusBar *p);
  40 static void statusbar_rearrange(WStatusBar *sb, bool rs);
  41 static void do_calc_systray_w(WStatusBar *p, WSBElem *el);
  42 static void statusbar_calc_systray_w(WStatusBar *p);
  43
  44 static WStatusBar *statusbars=NULL;
  45
  46
  47 /*{{{ Init/deinit */
  48
  49
  50 bool statusbar_init(WStatusBar *p, WWindow *parent, const WFitParams *fp)
  51 {
  52     if(!window_init(&(p->wwin), parent, fp))
  53         return FALSE;
  54
  55     p->brush=NULL;
  56     p->elems=NULL;
  57     p->nelems=0;
  58     p->natural_w=1;
  59     p->natural_h=1;
  60     p->filleridx=-1;
  61     p->sb_next=NULL;
  62     p->sb_prev=NULL;
  63     p->traywins=NULL;
  64     p->systray_enabled=TRUE;
  65
  66     statusbar_updategr(p);
  67
  68     if(p->brush==NULL){
  69         window_deinit(&(p->wwin));
  70         return FALSE;
  71     }
  72
  73     window_select_input(&(p->wwin), IONCORE_EVENTMASK_NORMAL);
  74
  75     region_register((WRegion*)p);
  76
  77     region_add_bindmap((WRegion*)p, mod_statusbar_statusbar_bindmap);
  78
  79     LINK_ITEM(statusbars, p, sb_next, sb_prev);
  80
  81     return TRUE;
  82 }
  83
  84
  85
  86 WStatusBar *create_statusbar(WWindow *parent, const WFitParams *fp)
  87 {
  88     CREATEOBJ_IMPL(WStatusBar, statusbar, (p, parent, fp));
  89 }
  90
  91
  92 void statusbar_deinit(WStatusBar *p)
  93 {
  94     UNLINK_ITEM(statusbars, p, sb_next, sb_prev);
  95
  96     statusbar_free_elems(p);
  97
  98     if(p->brush!=NULL){
  99         grbrush_release(p->brush);
 100         p->brush=NULL;
 101     }
 102
 103     window_deinit(&(p->wwin));
 104 }
 105
 106
 107 /*}}}*/
 108
 109
 110 /*{{{ Content stuff */
 111
 112
 113 static void init_sbelem(WSBElem *el)
 114 {
 115     el->type=WSBELEM_NONE;
 116     el->text_w=0;
 117     el->text=NULL;
 118     el->max_w=0;
 119     el->tmpl=NULL;
 120     el->meter=STRINGID_NONE;
 121     el->attr=STRINGID_NONE;
 122     el->stretch=0;
 123     el->align=WSBELEM_ALIGN_CENTER;
 124     el->zeropad=0;
 125     el->x=0;
 126     el->traywins=NULL;
 127 }
 128
 129
 130 static bool gets_stringstore(ExtlTab t, const char *str, StringId *id)
 131 {
 132     char *s;
 133
 134     if(extl_table_gets_s(t, str, &s)){
 135         *id=stringstore_alloc(s);
 136         free(s);
 137         return (*id!=STRINGID_NONE);
 138     }
 139
 140     return FALSE;
 141 }
 142
 143
 144 static WSBElem *get_sbelems(ExtlTab t, int *nret, int *filleridxret)
 145 {
 146     int i, n=extl_table_get_n(t);
 147     WSBElem *el;
 148     int systrayidx=-1;
 149
 150     *nret=0;
 151     *filleridxret=-1;
 152
 153     if(n<=0)
 154         return NULL;
 155
 156     el=ALLOC_N(WSBElem, n);
 157
 158     if(el==NULL)
 159         return NULL;
 160
 161     for(i=0; i<n; i++){
 162         ExtlTab tt;
 163
 164         init_sbelem(&el[i]);
 165
 166         if(extl_table_geti_t(t, i+1, &tt)){
 167             if(extl_table_gets_i(tt, "type", &(el[i].type))){
 168                 if(el[i].type==WSBELEM_TEXT || el[i].type==WSBELEM_STRETCH){
 169                     extl_table_gets_s(tt, "text", &(el[i].text));
 170                 }else if(el[i].type==WSBELEM_METER){
 171                     gets_stringstore(tt, "meter", &(el[i].meter));
 172                     extl_table_gets_s(tt, "tmpl", &(el[i].tmpl));
 173                     extl_table_gets_i(tt, "align", &(el[i].align));
 174                     extl_table_gets_i(tt, "zeropad", &(el[i].zeropad));
 175                     el[i].zeropad=maxof(el[i].zeropad, 0);
 176                 }else if(el[i].type==WSBELEM_SYSTRAY){
 177                     const char *tmp;
 178
 179                     gets_stringstore(tt, "meter", &(el[i].meter));
 180                     extl_table_gets_i(tt, "align", &(el[i].align));
 181
 182                     tmp=stringstore_get(el[i].meter);
 183
 184                     if(tmp==NULL || strcmp(tmp, "systray")==0)
 185                         systrayidx=i;
 186                 }else if(el[i].type==WSBELEM_FILLER){
 187                     *filleridxret=i;
 188                 }
 189             }
 190             extl_unref_table(tt);
 191         }
 192     }
 193
 194     if(systrayidx==-1){
 195         WSBElem *el2=REALLOC_N(el, WSBElem, n, n+1);
 196         if(el2!=NULL){
 197             el=el2;
 198             init_sbelem(&el[n]);
 199             el[n].type=WSBELEM_SYSTRAY;
 200             n++;
 201         }
 202     }
 203
 204     *nret=n;
 205
 206     return el;
 207 }
 208
 209
 210 static void free_sbelems(WSBElem *el, int n)
 211 {
 212     int i;
 213
 214     for(i=0; i<n; i++){
 215         if(el[i].text!=NULL)
 216             free(el[i].text);
 217         if(el[i].tmpl!=NULL)
 218             free(el[i].tmpl);
 219         if(el[i].meter!=STRINGID_NONE)
 220             stringstore_free(el[i].meter);
 221         if(el[i].attr!=STRINGID_NONE)
 222             stringstore_free(el[i].attr);
 223         if(el[i].traywins!=NULL)
 224             ptrlist_clear(&el[i].traywins);
 225     }
 226
 227     free(el);
 228 }
 229
 230
 231 static void statusbar_set_elems(WStatusBar *sb, ExtlTab t)
 232 {
 233     statusbar_free_elems(sb);
 234
 235     sb->elems=get_sbelems(t, &(sb->nelems), &(sb->filleridx));
 236 }
 237
 238
 239 static void statusbar_free_elems(WStatusBar *sb)
 240 {
 241     if(sb->elems!=NULL){
 242         free_sbelems(sb->elems, sb->nelems);
 243         sb->elems=NULL;
 244         sb->nelems=0;
 245         sb->filleridx=-1;
 246     }
 247 }
 248
 249
 250 /*}}}*/
 251
 252
 253
 254 /*{{{ Size stuff */
 255
 256
 257 static void statusbar_resize(WStatusBar *p)
 258 {
 259     WRQGeomParams rq=RQGEOMPARAMS_INIT;
 260
 261     rq.flags=REGION_RQGEOM_WEAK_X|REGION_RQGEOM_WEAK_Y;
 262
 263     rq.geom.w=p->natural_w;
 264     rq.geom.h=p->natural_h;
 265     rq.geom.x=REGION_GEOM(p).x;
 266     rq.geom.y=REGION_GEOM(p).y;
 267
 268     if(rectangle_compare(&rq.geom, &REGION_GEOM(p))!=RECTANGLE_SAME)
 269         region_rqgeom((WRegion*)p, &rq, NULL);
 270 }
 271
 272
 273 static void calc_elem_w(WStatusBar *p, WSBElem *el, GrBrush *brush)
 274 {
 275     const char *str;
 276
 277     if(el->type==WSBELEM_SYSTRAY){
 278         do_calc_systray_w(p, el);
 279         return;
 280     }
 281
 282     if(brush==NULL){
 283         el->text_w=0;
 284         return;
 285     }
 286
 287     if(el->type==WSBELEM_METER){
 288         str=(el->text!=NULL ? el->text : STATUSBAR_NX_STR);
 289         el->text_w=grbrush_get_text_width(brush, str, strlen(str));
 290         str=el->tmpl;
 291         el->max_w=maxof((str!=NULL
 292                          ? grbrush_get_text_width(brush, str, strlen(str))
 293                          : 0),
 294                         el->text_w);
 295     }else{
 296         str=el->text;
 297         el->text_w=(str!=NULL
 298                     ? grbrush_get_text_width(brush, str, strlen(str))
 299                     : 0);
 300         el->max_w=el->text_w;
 301     }
 302 }
 303
 304
 305 static void statusbar_calc_widths(WStatusBar *sb)
 306 {
 307     int i;
 308
 309     for(i=0; i<sb->nelems; i++)
 310         calc_elem_w(sb, &(sb->elems[i]), sb->brush);
 311 }
 312
 313
 314 static void statusbar_do_update_natural_size(WStatusBar *p)
 315 {
 316     GrBorderWidths bdw;
 317     GrFontExtents fnte;
 318     WRegion *reg;
 319     PtrListIterTmp tmp;
 320     int totw=0, stmh=0;
 321     int i;
 322
 323     if(p->brush==NULL){
 324         bdw.left=0; bdw.right=0;
 325         bdw.top=0; bdw.bottom=0;
 326         fnte.max_height=4;
 327     }else{
 328         grbrush_get_border_widths(p->brush, &bdw);
 329         grbrush_get_font_extents(p->brush, &fnte);
 330     }
 331
 332     for(i=0; i<p->nelems; i++)
 333         totw+=p->elems[i].max_w;
 334
 335     FOR_ALL_ON_PTRLIST(WRegion*, reg, p->traywins, tmp){
 336         stmh=maxof(stmh, REGION_GEOM(reg).h);
 337     }
 338
 339     p->natural_w=bdw.left+totw+bdw.right;
 340     p->natural_h=maxof(stmh, fnte.max_height)+bdw.top+bdw.bottom;
 341 }
 342
 343
 344 void statusbar_size_hints(WStatusBar *p, WSizeHints *h)
 345 {
 346     h->min_set=TRUE;
 347     h->min_width=p->natural_w;
 348     h->min_height=p->natural_h;
 349
 350     h->max_set=TRUE;
 351     h->max_width=INT_MAX;/*p->natural_w;*/
 352     h->max_height=p->natural_h;
 353 }
 354
 355
 356 /*}}}*/
 357
 358
 359 /*{{{ Systray */
 360
 361
 362 static WSBElem *statusbar_associate_systray(WStatusBar *sb, WRegion *reg)
 363 {
 364     WClientWin *cwin=OBJ_CAST(reg, WClientWin);
 365     WSBElem *el=NULL, *fbel=NULL;
 366     char *name=NULL;
 367     int i;
 368
 369     if(cwin!=NULL)
 370         extl_table_gets_s(cwin->proptab, "statusbar", &name);
 371
 372     for(i=0; i<sb->nelems; i++){
 373         const char *meter;
 374
 375         if(sb->elems[i].type!=WSBELEM_SYSTRAY)
 376             continue;
 377
 378         meter=stringstore_get(sb->elems[i].meter);
 379
 380         if(meter==NULL){
 381             fbel=&sb->elems[i];
 382             continue;
 383         }
 384         if(name!=NULL && strcmp(meter, name)==0){
 385             el=&sb->elems[i];
 386             break;
 387         }
 388         if(strcmp(meter, "systray")==0)
 389             fbel=&sb->elems[i];
 390     }
 391
 392     if(name!=NULL)
 393         free(name);
 394
 395     if(el==NULL)
 396         el=fbel;
 397
 398     if(el==NULL)
 399         return NULL;
 400
 401     ptrlist_insert_last(&el->traywins, (Obj*)reg);
 402
 403     return el;
 404 }
 405
 406
 407 static WSBElem *statusbar_unassociate_systray(WStatusBar *sb, WRegion *reg)
 408 {
 409     int i;
 410
 411     for(i=0; i<sb->nelems; i++){
 412         if(ptrlist_remove(&(sb->elems[i].traywins), (Obj*)reg))
 413             return &sb->elems[i];
 414     }
 415
 416     return NULL;
 417 }
 418
 419
 420
 421 static void do_calc_systray_w(WStatusBar *p, WSBElem *el)
 422 {
 423     WRegion *reg;
 424     PtrListIterTmp tmp;
 425     int padding=0;
 426     int w=-padding;
 427
 428     FOR_ALL_ON_PTRLIST(WRegion*, reg, el->traywins, tmp){
 429         w=w+REGION_GEOM(reg).w+padding;
 430     }
 431
 432     el->text_w=maxof(0, w);
 433     el->max_w=el->text_w; /* for now */
 434 }
 435
 436
 437 static void statusbar_calc_systray_w(WStatusBar *p)
 438 {
 439     int i;
 440
 441     for(i=0; i<p->nelems; i++){
 442         if(p->elems[i].type==WSBELEM_SYSTRAY)
 443             do_calc_systray_w(p, &p->elems[i]);
 444     }
 445 }
 446
 447
 448 static void statusbar_arrange_systray(WStatusBar *p)
 449 {
 450     WRegion *reg;
 451     PtrListIterTmp tmp;
 452     GrBorderWidths bdw;
 453     int padding=0, ymiddle;
 454     int i, x;
 455
 456     if(p->brush!=NULL){
 457         grbrush_get_border_widths(p->brush, &bdw);
 458     }else{
 459         bdw.top=0;
 460         bdw.bottom=0;
 461     }
 462
 463     ymiddle=bdw.top+(REGION_GEOM(p).h-bdw.top-bdw.bottom)/2;
 464
 465     for(i=0; i<p->nelems; i++){
 466         WSBElem *el=&p->elems[i];
 467         if(el->type!=WSBELEM_SYSTRAY)
 468             continue;
 469         x=el->x;
 470         FOR_ALL_ON_PTRLIST(WRegion*, reg, el->traywins, tmp){
 471             WRectangle g=REGION_GEOM(reg);
 472             g.x=x;
 473             g.y=ymiddle-g.h/2;
 474             region_fit(reg, &g, REGION_FIT_EXACT);
 475             x=x+g.w+padding;
 476         }
 477     }
 478 }
 479
 480
 481 static void systray_adjust_size(WRegion *reg, WRectangle *g)
 482 {
 483     g->h=CF_STATUSBAR_SYSTRAY_HEIGHT;
 484
 485     region_size_hints_correct(reg, &g->w, &g->h, TRUE);
 486 }
 487
 488
 489
 490 static WRegion *statusbar_do_attach_final(WStatusBar *sb,
 491                                           WRegion *reg,
 492                                           void *unused)
 493 {
 494     WFitParams fp;
 495     WSBElem *el;
 496
 497     if(!ptrlist_insert_last(&sb->traywins, (Obj*)reg))
 498         return NULL;
 499
 500     el=statusbar_associate_systray(sb, reg);
 501     if(el==NULL){
 502         ptrlist_remove(&sb->traywins, (Obj*)reg);
 503         return NULL;
 504     }
 505
 506     fp.g=REGION_GEOM(reg);
 507     fp.mode=REGION_FIT_EXACT;
 508     systray_adjust_size(reg, &fp.g);
 509
 510     region_fitrep(reg, NULL, &fp);
 511
 512     do_calc_systray_w(sb, el);
 513
 514     region_set_manager(reg, (WRegion*)sb);
 515
 516     statusbar_rearrange(sb, TRUE);
 517
 518     if(REGION_IS_MAPPED(sb))
 519         region_map(reg);
 520
 521     return reg;
 522 }
 523
 524
 525 static WRegion *statusbar_do_attach(WStatusBar *sb, WRegionAttachData *data)
 526 {
 527     WFitParams fp;
 528
 529     fp.g.x=0;
 530     fp.g.y=0;
 531     fp.g.h=CF_STATUSBAR_SYSTRAY_HEIGHT;
 532     fp.g.w=CF_STATUSBAR_SYSTRAY_HEIGHT;
 533     fp.mode=REGION_FIT_WHATEVER|REGION_FIT_BOUNDS;
 534
 535     return region_attach_helper((WRegion*)sb, (WWindow*)sb, &fp,
 536                                 (WRegionDoAttachFn*)statusbar_do_attach_final,
 537                                 NULL, data);
 538 }
 539
 540
 541 static WRegion *statusbar_attach_ph(WStatusBar *sb, int flags,
 542                                     WRegionAttachData *data)
 543 {
 544     return statusbar_do_attach(sb, data);
 545 }
 546
 547
 548 static WPHolder *statusbar_prepare_manage(WStatusBar *sb,
 549                                           const WClientWin *cwin,
 550                                           const WManageParams *param,
 551                                           int priority)
 552 {
 553     if(!MANAGE_PRIORITY_OK(priority, MANAGE_PRIORITY_LOW))
 554         return NULL;
 555
 556     return (WPHolder*)create_basicpholder((WRegion*)sb,
 557                                           ((WBasicPHolderHandler*)
 558                                            statusbar_attach_ph));
 559 }
 560
 561
 562 static void statusbar_managed_remove(WStatusBar *sb, WRegion *reg)
 563 {
 564     WSBElem *el;
 565
 566     ptrlist_remove(&sb->traywins, (Obj*)reg);
 567
 568     el=statusbar_unassociate_systray(sb, reg);
 569
 570     region_unset_manager(reg, (WRegion*)sb);
 571
 572     if(el!=NULL && ioncore_g.opmode!=IONCORE_OPMODE_DEINIT){
 573         do_calc_systray_w(sb, el);
 574         statusbar_rearrange(sb, TRUE);
 575     }
 576 }
 577
 578
 579 static void statusbar_managed_rqgeom(WStatusBar *sb, WRegion *reg,
 580                                      const WRQGeomParams *rq,
 581                                      WRectangle *geomret)
 582 {
 583     WRectangle g;
 584
 585     g.x=REGION_GEOM(reg).x;
 586     g.y=REGION_GEOM(reg).y;
 587     g.w=rq->geom.w;
 588     g.h=rq->geom.h;
 589
 590     systray_adjust_size(reg, &g);
 591
 592     if(rq->flags&REGION_RQGEOM_TRYONLY){
 593         if(geomret!=NULL)
 594             *geomret=g;
 595         return;
 596     }
 597
 598     region_fit(reg, &g, REGION_FIT_EXACT);
 599
 600     statusbar_calc_systray_w(sb);
 601     statusbar_rearrange(sb, TRUE);
 602
 603     if(geomret!=NULL)
 604         *geomret=REGION_GEOM(reg);
 605
 606 }
 607
 608
 609 void statusbar_map(WStatusBar *sb)
 610 {
 611     WRegion *reg;
 612     PtrListIterTmp tmp;
 613
 614     window_map((WWindow*)sb);
 615
 616     FOR_ALL_ON_PTRLIST(WRegion*, reg, sb->traywins, tmp)
 617         region_map(reg);
 618 }
 619
 620
 621 void statusbar_unmap(WStatusBar *sb)
 622 {
 623     WRegion *reg;
 624     PtrListIterTmp tmp;
 625
 626     window_unmap((WWindow*)sb);
 627
 628     FOR_ALL_ON_PTRLIST(WRegion*, reg, sb->traywins, tmp)
 629         region_unmap(reg);
 630 }
 631
 632
 633 bool statusbar_fitrep(WStatusBar *sb, WWindow *par, const WFitParams *fp)
 634 {
 635     bool wchg=(REGION_GEOM(sb).w!=fp->g.w);
 636     bool hchg=(REGION_GEOM(sb).h!=fp->g.h);
 637
 638     if(!window_fitrep(&(sb->wwin), par, fp))
 639         return FALSE;
 640
 641     if(wchg || hchg){
 642         statusbar_calculate_xs(sb);
 643         statusbar_arrange_systray(sb);
 644         statusbar_draw(sb, TRUE);
 645     }
 646
 647     return TRUE;
 648 }
 649
 650
 651 WPHolder *statusbar_prepare_manage_transient(WStatusBar *sb,
 652                                              const WClientWin *cwin,
 653                                              const WManageParams *param,
 654                                              int unused)
 655 {
 656     WRegion *mgr=REGION_MANAGER(sb);
 657
 658     if(mgr==NULL)
 659         mgr=(WRegion*)region_screen_of((WRegion*)sb);
 660
 661     if(mgr!=NULL)
 662         return region_prepare_manage(mgr, cwin, param,
 663                                      MANAGE_PRIORITY_NONE);
 664     else
 665         return NULL;
 666 }
 667
 668
 669
 670 /*}}}*/
 671
 672
 673 /*{{{ Exports */
 674
 675
 676 static ExtlFn parse_template_fn;
 677 static bool parse_template_fn_set=FALSE;
 678
 679
 680 EXTL_EXPORT
 681 void mod_statusbar__set_template_parser(ExtlFn fn)
 682 {
 683     if(parse_template_fn_set)
 684         extl_unref_fn(parse_template_fn);
 685     parse_template_fn=extl_ref_fn(fn);
 686     parse_template_fn_set=TRUE;
 687 }
 688
 689
 690 /*EXTL_DOC
 691  * Set statusbar template.
 692  */
 693 EXTL_EXPORT_MEMBER
 694 void statusbar_set_template(WStatusBar *sb, const char *tmpl)
 695 {
 696     ExtlTab t=extl_table_none();
 697     bool ok=FALSE;
 698
 699     if(parse_template_fn_set){
 700         extl_protect(NULL);
 701         ok=extl_call(parse_template_fn, "s", "t", tmpl, &t);
 702         extl_unprotect(NULL);
 703     }
 704
 705     if(ok)
 706         statusbar_set_template_table(sb, t);
 707 }
 708
 709
 710 /*EXTL_DOC
 711  * Set statusbar template as table.
 712  */
 713 EXTL_EXPORT_MEMBER
 714 void statusbar_set_template_table(WStatusBar *sb, ExtlTab t)
 715 {
 716     WRegion *reg;
 717     PtrListIterTmp tmp;
 718
 719     statusbar_set_elems(sb, t);
 720
 721     FOR_ALL_ON_PTRLIST(WRegion*, reg, sb->traywins, tmp){
 722         statusbar_associate_systray(sb, reg);
 723     }
 724
 725     statusbar_calc_widths(sb);
 726     statusbar_rearrange(sb, FALSE);
 727 }
 728
 729
 730 /*EXTL_DOC
 731  * Get statusbar template as table.
 732  */
 733 EXTL_EXPORT_MEMBER
 734 ExtlTab statusbar_get_template_table(WStatusBar *sb)
 735 {
 736     int count = sb->nelems;
 737     int i;
 738
 739     ExtlTab t = extl_create_table();
 740
 741     for(i=0; i<count; i++){
 742         ExtlTab tt = extl_create_table();
 743
 744         extl_table_sets_i(tt, "type", sb->elems[i].type);
 745         extl_table_sets_s(tt, "text", sb->elems[i].text);
 746         extl_table_sets_s(tt, "meter", stringstore_get(sb->elems[i].meter));
 747         extl_table_sets_s(tt, "tmpl", sb->elems[i].tmpl);
 748         extl_table_sets_i(tt, "align", sb->elems[i].align);
 749         extl_table_sets_i(tt, "zeropad", sb->elems[i].zeropad);
 750
 751         extl_table_seti_t(t, (i+1), tt);
 752         extl_unref_table(tt);
 753     }
 754
 755     return t;
 756 }
 757
 758
 759 static void reset_stretch(WStatusBar *sb)
 760 {
 761     int i;
 762
 763     for(i=0; i<sb->nelems; i++)
 764         sb->elems[i].stretch=0;
 765 }
 766
 767
 768 static void positive_stretch(WStatusBar *sb)
 769 {
 770     int i;
 771
 772     for(i=0; i<sb->nelems; i++)
 773         sb->elems[i].stretch=maxof(0, sb->elems[i].stretch);
 774 }
 775
 776
 777 static void spread_stretch(WStatusBar *sb)
 778 {
 779     int i, j, k;
 780     int diff;
 781     WSBElem *el, *lel, *rel;
 782     const char *str;
 783
 784     for(i=0; i<sb->nelems; i++){
 785         el=&(sb->elems[i]);
 786
 787         if(el->type!=WSBELEM_METER && el->type!=WSBELEM_SYSTRAY)
 788             continue;
 789
 790         diff=el->max_w-el->text_w;
 791
 792         lel=NULL;
 793         rel=NULL;
 794
 795         if(el->align!=WSBELEM_ALIGN_RIGHT){
 796             for(j=i+1; j<sb->nelems; j++){
 797                 if(sb->elems[j].type==WSBELEM_STRETCH){
 798                     rel=&(sb->elems[j]);
 799                     break;
 800                 }
 801             }
 802         }
 803
 804         if(el->align!=WSBELEM_ALIGN_LEFT){
 805             for(k=i-1; k>=0; k--){
 806                 if(sb->elems[k].type==WSBELEM_STRETCH){
 807                     lel=&(sb->elems[k]);
 808                     break;
 809                 }
 810             }
 811         }
 812
 813         if(rel!=NULL && lel!=NULL){
 814             int l=diff/2;
 815             int r=diff-l;
 816             lel->stretch+=l;
 817             rel->stretch+=r;
 818         }else if(lel!=NULL){
 819             lel->stretch+=diff;
 820         }else if(rel!=NULL){
 821             rel->stretch+=diff;
 822         }
 823     }
 824 }
 825
 826
 827 static void statusbar_rearrange(WStatusBar *sb, bool rs)
 828 {
 829     if(rs){
 830         int onw=sb->natural_w;
 831         int onh=sb->natural_h;
 832
 833         statusbar_do_update_natural_size(sb);
 834
 835         if(    (sb->natural_h>onh && REGION_GEOM(sb).h>=onh)
 836             || (sb->natural_h<onh && REGION_GEOM(sb).h<=onh)
 837             || (sb->natural_w>onw && REGION_GEOM(sb).w>=onw)
 838             || (sb->natural_w<onw && REGION_GEOM(sb).w<=onw)){
 839
 840             statusbar_resize(sb);
 841         }
 842     }
 843
 844     reset_stretch(sb);
 845     spread_stretch(sb);
 846     positive_stretch(sb);
 847     statusbar_calculate_xs(sb);
 848
 849     if(rs)
 850         statusbar_arrange_systray(sb);
 851 }
 852
 853
 854
 855 /*EXTL_DOC
 856  * Set statusbar template.
 857  */
 858 EXTL_EXPORT_MEMBER
 859 void statusbar_update(WStatusBar *sb, ExtlTab t)
 860 {
 861     int i;
 862     WSBElem *el;
 863     bool grow=FALSE;
 864
 865     if(sb->brush==NULL)
 866         return;
 867
 868     for(i=0; i<sb->nelems; i++){
 869         const char *meter;
 870
 871         el=&(sb->elems[i]);
 872
 873         if(el->type!=WSBELEM_METER)
 874             continue;
 875
 876         if(el->text!=NULL){
 877             free(el->text);
 878             el->text=NULL;
 879         }
 880
 881         if(el->attr!=GRATTR_NONE){
 882             stringstore_free(el->attr);
 883             el->attr=GRATTR_NONE;
 884         }
 885
 886         meter=stringstore_get(el->meter);
 887
 888         if(meter!=NULL){
 889             const char *str;
 890             char *attrnm;
 891
 892             extl_table_gets_s(t, meter, &(el->text));
 893
 894             if(el->text==NULL){
 895                 str=STATUSBAR_NX_STR;
 896             }else{
 897                 /* Zero-pad */
 898                 int l=strlen(el->text);
 899                 int ml=str_len(el->text);
 900                 int diff=el->zeropad-ml;
 901                 if(diff>0){
 902                     char *tmp=ALLOC_N(char, l+diff+1);
 903                     if(tmp!=NULL){
 904                         memset(tmp, '0', diff);
 905                         memcpy(tmp+diff, el->text, l+1);
 906                         free(el->text);
 907                         el->text=tmp;
 908                     }
 909                 }
 910                 str=el->text;
 911             }
 912
 913             if(el->tmpl!=NULL && el->text!=NULL){
 914                 char *tmp=grbrush_make_label(sb->brush, el->text, el->max_w);
 915                 if(tmp!=NULL){
 916                     free(el->text);
 917                     el->text=tmp;
 918                     str=tmp;
 919                 }
 920             }
 921
 922             el->text_w=grbrush_get_text_width(sb->brush, str, strlen(str));
 923
 924             if(el->text_w>el->max_w && el->tmpl==NULL){
 925                 el->max_w=el->text_w;
 926                 grow=TRUE;
 927             }
 928
 929             attrnm=scat(meter, "_hint");
 930             if(attrnm!=NULL){
 931                 char *s;
 932                 if(extl_table_gets_s(t, attrnm, &s)){
 933                     el->attr=stringstore_alloc(s);
 934                     free(s);
 935                 }
 936                 free(attrnm);
 937             }
 938         }
 939     }
 940
 941     statusbar_rearrange(sb, grow);
 942
 943     window_draw((WWindow*)sb, FALSE);
 944 }
 945
 946
 947 /*}}}*/
 948
 949
 950 /*{{{ Updategr */
 951
 952
 953 void statusbar_updategr(WStatusBar *p)
 954 {
 955     GrBrush *nbrush;
 956
 957     nbrush=gr_get_brush(p->wwin.win, region_rootwin_of((WRegion*)p),
 958                         "stdisp-statusbar");
 959     if(nbrush==NULL)
 960         return;
 961
 962     if(p->brush!=NULL)
 963         grbrush_release(p->brush);
 964
 965     p->brush=nbrush;
 966
 967     statusbar_calc_widths(p);
 968     statusbar_rearrange(p, TRUE);
 969
 970     window_draw(&(p->wwin), TRUE);
 971 }
 972
 973
 974 /*}}}*/
 975
 976
 977 /*{{{ Misc */
 978
 979
 980 int statusbar_orientation(WStatusBar *sb)
 981 {
 982     return REGION_ORIENTATION_HORIZONTAL;
 983 }
 984
 985
 986 /*EXTL_DOC
 987  * Returns a list of all statusbars.
 988  */
 989 EXTL_EXPORT
 990 ExtlTab mod_statusbar_statusbars()
 991 {
 992     ExtlTab t=extl_create_table();
 993     WStatusBar *sb;
 994     int i=1;
 995
 996     for(sb=statusbars; sb!=NULL; sb=sb->sb_next){
 997         extl_table_seti_o(t, i, (Obj*)sb);
 998         i++;
 999     }
1000
1001     return t;
1002 }
1003
1004
1005 WStatusBar *mod_statusbar_find_suitable(WClientWin *cwin,
1006                                         const WManageParams *param)
1007 {
1008     WStatusBar *sb;
1009
1010     for(sb=statusbars; sb!=NULL; sb=sb->sb_next){
1011         /*if(!sb->is_auto)
1012             continue;*/
1013         if(!sb->systray_enabled)
1014             continue;
1015         if(!region_same_rootwin((WRegion*)sb, (WRegion*)cwin))
1016             continue;
1017         break;
1018     }
1019
1020     return sb;
1021 }
1022
1023
1024 bool statusbar_set_systray(WStatusBar *sb, int sp)
1025 {
1026     bool set=sb->systray_enabled;
1027     bool nset=libtu_do_setparam(sp, set);
1028
1029     sb->systray_enabled=nset;
1030
1031     return nset;
1032 }
1033
1034
1035 /*EXTL_DOC
1036  * Enable or disable use of \var{sb} as systray.
1037  * The parameter \var{how} can be one of
1038  * \codestr{set}, \codestr{unset}, or \codestr{toggle}.
1039  * Resulting state is returned.
1040  */
1041 EXTL_EXPORT_AS(WStatusBar, set_systray)
1042 bool statusbar_set_systray_extl(WStatusBar *sb, const char *how)
1043 {
1044     return statusbar_set_systray(sb, libtu_string_to_setparam(how));
1045 }
1046
1047
1048 /*EXTL_DOC
1049  * Is \var{sb} used as a systray?
1050  */
1051 EXTL_EXPORT_AS(WStatusBar, is_systray)
1052 bool statusbar_is_systray_extl(WStatusBar *sb)
1053 {
1054     return sb->systray_enabled;
1055 }
1056
1057
1058 /*}}}*/
1059
1060
1061 /*{{{ Load */
1062
1063
1064 WRegion *statusbar_load(WWindow *par, const WFitParams *fp, ExtlTab tab)
1065 {
1066     WStatusBar *sb=create_statusbar(par, fp);
1067
1068     if(sb!=NULL){
1069         char *tmpl=NULL;
1070         ExtlTab t=extl_table_none();
1071         if(extl_table_gets_s(tab, "template", &tmpl)){
1072             statusbar_set_template(sb, tmpl);
1073             free(tmpl);
1074         }else if(extl_table_gets_t(tab, "template_table", &t)){
1075             statusbar_set_template_table(sb, t);
1076             extl_unref_table(t);
1077         }else{
1078             const char *tmpl=TR("[ %date || load: %load ] %filler%systray");
1079             statusbar_set_template(sb, tmpl);
1080         }
1081
1082         extl_table_gets_b(tab, "systray", &sb->systray_enabled);
1083     }
1084
1085     return (WRegion*)sb;
1086 }
1087
1088
1089 /*}}}*/
1090
1091
1092 /*{{{ Dynamic function table and class implementation */
1093
1094
1095 static DynFunTab statusbar_dynfuntab[]={
1096     {window_draw, statusbar_draw},
1097     {region_updategr, statusbar_updategr},
1098     {region_size_hints, statusbar_size_hints},
1099     {(DynFun*)region_orientation, (DynFun*)statusbar_orientation},
1100
1101     {region_managed_rqgeom, statusbar_managed_rqgeom},
1102     {(DynFun*)region_prepare_manage, (DynFun*)statusbar_prepare_manage},
1103     {region_managed_remove, statusbar_managed_remove},
1104
1105     {(DynFun*)region_prepare_manage_transient,
1106      (DynFun*)statusbar_prepare_manage_transient},
1107
1108     {region_map, statusbar_map},
1109     {region_unmap, statusbar_unmap},
1110
1111     {(DynFun*)region_fitrep,
1112      (DynFun*)statusbar_fitrep},
1113
1114     END_DYNFUNTAB
1115 };
1116
1117
1118 EXTL_EXPORT
1119 IMPLCLASS(WStatusBar, WWindow, statusbar_deinit, statusbar_dynfuntab);
1120
1121
1122 /*}}}*/
1123