[go: up one dir, main page]
Menu ▾ ▴

[79af12]: / src / wmmgr.h  Maximize  Restore  History

Download this file

363 lines (296 with data), 13.1 kB 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
#ifndef __WMMGR_H

#define __WMMGR_H



#include <X11/Xproto.h>

#include "ywindow.h"

#include "ymenu.h"

#include "WinMgr.h"

#include "ytimer.h"



#ifdef CONFIG_WM_SESSION

#include "yarray.h"



#define PROC_WM_SESSION "/proc/wm-session"

#endif



#define MAXWORKSPACES 64

#define INVALID_WORKSPACE 0xFFFFFFFF



extern long workspaceCount;

extern char *workspaceNames[MAXWORKSPACES];

extern YAction *workspaceActionActivate[MAXWORKSPACES];

extern YAction *workspaceActionMoveTo[MAXWORKSPACES];



extern YAction *layerActionSet[WinLayerCount];



#ifdef CONFIG_TRAY

#if 0

extern YAction *trayOptionActionSet[WinTrayOptionCount];

#endif

#endif



class YWindowManager;

class YFrameClient;

class YFrameWindow;



class EdgeSwitch: public YWindow, public YTimerListener {

public:

    EdgeSwitch(YWindowManager *manager, int delta, bool vertical);

    virtual ~EdgeSwitch();



    virtual void handleCrossing(const XCrossingEvent &crossing);

    virtual bool handleTimer(YTimer *t);

private:

    YWindowManager *fManager;

    YCursor & fCursor;

    int fDelta;



    static YTimer *fEdgeSwitchTimer;

};



class YProxyWindow: public YWindow {

public:

    YProxyWindow(YWindow *parent);

    virtual ~YProxyWindow();



    virtual void handleButton(const XButtonEvent &button);

};



class YWindowManager: public YDesktop {

public:

    YWindowManager(YWindow *parent, Window win = 0);

    virtual ~YWindowManager();



    void grabKeys();



    virtual void handleButton(const XButtonEvent &button);

    virtual void handleClick(const XButtonEvent &up, int count);

    virtual bool handleKey(const XKeyEvent &key);



    virtual void handleConfigureRequest(const XConfigureRequestEvent &configureRequest);

    virtual void handleMapRequest(const XMapRequestEvent &mapRequest);

    virtual void handleUnmap(const XUnmapEvent &unmap);

    virtual void handleDestroyWindow(const XDestroyWindowEvent &destroyWindow);

    virtual void handleClientMessage(const XClientMessageEvent &message);

    virtual void handleProperty(const XPropertyEvent &property);

    virtual void handleFocus(const XFocusChangeEvent &focus);



    void manageClients();

    void unmanageClients();



    Window findWindow(char const * resource);

    Window findWindow(Window root, char const * wmInstance,

                      char const * wmClass);



    YFrameWindow *findFrame(Window win);

    YFrameClient *findClient(Window win);

    YFrameWindow *manageClient(Window win, bool mapClient = false);

    void unmanageClient(Window win, bool mapClient = false,

                        bool reparent = true);

    void destroyedClient(Window win);

    YFrameWindow *mapClient(Window win);

    

    void setFocus(YFrameWindow *f, bool canWarp = false);

    YFrameWindow *getFocus() { return fFocusWin; }

    

    void loseFocus(YFrameWindow *window);

    void loseFocus(YFrameWindow *window,

                   YFrameWindow *next,

                   YFrameWindow *prev);

    void activate(YFrameWindow *frame, bool raise, bool canWarp = false);



    void installColormap(Colormap cmap);

    void setColormapWindow(YFrameWindow *frame);

    YFrameWindow *colormapWindow() { return fColormapWindow; }



    void removeClientFrame(YFrameWindow *frame);



    void getWorkArea(const YFrameWindow *frame, int *mx, int *my, int *Mx, int *My, int xiscreen = -1) const;

    void getWorkAreaSize(const YFrameWindow *frame, int *Mw,int *Mh);



    int calcCoverage(bool down, YFrameWindow *frame, int x, int y, int w, int h);

    void tryCover(bool down, YFrameWindow *frame, int x, int y, int w, int h,

                  int &px, int &py, int &cover, int xiscreen);

