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         if (!switchmenu->flags.realized)
 127             wMenuRealize(switchmenu);
 128         wMenuMapAt(switchmenu, x-switchmenu->frame->core->width/2, y,
 129                    keyboard);
 130     }
 131 }
 132
 133
 134 static int
 135 menuIndexForWindow(WMenu *menu, WWindow *wwin, int old_pos)
 136 {
 137     int idx;
 138
 139     if (menu->entry_no == 0)
 140         return -1;
 141
 142 #define WS(i)  ((WWindow*)menu->entries[i]->clientdata)->frame->workspace
 143     if (old_pos >= 0) {
 144         if (WS(old_pos) >= wwin->frame->workspace
 145             && (old_pos == 0 || WS(old_pos-1) <= wwin->frame->workspace)) {
 146             return old_pos;
 147         }
 148     }
 149 #undef WS
 150
 151     for (idx = 0; idx < menu->entry_no; idx++) {
 152         WWindow *tw = (WWindow*)menu->entries[idx]->clientdata;
 153
 154         if (!IS_OMNIPRESENT(tw)
 155             && tw->frame->workspace > wwin->frame->workspace) {
 156             break;
 157         }
 158     }
 159
 160     return idx;
 161 }
 162
 163
 164 /*
 165  * Update switch menu
 166  */
 167 void
 168 UpdateSwitchMenu(WScreen *scr, WWindow *wwin, int action)
 169 {
 170     WMenu *switchmenu = scr->switch_menu;
 171     WMenuEntry *entry;
 172     char title[MAX_MENU_TEXT_LENGTH+6];
 173     int i;
 174     int checkVisibility = 0;
 175
 176     if (!wwin->screen_ptr->switch_menu)
 177       return;
 178     /*
 179      *  This menu is updated under the following conditions:
 180      *
 181      *    1.  When a window is created.
 182      *    2.  When a window is destroyed.
 183      *
 184      *    3.  When a window changes it's title.
 185      *    4.  When a window changes its workspace.
 186      */
 187     if (action == ACTION_ADD) {
 188         char *t;
 189         int idx;
 190
 191         if (wwin->flags.internal_window || WFLAGP(wwin, skip_window_list))
 192             return;
 193
 194         if (wwin->frame->title)
 195           sprintf(title, "%s", wwin->frame->title);
 196         else
 197           sprintf(title, "%s", DEF_WINDOW_TITLE);
 198 #ifdef DRAWSTRING_PLUGIN
 199         t = ShrinkString(scr->menu_entry_font, title, MAX_WINDOWLIST_WIDTH,
 200             scr->drawstring_func[W_STRING_MTEXT]);
 201 #else
 202         t = ShrinkString(scr->menu_entry_font, title, MAX_WINDOWLIST_WIDTH);
 203 #endif
 204
 205         if (IS_OMNIPRESENT(wwin))
 206             idx = -1;
 207         else {
 208             idx = menuIndexForWindow(switchmenu, wwin, -1);
 209         }
 210
 211         entry = wMenuInsertCallback(switchmenu, idx, t, focusWindow, wwin);
 212         wfree(t);
 213
 214         entry->flags.indicator = 1;
 215         entry->rtext = wmalloc(MAX_WORKSPACENAME_WIDTH+8);
 216         if (IS_OMNIPRESENT(wwin))
 217             sprintf(entry->rtext, "[*]");
 218         else
 219             sprintf(entry->rtext, "[%s]",
 220                     scr->workspaces[wwin->frame->workspace]->name);
 221
 222         if (wwin->flags.hidden) {
 223             entry->flags.indicator_type = MI_HIDDEN;
 224             entry->flags.indicator_on = 1;
 225         } else if (wwin->flags.miniaturized) {
 226             entry->flags.indicator_type = MI_MINIWINDOW;
 227             entry->flags.indicator_on = 1;
 228         } else if (wwin->flags.focused) {
 229             entry->flags.indicator_type = MI_DIAMOND;
 230             entry->flags.indicator_on = 1;
 231         } else if (wwin->flags.shaded) {
 232             entry->flags.indicator_type = MI_SHADED;
 233             entry->flags.indicator_on = 1;
 234         }
 235
 236         wMenuRealize(switchmenu);
 237         checkVisibility = 1;
 238     } else {
 239         char *t;
 240         for (i=0; i<switchmenu->entry_no; i++) {
 241             entry = switchmenu->entries[i];
 242             /* this is the entry that was changed */
 243             if (entry->clientdata == wwin) {
 244                 switch (action) {
 245                  case ACTION_REMOVE:
 246                     wMenuRemoveItem(switchmenu, i);
 247                     wMenuRealize(switchmenu);
 248                     checkVisibility = 1;
 249                     break;
 250
 251                  case ACTION_CHANGE:
 252                     if (entry->text)
 253                       wfree(entry->text);
 254
 255                     if (wwin->frame->title)
 256                       sprintf(title, "%s", wwin->frame->title);
 257                     else
 258                       sprintf(title, "%s", DEF_WINDOW_TITLE);
 259
 260 #ifdef DRAWSTRING_PLUGIN
 261             t = ShrinkString(scr->menu_entry_font, title, MAX_WINDOWLIST_WIDTH,
 262                     scr->drawstring_func[W_STRING_MTEXT]);
 263 #else
 264                     t = ShrinkString(scr->menu_entry_font, title, MAX_WINDOWLIST_WIDTH);
 265 #endif
 266                     entry->text = t;
 267
 268                     wMenuRealize(switchmenu);
 269                     checkVisibility = 1;
 270                     break;
 271
 272                  case ACTION_CHANGE_WORKSPACE:
 273                     if (entry->rtext) {
 274                         int idx = -1;
 275                         char *t, *rt;
 276                         int it, ion;
 277
 278                         if (IS_OMNIPRESENT(wwin)) {
 279                             sprintf(entry->rtext, "[*]");
 280                         } else {
 281                             sprintf(entry->rtext, "[%s]",
 282                                     scr->workspaces[wwin->frame->workspace]->name);
 283                         }
 284
 285                         rt = entry->rtext;
 286                         entry->rtext = NULL;
 287                         t = entry->text;
 288                         entry->text = NULL;
 289
 290                         it = entry->flags.indicator_type;
 291                         ion = entry->flags.indicator_on;
 292
 293                         wMenuRemoveItem(switchmenu, i);
 294
 295                         if (!IS_OMNIPRESENT(wwin) && idx < 0) {
 296                             idx = menuIndexForWindow(switchmenu, wwin, i);
 297                         }
 298
 299                         entry = wMenuInsertCallback(switchmenu, idx, t,
 300                                                     focusWindow, wwin);
 301                         wfree(t);
 302                         entry->rtext = rt;
 303                         entry->flags.indicator = 1;
 304                         entry->flags.indicator_type = it;
 305                         entry->flags.indicator_on = ion;
 306                     }
 307                     wMenuRealize(switchmenu);
 308                     checkVisibility = 1;
 309                     break;
 310
 311
 312                  case ACTION_CHANGE_STATE:
 313                     if (wwin->flags.hidden) {
 314                         entry->flags.indicator_type = MI_HIDDEN;
 315                         entry->flags.indicator_on = 1;
 316                     } else if (wwin->flags.miniaturized) {
 317                         entry->flags.indicator_type = MI_MINIWINDOW;
 318                         entry->flags.indicator_on = 1;
 319                     } else if (wwin->flags.shaded && !wwin->flags.focused) {
 320                         entry->flags.indicator_type = MI_SHADED;
 321                         entry->flags.indicator_on = 1;
 322                     } else {
 323                         entry->flags.indicator_on = wwin->flags.focused;
 324                         entry->flags.indicator_type = MI_DIAMOND;
 325                     }
 326                     break;
 327                 }
 328                 break;
 329             }
 330         }
 331     }
 332     if (checkVisibility) {
 333         int tmp;
 334
 335         tmp = switchmenu->frame->top_width + 5;
 336         /* if menu got unreachable, bring it to a visible place */
 337         if (switchmenu->frame_x < tmp - (int)switchmenu->frame->core->width) {
 338             wMenuMove(switchmenu, tmp - (int)switchmenu->frame->core->width,
 339                       switchmenu->frame_y, False);
 340         }
 341     }
 342     wMenuPaint(switchmenu);
 343 }
 344
 345
 346
 347 void
 348 UpdateSwitchMenuWorkspace(WScreen *scr, int workspace)
 349 {
 350     WMenu *menu = scr->switch_menu;
 351     int i;
 352     WWindow *wwin;
 353
 354     if (!menu)
 355         return;
 356
 357     for (i=0; i<menu->entry_no; i++) {
 358         wwin = (WWindow*)menu->entries[i]->clientdata;
 359
 360         if (wwin->frame->workspace==workspace
 361             && !IS_OMNIPRESENT(wwin)) {
 362             if (IS_OMNIPRESENT(wwin))
 363                 sprintf(menu->entries[i]->rtext, "[*]");
 364             else
 365                 sprintf(menu->entries[i]->rtext, "[%s]",
 366                         scr->workspaces[wwin->frame->workspace]->name);
 367             menu->flags.realized = 0;
 368         }
 369     }
 370     if (!menu->flags.realized)
 371         wMenuRealize(menu);
 372 }
 373
 374
 375 #endif /* !LITE */