src/switchmenu.c

   1 /*
   2  *  Window Maker window manager
   3  *
   4  *  Copyright (c) 1997      Shige Abe
   5  *  Copyright (c) 1997-2003 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 #include "wconfig.h"
  24
  25 #ifndef LITE
  26
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <stdint.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 static int initialized = 0;
  49
  50 static void observer(void *self, WMNotification * notif);
  51 static void wsobserver(void *self, WMNotification * notif);
  52
  53 /*
  54  * FocusWindow
  55  *
  56  *  - Needs to check if already in the right workspace before
  57  *    calling wChangeWorkspace?
  58  *
  59  *  Order:
  60  *    Switch to correct workspace
  61  *    Unshade if shaded
  62  *    If iconified then deiconify else focus/raise.
  63  */
  64 static void focusWindow(WMenu * menu, WMenuEntry * entry)
  65 {
  66         WWindow *wwin;
  67         WScreen *scr;
  68         int x, y, move = 0;
  69
  70         wwin = (WWindow *) entry->clientdata;
  71         scr = wwin->screen_ptr;
  72
  73         wMakeWindowVisible(wwin);
  74
  75         x = wwin->frame_x;
  76         y = wwin->frame_y;
  77
  78         /* bring window back to visible area */
  79         move = wScreenBringInside(scr, &x, &y, wwin->frame->core->width, wwin->frame->core->height);
  80
  81         if (move) {
  82                 wWindowConfigure(wwin, x, y, wwin->client.width, wwin->client.height);
  83         }
  84 }
  85
  86 void InitializeSwitchMenu()
  87 {
  88         if (!initialized) {
  89                 initialized = 1;
  90
  91                 WMAddNotificationObserver(observer, NULL, WMNManaged, NULL);
  92                 WMAddNotificationObserver(observer, NULL, WMNUnmanaged, NULL);
  93                 WMAddNotificationObserver(observer, NULL, WMNChangedWorkspace, NULL);
  94                 WMAddNotificationObserver(observer, NULL, WMNChangedState, NULL);
  95                 WMAddNotificationObserver(observer, NULL, WMNChangedFocus, NULL);
  96                 WMAddNotificationObserver(observer, NULL, WMNChangedStacking, NULL);
  97                 WMAddNotificationObserver(observer, NULL, WMNChangedName, NULL);
  98
  99                 WMAddNotificationObserver(wsobserver, NULL, WMNWorkspaceChanged, NULL);
 100                 WMAddNotificationObserver(wsobserver, NULL, WMNWorkspaceNameChanged, NULL);
 101         }
 102 }
 103
 104 /*
 105  *
 106  * Open switch menu
 107  *
 108  */
 109 void OpenSwitchMenu(WScreen * scr, int x, int y, int keyboard)
 110 {
 111         WMenu *switchmenu = scr->switch_menu;
 112         WWindow *wwin;
 113
 114         if (switchmenu) {
 115                 if (switchmenu->flags.mapped) {
 116                         if (!switchmenu->flags.buttoned) {
 117                                 wMenuUnmap(switchmenu);
 118                         } else {
 119                                 wRaiseFrame(switchmenu->frame->core);
 120
 121                                 if (keyboard)
 122                                         wMenuMapAt(switchmenu, 0, 0, True);
 123                                 else
 124                                         wMenuMapCopyAt(switchmenu, x - switchmenu->frame->core->width / 2, y);
 125                         }
 126                 } else {
 127                         if (keyboard && x == scr->scr_width / 2 && y == scr->scr_height / 2) {
 128                                 y = y - switchmenu->frame->core->height / 2;
 129                         }
 130                         wMenuMapAt(switchmenu, x - switchmenu->frame->core->width / 2, y, keyboard);
 131                 }
 132                 return;
 133         }
 134         switchmenu = wMenuCreate(scr, _("Windows"), True);
 135         scr->switch_menu = switchmenu;
 136
 137         wwin = scr->focused_window;
 138         while (wwin) {
 139                 UpdateSwitchMenu(scr, wwin, ACTION_ADD);
 140
 141                 wwin = wwin->prev;
 142         }
 143
 144         if (switchmenu) {
 145                 int newx, newy;
 146
 147                 if (!switchmenu->flags.realized)
 148                         wMenuRealize(switchmenu);
 149
 150                 if (keyboard && x == 0 && y == 0) {
 151                         newx = newy = 0;
 152                 } else if (keyboard && x == scr->scr_width / 2 && y == scr->scr_height / 2) {
 153                         newx = x - switchmenu->frame->core->width / 2;
 154                         newy = y - switchmenu->frame->core->height / 2;
 155                 } else {
 156                         newx = x - switchmenu->frame->core->width / 2;
 157                         newy = y;
 158                 }
 159                 wMenuMapAt(switchmenu, newx, newy, keyboard);
 160         }
 161 }
 162
 163 static int menuIndexForWindow(WMenu * menu, WWindow * wwin, int old_pos)
 164 {
 165         int idx;
 166
 167         if (menu->entry_no <= old_pos)
 168                 return -1;
 169
 170 #define WS(i)  ((WWindow*)menu->entries[i]->clientdata)->frame->workspace
 171         if (old_pos >= 0) {
 172                 if (WS(old_pos) >= wwin->frame->workspace
 173                     && (old_pos == 0 || WS(old_pos - 1) <= wwin->frame->workspace)) {
 174                         return old_pos;
 175                 }
 176         }
 177 #undef WS
 178
 179         for (idx = 0; idx < menu->entry_no; idx++) {
 180                 WWindow *tw = (WWindow *) menu->entries[idx]->clientdata;
 181
 182                 if (!IS_OMNIPRESENT(tw)
 183                     && tw->frame->workspace > wwin->frame->workspace) {
 184                         break;
 185                 }
 186         }
 187
 188         return idx;
 189 }
 190
 191 /*
 192  * Update switch menu
 193  */
 194 void UpdateSwitchMenu(WScreen * scr, WWindow * wwin, int action)
 195 {
 196         WMenu *switchmenu = scr->switch_menu;
 197         WMenuEntry *entry;
 198         char title[MAX_MENU_TEXT_LENGTH + 6];
 199         int len = sizeof(title);
 200         int i;
 201         int checkVisibility = 0;
 202
 203         if (!wwin->screen_ptr->switch_menu)
 204                 return;
 205         /*
 206          *  This menu is updated under the following conditions:
 207          *
 208          *    1.  When a window is created.
 209          *    2.  When a window is destroyed.
 210          *
 211          *    3.  When a window changes it's title.
 212          *    4.  When a window changes its workspace.
 213          */
 214         if (action == ACTION_ADD) {
 215                 char *t;
 216                 int idx;
 217
 218                 if (wwin->flags.internal_window || WFLAGP(wwin, skip_window_list) || IS_GNUSTEP_MENU(wwin)) {
 219                         return;
 220                 }
 221
 222                 if (wwin->frame->title)
 223                         snprintf(title, len, "%s", wwin->frame->title);
 224                 else
 225                         snprintf(title, len, "%s", DEF_WINDOW_TITLE);
 226                 t = ShrinkString(scr->menu_entry_font, title, MAX_WINDOWLIST_WIDTH);
 227
 228                 if (IS_OMNIPRESENT(wwin))
 229                         idx = -1;
 230                 else {
 231                         idx = menuIndexForWindow(switchmenu, wwin, -1);
 232                 }
 233
 234                 entry = wMenuInsertCallback(switchmenu, idx, t, focusWindow, wwin);
 235                 wfree(t);
 236
 237                 entry->flags.indicator = 1;
 238                 entry->rtext = wmalloc(MAX_WORKSPACENAME_WIDTH + 8);
 239                 if (IS_OMNIPRESENT(wwin))
 240                         snprintf(entry->rtext, MAX_WORKSPACENAME_WIDTH, "[*]");
 241                 else
 242                         snprintf(entry->rtext, MAX_WORKSPACENAME_WIDTH, "[%s]",
 243                                  scr->workspaces[wwin->frame->workspace]->name);
 244
 245                 if (wwin->flags.hidden) {
 246                         entry->flags.indicator_type = MI_HIDDEN;
 247                         entry->flags.indicator_on = 1;
 248                 } else if (wwin->flags.miniaturized) {
 249                         entry->flags.indicator_type = MI_MINIWINDOW;
 250                         entry->flags.indicator_on = 1;
 251                 } else if (wwin->flags.focused) {
 252                         entry->flags.indicator_type = MI_DIAMOND;
 253                         entry->flags.indicator_on = 1;
 254                 } else if (wwin->flags.shaded) {
 255                         entry->flags.indicator_type = MI_SHADED;
 256                         entry->flags.indicator_on = 1;
 257                 }
 258
 259                 wMenuRealize(switchmenu);
 260                 checkVisibility = 1;
 261         } else {
 262                 char *t;
 263                 for (i = 0; i < switchmenu->entry_no; i++) {
 264                         entry = switchmenu->entries[i];
 265                         /* this is the entry that was changed */
 266                         if (entry->clientdata == wwin) {
 267                                 switch (action) {
 268                                 case ACTION_REMOVE:
 269                                         wMenuRemoveItem(switchmenu, i);
 270                                         wMenuRealize(switchmenu);
 271                                         checkVisibility = 1;
 272                                         break;
 273
 274                                 case ACTION_CHANGE:
 275                                         if (entry->text)
 276                                                 wfree(entry->text);
 277
 278                                         if (wwin->frame->title)
 279                                                 snprintf(title, MAX_MENU_TEXT_LENGTH, "%s", wwin->frame->title);
 280                                         else
 281                                                 snprintf(title, MAX_MENU_TEXT_LENGTH, "%s", DEF_WINDOW_TITLE);
 282
 283                                         t = ShrinkString(scr->menu_entry_font, title, MAX_WINDOWLIST_WIDTH);
 284                                         entry->text = t;
 285
 286                                         wMenuRealize(switchmenu);
 287                                         checkVisibility = 1;
 288                                         break;
 289
 290                                 case ACTION_CHANGE_WORKSPACE:
 291                                         if (entry->rtext) {
 292                                                 int idx = -1;
 293                                                 char *t, *rt;
 294                                                 int it, ion;
 295
 296                                                 if (IS_OMNIPRESENT(wwin)) {
 297                                                         snprintf(entry->rtext, MAX_WORKSPACENAME_WIDTH, "[*]");
 298                                                 } else {
 299                                                         snprintf(entry->rtext, MAX_WORKSPACENAME_WIDTH,
 300                                                                  "[%s]",
 301                                                                  scr->workspaces[wwin->frame->workspace]->name);
 302                                                 }
 303
 304                                                 rt = entry->rtext;
 305                                                 entry->rtext = NULL;
 306                                                 t = entry->text;
 307                                                 entry->text = NULL;
 308
 309                                                 it = entry->flags.indicator_type;
 310                                                 ion = entry->flags.indicator_on;
 311
 312                                                 if (!IS_OMNIPRESENT(wwin) && idx < 0) {
 313                                                         idx = menuIndexForWindow(switchmenu, wwin, i);
 314                                                 }
 315
 316                                                 wMenuRemoveItem(switchmenu, i);
 317
 318                                                 entry = wMenuInsertCallback(switchmenu, idx, t, focusWindow, wwin);
 319                                                 wfree(t);
 320                                                 entry->rtext = rt;
 321                                                 entry->flags.indicator = 1;
 322                                                 entry->flags.indicator_type = it;
 323                                                 entry->flags.indicator_on = ion;
 324                                         }
 325                                         wMenuRealize(switchmenu);
 326                                         checkVisibility = 1;
 327                                         break;
 328
 329                                 case ACTION_CHANGE_STATE:
 330                                         if (wwin->flags.hidden) {
 331                                                 entry->flags.indicator_type = MI_HIDDEN;
 332                                                 entry->flags.indicator_on = 1;
 333                                         } else if (wwin->flags.miniaturized) {
 334                                                 entry->flags.indicator_type = MI_MINIWINDOW;
 335                                                 entry->flags.indicator_on = 1;
 336                                         } else if (wwin->flags.shaded && !wwin->flags.focused) {
 337                                                 entry->flags.indicator_type = MI_SHADED;
 338                                                 entry->flags.indicator_on = 1;
 339                                         } else {
 340                                                 entry->flags.indicator_on = wwin->flags.focused;
 341                                                 entry->flags.indicator_type = MI_DIAMOND;
 342                                         }
 343                                         break;
 344                                 }
 345                                 break;
 346                         }
 347                 }
 348         }
 349         if (checkVisibility) {
 350                 int tmp;
 351
 352                 tmp = switchmenu->frame->top_width + 5;
 353                 /* if menu got unreachable, bring it to a visible place */
 354                 if (switchmenu->frame_x < tmp - (int)switchmenu->frame->core->width) {
 355                         wMenuMove(switchmenu, tmp - (int)switchmenu->frame->core->width,
 356                                   switchmenu->frame_y, False);
 357                 }
 358         }
 359         wMenuPaint(switchmenu);
 360 }
 361
 362 void UpdateSwitchMenuWorkspace(WScreen * scr, int workspace)
 363 {
 364         WMenu *menu = scr->switch_menu;
 365         int i;
 366         WWindow *wwin;
 367
 368         if (!menu)
 369                 return;
 370
 371         for (i = 0; i < menu->entry_no; i++) {
 372                 wwin = (WWindow *) menu->entries[i]->clientdata;
 373
 374                 if (wwin->frame->workspace == workspace && !IS_OMNIPRESENT(wwin)) {
 375                         if (IS_OMNIPRESENT(wwin))
 376                                 snprintf(menu->entries[i]->rtext, MAX_WORKSPACENAME_WIDTH, "[*]");
 377                         else
 378                                 snprintf(menu->entries[i]->rtext, MAX_WORKSPACENAME_WIDTH, "[%s]",
 379                                          scr->workspaces[wwin->frame->workspace]->name);
 380                         menu->flags.realized = 0;
 381                 }
 382         }
 383         if (!menu->flags.realized)
 384                 wMenuRealize(menu);
 385 }
 386
 387 static void observer(void *self, WMNotification * notif)
 388 {
 389         WWindow *wwin = (WWindow *) WMGetNotificationObject(notif);
 390         const char *name = WMGetNotificationName(notif);
 391         void *data = WMGetNotificationClientData(notif);
 392
 393         if (!wwin)
 394                 return;
 395
 396         if (strcmp(name, WMNManaged) == 0)
 397                 UpdateSwitchMenu(wwin->screen_ptr, wwin, ACTION_ADD);
 398         else if (strcmp(name, WMNUnmanaged) == 0)
 399                 UpdateSwitchMenu(wwin->screen_ptr, wwin, ACTION_REMOVE);
 400         else if (strcmp(name, WMNChangedWorkspace) == 0)
 401                 UpdateSwitchMenu(wwin->screen_ptr, wwin, ACTION_CHANGE_WORKSPACE);
 402         else if (strcmp(name, WMNChangedFocus) == 0)
 403                 UpdateSwitchMenu(wwin->screen_ptr, wwin, ACTION_CHANGE_STATE);
 404         else if (strcmp(name, WMNChangedName) == 0)
 405                 UpdateSwitchMenu(wwin->screen_ptr, wwin, ACTION_CHANGE);
 406         else if (strcmp(name, WMNChangedState) == 0) {
 407                 if (strcmp((char *)data, "omnipresent") == 0) {
 408                         UpdateSwitchMenu(wwin->screen_ptr, wwin, ACTION_CHANGE_WORKSPACE);
 409                 } else {
 410                         UpdateSwitchMenu(wwin->screen_ptr, wwin, ACTION_CHANGE_STATE);
 411                 }
 412         }
 413 }
 414
 415 static void wsobserver(void *self, WMNotification * notif)
 416 {
 417         WScreen *scr = (WScreen *) WMGetNotificationObject(notif);
 418         const char *name = WMGetNotificationName(notif);
 419         void *data = WMGetNotificationClientData(notif);
 420
 421         if (strcmp(name, WMNWorkspaceNameChanged) == 0) {
 422                 UpdateSwitchMenuWorkspace(scr, (int)(uintptr_t) data);
 423         } else if (strcmp(name, WMNWorkspaceChanged) == 0) {
 424
 425         }
 426 }
 427
 428 #endif                          /* !LITE */