    bool getSmartPlace(bool down, YFrameWindow *frame, int &x, int &y, int w, int h, int xiscreen);

    void getNewPosition(YFrameWindow *frame, int &x, int &y, int w, int h, int xiscreen);

    void placeWindow(YFrameWindow *frame, int x, int y, bool newClient, bool &canActivate);



    YFrameWindow *top(long layer) const { return fTop[layer]; }

    void setTop(long layer, YFrameWindow *top);

    YFrameWindow *bottom(long layer) const { return fBottom[layer]; }

    void setBottom(long layer, YFrameWindow *bottom) { fBottom[layer] = bottom; }



    YFrameWindow *topLayer(long layer = WinLayerCount - 1);

    YFrameWindow *bottomLayer(long layer = 0);



    YFrameWindow *firstFrame() { return fFirst; }

    YFrameWindow *lastFrame() { return fLast; }

    void setFirstFrame(YFrameWindow *f) { fFirst = f; }

    void setLastFrame(YFrameWindow *f) { fLast = f; }



    YFrameWindow *firstFocusFrame() { return fFirstFocus; }

    YFrameWindow *lastFocusFrame() { return fLastFocus; }

    void setFirstFocusFrame(YFrameWindow *f) { fFirstFocus = f; }

    void setLastFocusFrame(YFrameWindow *f) { fLastFocus = f; }



    void restackWindows(YFrameWindow *win);

    void focusTopWindow();

    YFrameWindow *getLastFocus(long workspace = -1);

    void focusLastWindow();

    bool focusTop(YFrameWindow *f);

    void relocateWindows(long workspace, int dx, int dy);

    void updateClientList();



    YMenu *createWindowMenu(YMenu *menu, long workspace);

    int windowCount(long workspace);

#ifdef CONFIG_WINMENU

    void popupWindowListMenu(YWindow *owner, int x, int y);

#endif



    long activeWorkspace() const { return fActiveWorkspace; }

    long lastWorkspace() const { return fLastWorkspace; }

    void activateWorkspace(long workspace);

    long workspaceCount() const { return ::workspaceCount; }

    const char *workspaceName(long workspace) const { return ::workspaceNames[workspace]; }



    void announceWorkArea();

    void setWinWorkspace(long workspace);

    void updateWorkArea();

    void resizeWindows();



    void getIconPosition(YFrameWindow *frame, int *iconX, int *iconY);



    void wmCloseSession();

    void exitAfterLastClient(bool shuttingDown);

    void checkLogout();



    virtual void resetColormap(bool active);



    void switchFocusTo(YFrameWindow *frame, bool reorderFocus = true);

    void switchFocusFrom(YFrameWindow *frame);

    void notifyFocus(YFrameWindow *frame);



    void popupStartMenu(YWindow *owner);

#ifdef CONFIG_WINMENU

    void popupWindowListMenu(YWindow *owner);

#endif



    void switchToWorkspace(long nw, bool takeCurrent);

    void switchToPrevWorkspace(bool takeCurrent);

    void switchToNextWorkspace(bool takeCurrent);

    void switchToLastWorkspace(bool takeCurrent);



    void tilePlace(YFrameWindow *w, int tx, int ty, int tw, int th);

    void tileWindows(YFrameWindow **w, int count, bool vertical);

    void smartPlace(YFrameWindow **w, int count);

    void getCascadePlace(YFrameWindow *frame, int &lastX, int &lastY, int &x, int &y, int w, int h);

    void cascadePlace(YFrameWindow **w, int count);

    void setWindows(YFrameWindow **w, int count, YAction *action);



    void getWindowsToArrange(YFrameWindow ***w, int *count);



    void saveArrange(YFrameWindow **w, int count);

    void undoArrange();



    bool haveClients();

    void setupRootProxy();



    void setWorkAreaMoveWindows(bool m) { fWorkAreaMoveWindows = m; }



    void clearFullscreenLayer();

    void updateFullscreenLayer();



#ifdef CONFIG_WM_SESSION

    void setTopLevelProcess(pid_t p);

    void removeLRUProcess();

#endif



    int getScreen();



    enum { wmSTARTUP, wmRUNNING, wmSHUTDOWN, wmRESTART } wmState;



