ioncore/focus.c

   1 /*
   2  * ion/ioncore/focus.c
   3  *
   4  * Copyright (c) Tuomo Valkonen 1999-2009.
   5  *
   6  * See the included file LICENSE for details.
   7  */
   8
   9 #include <libmainloop/hooks.h>
  10 #include <libmainloop/signal.h>
  11 #include "common.h"
  12 #include "focus.h"
  13 #include "global.h"
  14 #include "window.h"
  15 #include "region.h"
  16 #include "frame.h"
  17 #include "colormap.h"
  18 #include "activity.h"
  19 #include "xwindow.h"
  20 #include "regbind.h"
  21 #include "log.h"
  22 #include "screen-notify.h"
  23
  24
  25 static void region_focuslist_awaiting_insertion_trigger(void);
  26
  27 /*{{{ Hooks. */
  28
  29
  30 WHook *region_do_warp_alt=NULL;
  31
  32
  33 /*}}}*/
  34
  35
  36 /*{{{ Focus list */
  37
  38
  39 void region_focuslist_remove_with_mgrs(WRegion *reg)
  40 {
  41     WRegion *mgrp=region_manager_or_parent(reg);
  42
  43     UNLINK_ITEM(ioncore_g.focuslist, reg, active_next, active_prev);
  44
  45     if(mgrp!=NULL)
  46         region_focuslist_remove_with_mgrs(mgrp);
  47 }
  48
  49
  50 void region_focuslist_push(WRegion *reg)
  51 {
  52     region_focuslist_remove_with_mgrs(reg);
  53     LINK_ITEM_FIRST(ioncore_g.focuslist, reg, active_next, active_prev);
  54 }
  55
  56
  57 void region_focuslist_move_after(WRegion *reg, WRegion *after)
  58 {
  59     region_focuslist_remove_with_mgrs(reg);
  60     LINK_ITEM_AFTER(ioncore_g.focuslist, after, reg,
  61                     active_next, active_prev);
  62 }
  63
  64
  65 static void region_focuslist_deinit(WRegion *reg)
  66 {
  67     WRegion *replace=region_manager_or_parent(reg);
  68
  69     if(replace!=NULL)
  70         region_focuslist_move_after(replace, reg);
  71
  72     UNLINK_ITEM(ioncore_g.focuslist, reg, active_next, active_prev);
  73 }
  74
  75
  76 /*EXTL_DOC
  77  * Go to and return to a previously active region (if any).
  78  *
  79  * Note that this function is asynchronous; the region will not
  80  * actually have received the focus when this function returns.
  81  */
  82 EXTL_EXPORT
  83 WRegion *ioncore_goto_previous()
  84 {
  85     WRegion *next;
  86
  87     if(ioncore_g.focuslist==NULL)
  88         return NULL;
  89
  90     /* We're trying to access the focus list from lua (likely from the UI). I
  91      * thus force any pending focuslist updates to complete now */
  92     region_focuslist_awaiting_insertion_trigger();
  93
  94     /* Find the first region on focus history list that isn't currently
  95      * active.
  96      */
  97     for(next=ioncore_g.focuslist->active_next;
  98         next!=NULL;
  99         next=next->active_next){
 100
 101         if(!REGION_IS_ACTIVE(next))
 102             break;
 103     }
 104
 105     if(next!=NULL)
 106         region_goto(next);
 107
 108     return next;
 109 }
 110
 111
 112 /*EXTL_DOC
 113  * Iterate over focus history until \var{iterfn} returns \code{false}.
 114  * The function is called in protected mode.
 115  * This routine returns \code{true} if it reaches the end of list
 116  * without this happening.
 117  */
 118 EXTL_EXPORT
 119 bool ioncore_focushistory_i(ExtlFn iterfn)
 120 {
 121     WRegion *next;
 122
 123     if(ioncore_g.focuslist==NULL)
 124         return FALSE;
 125
 126     /* We're trying to access the focus list from lua (likely from the UI). I
 127      * thus force any pending focuslist updates to complete now */
 128     region_focuslist_awaiting_insertion_trigger();
 129
 130     /* Find the first region on focus history list that isn't currently
 131      * active.
 132      */
 133     for(next=ioncore_g.focuslist->active_next;
 134         next!=NULL;
 135         next=next->active_next){
 136
 137         if(!extl_iter_obj(iterfn, (Obj*)next))
 138             return FALSE;
 139     }
 140
 141     return TRUE;
 142 }
 143
 144
 145 /*}}}*/
 146
 147
 148 /*{{{ Await focus */
 149
 150
 151 static Watch await_watch=WATCH_INIT;
 152
 153
 154 static void await_watch_handler(Watch *UNUSED(watch), WRegion *prev)
 155 {
 156     WRegion *r;
 157     while(1){
 158         r=REGION_PARENT_REG(prev);
 159         if(r==NULL)
 160             break;
 161
 162         if(watch_setup(&await_watch, (Obj*)r,
 163                        (WatchHandler*)await_watch_handler))
 164             break;
 165         prev=r;
 166     }
 167 }
 168
 169
 170 void region_set_await_focus(WRegion *reg)
 171 {
 172     if(reg==NULL){
 173         watch_reset(&await_watch);
 174     }else{
 175         watch_setup(&await_watch, (Obj*)reg,
 176                     (WatchHandler*)await_watch_handler);
 177     }
 178 }
 179
 180
 181 static bool region_is_parent(WRegion *reg, WRegion *aw)
 182 {
 183     while(aw!=NULL){
 184         if(aw==reg)
 185             return TRUE;
 186         aw=REGION_PARENT_REG(aw);
 187     }
 188
 189     return FALSE;
 190 }
 191
 192
 193 static bool region_is_await(WRegion *reg)
 194 {
 195     return region_is_parent(reg, (WRegion*)await_watch.obj);
 196 }
 197
 198
 199 static bool region_is_focusnext(WRegion *reg)
 200 {
 201     return region_is_parent(reg, ioncore_g.focus_next);
 202 }
 203
 204
 205 /* Only keep await status if focus event is to an ancestor of the await
 206  * region.
 207  */
 208 static void check_clear_await(WRegion *reg)
 209 {
 210     if(region_is_await(reg) && reg!=(WRegion*)await_watch.obj)
 211         return;
 212
 213     watch_reset(&await_watch);
 214 }
 215
 216
 217 WRegion *ioncore_await_focus()
 218 {
 219     return (WRegion*)(await_watch.obj);
 220 }
 221
 222
 223 /*}}}*/
 224
 225
 226 /*{{{ focuslist delayed insertion logic */
 227
 228 static WTimer*  focuslist_insert_timer=NULL;
 229 static WRegion* region_awaiting_insertion;
 230
 231 static void timer_expired__focuslist_insert(WTimer* UNUSED(dummy1), Obj* UNUSED(dummy2))
 232 {
 233   region_focuslist_push(region_awaiting_insertion);
 234   region_awaiting_insertion = NULL;
 235 }
 236
 237 static void schedule_focuslist_insert_timer(WRegion *reg)
 238 {
 239   /* if the delay is disabled, add to the list NOW */
 240   if( ioncore_g.focuslist_insert_delay <= 0 )
 241   {
 242     region_focuslist_push(reg);
 243     return;
 244   }
 245
 246   if( focuslist_insert_timer == NULL)
 247   {
 248     focuslist_insert_timer=create_timer();
 249     if( focuslist_insert_timer == NULL )
 250       return;
 251   }
 252
 253   region_awaiting_insertion = reg;
 254   timer_set(focuslist_insert_timer, ioncore_g.focuslist_insert_delay,
 255             (WTimerHandler*)timer_expired__focuslist_insert, NULL);
 256 }
 257
 258 static void region_focuslist_awaiting_insertion_cancel_if_is( WRegion* reg )
 259 {
 260     if( region_awaiting_insertion == reg &&
 261         focuslist_insert_timer    != NULL )
 262     {
 263         timer_reset(focuslist_insert_timer);
 264     }
 265 }
 266
 267 static void region_focuslist_awaiting_insertion_trigger(void)
 268 {
 269   if( focuslist_insert_timer    != NULL &&
 270       region_awaiting_insertion != NULL )
 271   {
 272     timer_expired__focuslist_insert(NULL,NULL);
 273     timer_reset(focuslist_insert_timer);
 274   }
 275 }
 276
 277
 278 /*}}}*/
 279
 280
 281 /*{{{ Events */
 282
 283
 284 void region_got_focus(WRegion *reg)
 285 {
 286     WRegion *par;
 287
 288     check_clear_await(reg);
 289
 290     region_set_activity(reg, SETPARAM_UNSET);
 291
 292     if(reg->active_sub==NULL)
 293     {
 294       /* I update the current focus indicator right now. The focuslist is
 295        * updated on a timer to keep the list ordered by importance (to keep
 296        * windows that the user quickly cycles through at the bottom of the list) */
 297       ioncore_g.focus_current = reg;
 298       schedule_focuslist_insert_timer(reg);
 299     }
 300
 301     if(!REGION_IS_ACTIVE(reg)){
 302         D(fprintf(stderr, "got focus (inact) %s [%p]\n", OBJ_TYPESTR(reg), reg);)
 303
 304         reg->flags|=REGION_ACTIVE;
 305         region_set_manager_pseudoactivity(reg);
 306
 307         par=REGION_PARENT_REG(reg);
 308         if(par!=NULL){
 309             par->active_sub=reg;
 310             region_update_owned_grabs(par);
 311         }
 312
 313         region_activated(reg);
 314         region_notify_change(reg, ioncore_g.notifies.activated);
 315     }else{
 316         D(fprintf(stderr, "got focus (act) %s [%p]\n", OBJ_TYPESTR(reg), reg);)
 317     }
 318
 319     /* Install default colour map only if there is no active subregion;
 320      * their maps should come first. WClientWins will install their maps
 321      * in region_activated. Other regions are supposed to use the same
 322      * default map.
 323      */
 324     if(reg->active_sub==NULL && !OBJ_IS(reg, WClientWin))
 325         rootwin_install_colormap(region_rootwin_of(reg), None);
 326
 327     screen_update_workspace_indicatorwin( reg );
 328 }
 329
 330
 331 void region_lost_focus(WRegion *reg)
 332 {
 333     WRegion *par;
 334
 335     if(!REGION_IS_ACTIVE(reg)){
 336         D(fprintf(stderr, "lost focus (inact) %s [%p:]\n", OBJ_TYPESTR(reg), reg);)
 337         return;
 338     }
 339
 340     par=REGION_PARENT_REG(reg);
 341     if(par!=NULL && par->active_sub==reg){
 342         par->active_sub=NULL;
 343         region_update_owned_grabs(par);
 344     }
 345
 346     D(fprintf(stderr, "lost focus (act) %s [%p:]\n", OBJ_TYPESTR(reg), reg);)
 347
 348     reg->flags&=~REGION_ACTIVE;
 349     region_unset_manager_pseudoactivity(reg);
 350
 351     region_inactivated(reg);
 352     region_notify_change(reg, ioncore_g.notifies.inactivated);
 353 }
 354
 355
 356 void region_focus_deinit(WRegion *reg)
 357 {
 358     /* if the region that's waiting to be added to the focuslist is being
 359      * deleted, cancel the insertion */
 360     if(region_awaiting_insertion)
 361         region_focuslist_awaiting_insertion_cancel_if_is(reg);
 362
 363     region_focuslist_deinit(reg);
 364
 365     if(ioncore_g.focus_current==reg)
 366         ioncore_g.focus_current=ioncore_g.focuslist;
 367 }
 368
 369
 370 /*}}}*/
 371
 372
 373 /*{{{ Focus status requests */
 374
 375
 376 /*EXTL_DOC
 377  * Is \var{reg} active/does it or one of it's children of focus?
 378  */
 379 EXTL_SAFE
 380 EXTL_EXPORT_MEMBER
 381 bool region_is_active(WRegion *reg, bool pseudoact_ok)
 382 {
 383     return (REGION_IS_ACTIVE(reg) ||
 384             (pseudoact_ok && REGION_IS_PSEUDOACTIVE(reg)));
 385 }
 386
 387
 388 bool region_manager_is_focusnext(WRegion *reg)
 389 {
 390     if(reg==NULL || ioncore_g.focus_next==NULL)
 391         return FALSE;
 392
 393     if(reg==ioncore_g.focus_next)
 394         return TRUE;
 395
 396     return region_manager_is_focusnext(REGION_MANAGER(reg));
 397 }
 398
 399
 400 bool region_may_control_focus(WRegion *reg)
 401 {
 402     if(OBJ_IS_BEING_DESTROYED(reg))
 403         return FALSE;
 404
 405     if(REGION_IS_ACTIVE(reg) || REGION_IS_PSEUDOACTIVE(reg))
 406         return TRUE;
 407
 408     if(region_is_await(reg) || region_is_focusnext(reg))
 409         return TRUE;
 410
 411     if(region_manager_is_focusnext(reg))
 412         return TRUE;
 413
 414     return FALSE;
 415 }
 416
 417
 418 /*}}}*/
 419
 420
 421 /*{{{ set_focus, warp */
 422
 423
 424 /*Time ioncore_focus_time=CurrentTime;*/
 425
 426 bool ioncore_should_focus_parent_when_refusing_focus(WRegion* reg){
 427     WWindow* parent = reg->parent;
 428
 429     LOG(DEBUG, FOCUS, "Region %s refusing focus", reg->ni.name);
 430
 431     if(parent==NULL)
 432         return FALSE;
 433
 434     /**
 435      * If the region is refusing focus, this might be because the mouse
 436      * entered it but it doesn't accept any focus (like in the case of
 437      * oclock). In that case we want to focus its parent WTiling, if any.
 438      *
 439      * However, when for example IntelliJ IDEA's main window is refusing
 440      * the focus because some transient completion popup is open, we want
 441      * to leave the focus alone.
 442      */
 443     LOG(DEBUG, FOCUS, "Parent is %s", parent->region.ni.name);
 444
 445     if (obj_is((Obj*)parent, &CLASSDESCR(WFrame))
 446         && ((WFrame*)parent)->mode == FRAME_MODE_TILED) {
 447         LOG(DEBUG, FOCUS, "Parent %s is a tiled WFrame", parent->region.ni.name);
 448         return TRUE;
 449     }
 450
 451     return FALSE;
 452 }
 453
 454 void region_finalise_focusing(WRegion* reg, Window win, bool warp, Time time, int set_input) {
 455     if(warp)
 456         region_do_warp(reg);
 457
 458     if(REGION_IS_ACTIVE(reg) && ioncore_await_focus()==NULL)
 459         return;
 460
 461     region_set_await_focus(reg);
 462
 463     if(set_input)
 464         XSetInputFocus(ioncore_g.dpy, win, RevertToParent, time);
 465     else if(ioncore_should_focus_parent_when_refusing_focus(reg)) {
 466         XSetInputFocus(ioncore_g.dpy, reg->parent->win, RevertToParent, time);
 467    }
 468 }
 469
 470
 471
 472 static WRegion *find_warp_to_reg(WRegion *reg)
 473 {
 474     if(reg==NULL)
 475         return NULL;
 476     if(reg->flags&REGION_PLEASE_WARP)
 477         return reg;
 478     return find_warp_to_reg(region_manager_or_parent(reg));
 479 }
 480
 481
 482 bool region_do_warp_default(WRegion *reg)
 483 {
 484     int x, y, w, h, px=0, py=0;
 485     WRootWin *root;
 486
 487     reg=find_warp_to_reg(reg);
 488
 489     if(reg==NULL)
 490         return FALSE;
 491
 492     D(fprintf(stderr, "region_do_warp %p %s\n", reg, OBJ_TYPESTR(reg)));
 493
 494     root=region_rootwin_of(reg);
 495
 496     region_rootpos(reg, &x, &y);
 497     w=REGION_GEOM(reg).w;
 498     h=REGION_GEOM(reg).h;
 499
 500     if(xwindow_pointer_pos(WROOTWIN_ROOT(root), &px, &py)){
 501         if(px>=x && py>=y && px<x+w && py<y+h)
 502             return TRUE;
 503     }
 504
 505     rootwin_warp_pointer(root, x+5, y+5);
 506
 507     return TRUE;
 508 }
 509
 510
 511 void region_do_warp(WRegion *reg)
 512 {
 513     extl_protect(NULL);
 514     hook_call_alt_o(region_do_warp_alt, (Obj*)reg);
 515     extl_unprotect(NULL);
 516 }
 517
 518
 519 void region_maybewarp(WRegion *reg, bool warp)
 520 {
 521     ioncore_g.focus_next=reg;
 522     ioncore_g.focus_next_source=IONCORE_FOCUSNEXT_OTHER;
 523     ioncore_g.warp_next=(warp && ioncore_g.warp_enabled);
 524 }
 525
 526
 527 void region_maybewarp_now(WRegion *reg, bool warp)
 528 {
 529     ioncore_g.focus_next=NULL;
 530     /* TODO: what if focus isn't set? Should focus_next be reset then? */
 531     region_do_set_focus(reg, warp && ioncore_g.warp_enabled);
 532 }
 533
 534
 535 void region_set_focus(WRegion *reg)
 536 {
 537     region_maybewarp(reg, FALSE);
 538 }
 539
 540
 541 void region_warp(WRegion *reg)
 542 {
 543     region_maybewarp(reg, TRUE);
 544 }
 545
 546
 547 /*}}}*/
 548
 549
 550 /*{{{ Misc. */
 551
 552
 553 bool region_skip_focus(WRegion *reg)
 554 {
 555     while(reg!=NULL){
 556         if(reg->flags&REGION_SKIP_FOCUS)
 557             return TRUE;
 558         reg=REGION_PARENT_REG(reg);
 559     }
 560     return FALSE;
 561 }
 562
 563 /*EXTL_DOC
 564  * Returns the currently focused region, if any.
 565  */
 566 EXTL_EXPORT
 567 WRegion *ioncore_current()
 568 {
 569     return ioncore_g.focus_current;
 570 }
 571
 572
 573 /*}}}*/
 574
 575
 576 /*{{{ Pointer focus hack */
 577
 578
 579 /* This ugly hack tries to prevent focus change, when the pointer is
 580  * in a window to be unmapped (or destroyed), and that does not have
 581  * the focus, or should not soon have it.
 582  */
 583 void region_pointer_focus_hack(WRegion *reg)
 584 {
 585     WRegion *act;
 586
 587     if(ioncore_g.opmode!=IONCORE_OPMODE_NORMAL)
 588         return;
 589
 590     if(ioncore_g.focus_next!=NULL &&
 591        ioncore_g.focus_next_source<=IONCORE_FOCUSNEXT_POINTERHACK){
 592         return;
 593     }
 594
 595     act=ioncore_await_focus();
 596
 597     if((REGION_IS_ACTIVE(reg) && act==NULL) || !region_is_fully_mapped(reg))
 598         return;
 599
 600     if(act==NULL)
 601         act=ioncore_g.focus_current;
 602
 603     if(act==NULL ||
 604        OBJ_IS_BEING_DESTROYED(act) ||
 605        !region_is_fully_mapped(act) ||
 606        region_skip_focus(act)){
 607         return;
 608     }
 609
 610     region_set_focus(act);
 611     ioncore_g.focus_next_source=IONCORE_FOCUSNEXT_POINTERHACK;
 612 }
 613
 614
 615 /*}}}*/
 616
 617 /*{{{ Debug printers */
 618
 619 void region_focuslist_debugprint(void)
 620 {
 621   WRegion* reg;
 622
 623   LOG(DEBUG, GENERAL, "focus list start =========================");
 624   LOG(DEBUG, GENERAL, "currently-focused region ");
 625   region_debugprint_parents( ioncore_g.focus_current );
 626   LOG(DEBUG, GENERAL, "");
 627
 628   LOG(DEBUG, GENERAL, "top-of-focuslist ");
 629   region_debugprint_parents( ioncore_g.focuslist );
 630   LOG(DEBUG, GENERAL, "");
 631
 632   reg = ioncore_g.focuslist;
 633   while(1)
 634   {
 635     LOG(DEBUG, GENERAL, "%p (%s)", (void*)reg, reg != NULL ? reg->ni.name : "NULL");
 636
 637     if( reg              == NULL             ||
 638         reg->active_next == NULL             ||
 639         reg              == reg->active_next )
 640     {
 641       break;
 642     }
 643
 644     reg = reg->active_next;
 645   }
 646
 647   LOG(DEBUG, GENERAL, "focus list end =========================");
 648 }
 649
 650 /*}}}*/