src/switchmenu.c

   1 /*
   2  *  Window Maker window manager
   3  *
   4  *  Copyright (c) 1997 Shige Abe and
   5  *                     Alfredo K. Kojima
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  20  *  USA.
  21  */
  22
  23
  24 #include "wconfig.h"
  25
  26 #ifndef LITE
  27
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31
  32 #include <X11/Xlib.h>
  33 #include <X11/Xutil.h>
  34
  35 #include "WindowMaker.h"
  36 #include "window.h"
  37 #include "actions.h"
  38 #include "client.h"
  39 #include "funcs.h"
  40 #include "stacking.h"
  41 #include "workspace.h"
  42 #include "framewin.h"
  43
  44 /********* Global Variables *******/
  45 extern WPreferences wPreferences;
  46 extern Time LastTimestamp;
  47
  48
  49 /*
  50  * FocusWindow
  51  *
  52  *  - Needs to check if already in the right workspace before
  53  *    calling wChangeWorkspace?
  54  *
  55  *  Order:
  56  *    Switch to correct workspace
  57  *    Unshade if shaded
  58  *    If iconified then deiconify else focus/raise.
  59  */
  60 static void
  61 focusWindow(WMenu *menu, WMenuEntry *entry)
  62 {
  63     WWindow *wwin;
  64     WScreen *scr;
  65     int x, y, move=0;
  66
  67     wwin = (WWindow*)entry->clientdata;
  68     scr = wwin->screen_ptr;
  69
  70     wMakeWindowVisible(wwin);
  71
  72     x = wwin->frame_x;
  73     y = wwin->frame_y;
  74
  75     /* bring window back to visible area */
  76     move = wScreenBringInside(scr, &x, &y, wwin->frame->core->width,
  77                               wwin->frame->core->height);
  78
  79     if (move) {
  80         wWindowConfigure(wwin, x, y, wwin->client.width, wwin->client.height);
  81     }
  82 }
  83
  84 /*
  85  *
  86  * Open switch menu
  87  *
  88  */
  89 void
  90 OpenSwitchMenu(WScreen *scr, int x, int y, int keyboard)
  91 {
  92     WMenu *switchmenu = scr->switch_menu;
  93     WWindow *wwin;
  94
  95     if (switchmenu) {
  96         if (switchmenu->flags.mapped) {
  97             if (!switchmenu->flags.buttoned) {
  98                 wMenuUnmap(switchmenu);
  99             } else {
 100                 wRaiseFrame(switchmenu->frame->core);
 101
 102                 if (keyboard)
 103                     wMenuMapAt(switchmenu, 0, 0, True);
 104                 else
 105                     wMenuMapCopyAt(switchmenu,
 106                                    x-switchmenu->frame->core->width/2, y);
 107             }
 108         } else {
 109             wMenuMapAt(switchmenu, x-switchmenu->frame->core->width/2, y,
 110                        keyboard);
 111         }
 112         return;
 113     }
 114     switchmenu = wMenuCreate(scr,_("Windows"),True);
 115     scr->switch_menu = switchmenu;
 116
 117
 118     wwin = scr->focused_window;
 119     while (wwin) {
 120         UpdateSwitchMenu(scr, wwin, ACTION_ADD);
 121
 122         wwin = wwin->prev;
 123     }
 124
 125     if (switchmenu) {
 126         int newx, newy;
 127
 128         if (!switchmenu->flags.realized)
 129             wMenuRealize(switchmenu);
 130
 131         if (keyboard && x==0 && y==0) {
 132             newx = newy = 0;
 133         } else if (keyboard && x==scr->scr_width/2 && y==scr->scr_height/2) {
 134             newx = x - switchmenu->frame->core->width/2;
 135             newy = y - switchmenu->frame->core->height/2;
 136         } else {
 137             newx = x - switchmenu->frame->core->width/2;
 138             newy = y;
 139         }
 140         wMenuMapAt(switchmenu, newx, newy, keyboard);
 141     }
 142 }
 143
 144
 145 static int
 146 menuIndexForWindow(WMenu *menu, WWindow *wwin, int old_pos)
 147 {
 148     int idx;
 149
 150     if (menu->entry_no == 0)
 151         return -1;
 152
 153 #define WS(i)  ((WWindow*)menu->entries[i]->clientdata)->frame->workspace
 154     if (old_pos >= 0) {
 155         if (WS(old_pos) >= wwin->frame->workspace
 156             && (old_pos == 0 || WS(old_pos-1) <= wwin->frame->workspace)) {
 157             return old_pos;
 158         }
 159     }
 160 #undef WS
 161
 162     for (idx = 0; idx < menu->entry_no; idx++) {
 163         WWindow *tw = (WWindow*)menu->entries[idx]->clientdata;
 164
 165         if (!IS_OMNIPRESENT(tw)
 166             && tw->frame->workspace > wwin->frame->workspace) {
 167             break;
 168         }
 169     }
 170
 171     return idx;
 172 }
 173
 174
 175 /*
 176  * Update switch menu
 177  */
 178 void
 179 UpdateSwitchMenu(WScreen *scr, WWindow *wwin, int action)
 180 {
 181     WMenu *switchmenu = scr->switch_menu;
 182     WMenuEntry *entry;
 183     char title[MAX_MENU_TEXT_LENGTH+6];
 184     int len = MAX_MENU_TEXT_LENGTH+6;
 185     int i;
 186     int checkVisibility = 0;
 187
 188     if (!wwin->screen_ptr->switch_menu)
 189       return;
 190     /*
 191      *  This menu is updated under the following conditions:
 192      *
 193      *    1.  When a window is created.
 194      *    2.  When a window is destroyed.
 195      *
 196      *    3.  When a window changes it's title.
 197      *    4.  When a window changes its workspace.
 198      */
 199     if (action == ACTION_ADD) {
 200         char *t;
 201         int idx;
 202
 203         if (wwin->flags.internal_window || WFLAGP(wwin, skip_window_list))
 204             return;
 205
 206         if (wwin->frame->title)
 207           snprintf(title, len, "%s", wwin->frame->title);
 208         else
 209           snprintf(title, len, "%s", DEF_WINDOW_TITLE);
 210         t = ShrinkString(scr->menu_entry_font, title, MAX_WINDOWLIST_WIDTH);
 211
 212         if (IS_OMNIPRESENT(wwin))
 213             idx = -1;
 214         else {
 215             idx = menuIndexForWindow(switchmenu, wwin, -1);
 216         }
 217
 218         entry = wMenuInsertCallback(switchmenu, idx, t, focusWindow, wwin);
 219         wfree(t);
 220
 221         entry->flags.indicator = 1;
 222         entry->rtext = wmalloc(MAX_WORKSPACENAME_WIDTH+8);
 223         if (IS_OMNIPRESENT(wwin))
 224             snprintf(entry->rtext, MAX_WORKSPACENAME_WIDTH, "[*]");
 225         else
 226             snprintf(entry->rtext, MAX_WORKSPACENAME_WIDTH, "[%s]",
 227                     scr->workspaces[wwin->frame->workspace]->name);
 228
 229         if (wwin->flags.hidden) {
 230             entry->flags.indicator_type = MI_HIDDEN;
 231             entry->flags.indicator_on = 1;
 232         } else if (wwin->flags.miniaturized) {
 233             entry->flags.indicator_type = MI_MINIWINDOW;
 234             entry->flags.indicator_on = 1;
 235         } else if (wwin->flags.focused) {
 236             entry->flags.indicator_type = MI_DIAMOND;
 237             entry->flags.indicator_on = 1;
 238         } else if (wwin->flags.shaded) {
 239             entry->flags.indicator_type = MI_SHADED;
 240             entry->flags.indicator_on = 1;
 241         }
 242
 243         wMenuRealize(switchmenu);
 244         checkVisibility = 1;
 245     } else {
 246         char *t;
 247         for (i=0; i<switchmenu->entry_no; i++) {
 248             entry = switchmenu->entries[i];
 249             /* this is the entry that was changed */
 250             if (entry->clientdata == wwin) {
 251                 switch (action) {
 252                  case ACTION_REMOVE:
 253                     wMenuRemoveItem(switchmenu, i);
 254                     wMenuRealize(switchmenu);
 255                     checkVisibility = 1;
 256                     break;
 257
 258                  case ACTION_CHANGE:
 259                     if (entry->text)
 260                       wfree(entry->text);
 261
 262                     if (wwin->frame->title)
 263                         snprintf(title, MAX_MENU_TEXT_LENGTH, "%s",
 264                                  wwin->frame->title);
 265                     else
 266                         snprintf(title, MAX_MENU_TEXT_LENGTH, "%s",
 267                                  DEF_WINDOW_TITLE);
 268
 269                     t = ShrinkString(scr->menu_entry_font, title, MAX_WINDOWLIST_WIDTH);
 270                     entry->text = t;
 271
 272                     wMenuRealize(switchmenu);
 273                     checkVisibility = 1;
 274                     break;
 275
 276                  case ACTION_CHANGE_WORKSPACE:
 277                     if (entry->rtext) {
 278                         int idx = -1;
 279                         char *t, *rt;
 280                         int it, ion;
 281
 282                         if (IS_OMNIPRESENT(wwin)) {
 283                             snprintf(entry->rtext, MAX_WORKSPACENAME_WIDTH,
 284                                      "[*]");
 285                         } else {
 286                             snprintf(entry->rtext, MAX_WORKSPACENAME_WIDTH,
 287                                      "[%s]", scr->workspaces[wwin->frame->workspace]->name);
 288                         }
 289
 290                         rt = entry->rtext;
 291                         entry->rtext = NULL;
 292                         t = entry->text;
 293                         entry->text = NULL;
 294
 295                         it = entry->flags.indicator_type;
 296                         ion = entry->flags.indicator_on;
 297
 298                         wMenuRemoveItem(switchmenu, i);
 299
 300                         if (!IS_OMNIPRESENT(wwin) && idx < 0) {
 301                             idx = menuIndexForWindow(switchmenu, wwin, i);
 302                         }
 303
 304                         entry = wMenuInsertCallback(switchmenu, idx, t,
 305                                                     focusWindow, wwin);
 306                         wfree(t);
 307                         entry->rtext = rt;
 308                         entry->flags.indicator = 1;
 309                         entry->flags.indicator_type = it;
 310                         entry->flags.indicator_on = ion;
 311                     }
 312                     wMenuRealize(switchmenu);
 313                     checkVisibility = 1;
 314                     break;
 315
 316
 317                  case ACTION_CHANGE_STATE:
 318                     if (wwin->flags.hidden) {
 319                         entry->flags.indicator_type = MI_HIDDEN;
 320                         entry->flags.indicator_on = 1;
 321                     } else if (wwin->flags.miniaturized) {
 322                         entry->flags.indicator_type = MI_MINIWINDOW;
 323                         entry->flags.indicator_on = 1;
 324                     } else if (wwin->flags.shaded && !wwin->flags.focused) {
 325                         entry->flags.indicator_type = MI_SHADED;
 326                         entry->flags.indicator_on = 1;
 327                     } else {
 328                         entry->flags.indicator_on = wwin->flags.focused;
 329                         entry->flags.indicator_type = MI_DIAMOND;
 330                     }
 331                     break;
 332                 }
 333                 break;
 334             }
 335         }
 336     }
 337     if (checkVisibility) {
 338         int tmp;
 339
 340         tmp = switchmenu->frame->top_width + 5;
 341         /* if menu got unreachable, bring it to a visible place */
 342         if (switchmenu->frame_x < tmp - (int)switchmenu->frame->core->width) {
 343             wMenuMove(switchmenu, tmp - (int)switchmenu->frame->core->width,
 344                       switchmenu->frame_y, False);
 345         }
 346     }
 347     wMenuPaint(switchmenu);
 348 }
 349
 350
 351
 352 void
 353 UpdateSwitchMenuWorkspace(WScreen *scr, int workspace)
 354 {
 355     WMenu *menu = scr->switch_menu;
 356     int i;
 357     WWindow *wwin;
 358
 359     if (!menu)
 360         return;
 361
 362     for (i=0; i<menu->entry_no; i++) {
 363         wwin = (WWindow*)menu->entries[i]->clientdata;
 364
 365         if (wwin->frame->workspace==workspace
 366             && !IS_OMNIPRESENT(wwin)) {
 367             if (IS_OMNIPRESENT(wwin))
 368                 snprintf(menu->entries[i]->rtext, MAX_WORKSPACENAME_WIDTH,"[*]");
 369             else
 370                 snprintf(menu->entries[i]->rtext, MAX_WORKSPACENAME_WIDTH,"[%s]",
 371                         scr->workspaces[wwin->frame->workspace]->name);
 372             menu->flags.realized = 0;
 373         }
 374     }
 375     if (!menu->flags.realized)
 376         wMenuRealize(menu);
 377 }
 378
 379
 380 #endif /* !LITE */