    void doWMAction(long action);

    void lockFocus() { lockFocusCount++; }

    void unlockFocus() { lockFocusCount--; }

    bool focusLocked() { return lockFocusCount != 0; }

private:

    struct WindowPosState {

        int x, y, w, h;

        long state;

        YFrameWindow *frame;

    };



    void updateArea(long workspace, int l, int t, int r, int b);



    YFrameWindow *fFocusWin;

    YFrameWindow *fTop[WinLayerCount];

    YFrameWindow *fBottom[WinLayerCount];

    YFrameWindow *fFirst, *fLast; // creation order

    YFrameWindow *fFirstFocus, *fLastFocus; // creation order

    long fActiveWorkspace;

    long fLastWorkspace;

    YFrameWindow *fColormapWindow;

    int fWorkAreaCount;

    struct WorkAreaRect {

        int fMinX, fMinY, fMaxX, fMaxY;

    } *fWorkArea;

    EdgeSwitch *fLeftSwitch, *fRightSwitch, *fTopSwitch, *fBottomSwitch;

    bool fShuttingDown;

    int fArrangeCount;

    WindowPosState *fArrangeInfo;

    YProxyWindow *rootProxy;

    YWindow *fTopWin;

    bool fWorkAreaMoveWindows;

    bool fOtherScreenFocused;

    int lockFocusCount;



#ifdef CONFIG_WM_SESSION

    YStackSet<pid_t> fProcessList;

#endif

};



extern YWindowManager *manager;



void dumpZorder(const char *oper, YFrameWindow *w, YFrameWindow *a = 0);



extern Atom _XA_WIN_PROTOCOLS;

extern Atom _XA_WIN_WORKSPACE;

extern Atom _XA_WIN_WORKSPACE_COUNT;

extern Atom _XA_WIN_WORKSPACE_NAMES;

extern Atom _XA_WIN_WORKAREA;

extern Atom _XA_WIN_LAYER;

#ifdef CONFIG_TRAY

extern Atom _XA_WIN_TRAY;

#endif

extern Atom _XA_WIN_ICONS;

extern Atom _XA_WIN_HINTS;

extern Atom _XA_WIN_STATE;

extern Atom _XA_WIN_SUPPORTING_WM_CHECK;

extern Atom _XA_WIN_CLIENT_LIST;

extern Atom _XA_WIN_DESKTOP_BUTTON_PROXY;

extern Atom _XA_WIN_AREA;

extern Atom _XA_WIN_AREA_COUNT;

extern Atom _XA_WM_CLIENT_LEADER;

extern Atom _XA_WM_WINDOW_ROLE;

extern Atom _XA_WINDOW_ROLE;

extern Atom _XA_SM_CLIENT_ID;



extern Atom _XA_ICEWM_ACTION;



/// _SET would be nice to have

#define _NET_WM_STATE_REMOVE 0

#define _NET_WM_STATE_ADD 1

#define _NET_WM_STATE_TOGGLE 2



#define _NET_WM_MOVERESIZE_SIZE_TOPLEFT      0

#define _NET_WM_MOVERESIZE_SIZE_TOP          1

#define _NET_WM_MOVERESIZE_SIZE_TOPRIGHT     2

#define _NET_WM_MOVERESIZE_SIZE_RIGHT        3

#define _NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT  4

#define _NET_WM_MOVERESIZE_SIZE_BOTTOM       5

#define _NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT   6

#define _NET_WM_MOVERESIZE_SIZE_LEFT         7

#define _NET_WM_MOVERESIZE_MOVE              8 /* Movement only */

                                                 //*=testnetwmhints

extern Atom _XA_NET_SUPPORTED;                   // OK

extern Atom _XA_NET_CLIENT_LIST;                 // OK (perf: don't update on stacking changes)

extern Atom _XA_NET_CLIENT_LIST_STACKING;        // OK

extern Atom _XA_NET_NUMBER_OF_DESKTOPS;          // implement change request

///extern Atom _XA_NET_DESKTOP_GEOMETRY;         // N/A

///extern Atom _XA_NET_DESKTOP_VIEWPORT;         // N/A

extern Atom _XA_NET_CURRENT_DESKTOP;             // OK

///extern Atom _XA_NET_DESKTOP_NAMES;            // N/A

extern Atom _XA_NET_ACTIVE_WINDOW;               // OK

extern Atom _XA_NET_WORKAREA;                    // OK

extern Atom _XA_NET_SUPPORTING_WM_CHECK;         // OK

///extern Atom _XA_NET_SUPPORTING_WM_CHECK;      // N/A

extern Atom _XA_NET_CLOSE_WINDOW;                // OK

extern Atom _XA_NET_WM_MOVERESIZE;               //*OK

extern Atom _XA_NET_WM_NAME;                     // TODO

extern Atom _XA_NET_WM_VISIBLE_NAME;             // TODO

extern Atom _XA_NET_WM_ICON_NAME;                // TODO

extern Atom _XA_NET_WM_VISIBLE_ICON_NAME;        // TODO

extern Atom _XA_NET_WM_DESKTOP;                  // OK

extern Atom _XA_NET_WM_WINDOW_TYPE;              // OK

extern Atom _XA_NET_WM_WINDOW_TYPE_DESKTOP;      // OK

extern Atom _XA_NET_WM_WINDOW_TYPE_DOCK;         // OK

///extern Atom _XA_NET_WM_WINDOW_TYPE_TOOLBAR;   // N/A

///extern Atom _XA_NET_WM_WINDOW_TYPE_MENU;      // N/A

///extern Atom _XA_NET_WM_WINDOW_TYPE_UTILITY;   // N/A

extern Atom _XA_NET_WM_WINDOW_TYPE_SPLASH;       // N/A

extern Atom _XA_NET_WM_WINDOW_TYPE_DIALOG;       // TODO

extern Atom _XA_NET_WM_WINDOW_TYPE_NORMAL;       // TODO

extern Atom _XA_NET_WM_STATE;                    // OK

extern Atom _XA_NET_WM_STATE_MODAL;              // TODO

///extern Atom _XA_NET_WM_STATE_STICKY;          // N/A

extern Atom _XA_NET_WM_STATE_MAXIMIZED_VERT;     // OK

extern Atom _XA_NET_WM_STATE_MAXIMIZED_HORZ;     // OK

extern Atom _XA_NET_WM_STATE_SHADED;             // OK

extern Atom _XA_NET_WM_STATE_SKIP_TASKBAR;       // TODO ;; == HIDDEN && ! MINIMIZED?

///extern Atom _XA_NET_WM_STATE_SKIP_PAGER;      // N/A

extern Atom _XA_NET_WM_STATE_HIDDEN;             // OK ;; == HIDDEN || MINIMIZED?

extern Atom _XA_NET_WM_STATE_FULLSCREEN;         //*OK (hack)



extern Atom _XA_NET_WM_ALLOWED_ACTIONS;          // TODO

extern Atom _XA_NET_WM_ACTION_MOVE;              // TODO

extern Atom _XA_NET_WM_ACTION_RESIZE;            // TODO

extern Atom _XA_NET_WM_ACTION_SHADE;             // TODO

///extern Atom _XA_NET_WM_ACTION_STICK;          // N/A

extern Atom _XA_NET_WM_ACTION_MAXIMIZE_HORZ;     // TODO

extern Atom _XA_NET_WM_ACTION_MAXIMIZE_VERT;     // TODO

extern Atom _XA_NET_WM_ACTION_CHANGE_DESKTOP;    // TODO

extern Atom _XA_NET_WM_ACTION_CLOSE;             // TODO



extern Atom _XA_NET_WM_STRUT;                    // OK

///extern Atom _XA_NET_WM_ICON_GEOMETRY;         // N/A

extern Atom _XA_NET_WM_ICON;                     // TODO

extern Atom _XA_NET_WM_PID;                      // TODO

extern Atom _XA_NET_WM_HANDLED_ICONS;            // TODO -> toggle minimizeToDesktop

extern Atom _XA_NET_WM_PING;                     // TODO



// TODO extra:

// original geometry of maximized window

//



/* KDE specific */

extern Atom _XA_KWM_WIN_ICON;



extern Atom XA_IcewmWinOptHint;



extern YIcon *defaultAppIcon;



#endif