e16
/
e16
3
0
Fork 1
Code Issues Pull Requests Projects Releases Wiki Activity
e16/src/desktops.c

3056 lines
66 KiB
C
Raw Blame History

/*
* Copyright (C) 2000-2007 Carsten Haitzler, Geoff Harrison and various contributors
* Copyright (C) 2004-2014 Kim Woelders
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to
* deal in the Software without restriction, including without limitation the
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
* sell copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies of the Software, its documentation and marketing & publicity
* materials, and acknowledgment shall be given in the documentation, materials
* and software packages that this Software was used.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include "E.h"
#include "aclass.h"
#include "animation.h"
#include "backgrounds.h"
#include "buttons.h"
#include "desktops.h"
#include "dialog.h"
#include "ecompmgr.h"
#include "emodule.h"
#include "eobj.h"
#include "events.h"
#include "ewins.h"
#include "focus.h"
#include "grabs.h"
#include "hints.h"
#include "iclass.h"
#include "screen.h"
#include "settings.h"
#include "slide.h"
#include "timers.h"
#include "tooltips.h"
#include "xwin.h"
#include <time.h>
#if USE_XRANDR
#include <X11/extensions/Xrandr.h>
#endif
#define DESK_EVENT_MASK1 \
(ButtonPressMask | ButtonReleaseMask)
#define DESK_EVENT_MASK2 \
(EnterWindowMask | LeaveWindowMask | \
SubstructureNotifyMask | SubstructureRedirectMask | PropertyChangeMask)
#define DESK_EVENT_MASK (DESK_EVENT_MASK1 | DESK_EVENT_MASK2)
#define ENLIGHTENMENT_CONF_NUM_DESKTOPS 32
typedef struct {
Desk *current;
Desk *previous;
Desk *desk[ENLIGHTENMENT_CONF_NUM_DESKTOPS];
unsigned int order[ENLIGHTENMENT_CONF_NUM_DESKTOPS];
int drag_x0, drag_y0;
unsigned int prev_num;
Animator *anim_slide;
} Desktops;
static void DeskRaise(unsigned int num);
static void DeskLower(unsigned int num);
static void DeskHandleEvents(Win win, XEvent * ev, void *prm);
static void DeskButtonCallback(void *prm, XEvent * ev,
ActionClass * ac);
/* The desktops */
static Desktops desks;
#define _DeskGet(d) (desks.desk[d])
static void
DeskControlsCreate(Desk * dsk)
{
char s[512];
const char *ic1, *ic2, *ic3;
#if ENABLE_DESKRAY
const char *ic4;
#endif
char ac1[64], ac2[64], ac3[64];
Button *b;
ActionClass *ac;
Action *a;
int x[3], y[3], w[3], h[3], m, n, o;
const char *t;
if (Conf.desks.dragdir < 0 || Conf.desks.dragdir > 3)
Conf.desks.dragdir = 2;
if (Conf.desks.dragbar_ordering < 0 || Conf.desks.dragbar_ordering > 5)
Conf.desks.dragbar_ordering = 1;
if (Conf.desks.dragbar_width < 0)
Conf.desks.dragbar_width = 0;
else if (Conf.desks.dragbar_width > 64)
Conf.desks.dragbar_width = 64;
if (Conf.desks.dragbar_length < 0)
Conf.desks.dragbar_length = 0;
else if (Conf.desks.dragbar_length > WinGetW(VROOT))
Conf.desks.dragbar_length = WinGetW(VROOT);
Esnprintf(ac1, sizeof(ac1), "DRAGBAR_DESKTOP_%i", dsk->num);
if (!ActionclassFind(ac1))
{
ac = ActionclassCreate(ac1, 0);
a = ActionCreate(EVENT_MOUSE_DOWN, 0, 0, 0, 1, 0, NULL, NULL);
ActionclassAddAction(ac, a);
Esnprintf(s, sizeof(s), "desk drag %i", dsk->num);
ActionAddTo(a, s);
a = ActionCreate(EVENT_MOUSE_DOWN, 0, 0, 0, 3, 0, NULL, NULL);
ActionclassAddAction(ac, a);
ActionAddTo(a, "menus show deskmenu");
a = ActionCreate(EVENT_MOUSE_DOWN, 0, 0, 0, 2, 0, NULL, NULL);
ActionclassAddAction(ac, a);
ActionAddTo(a, "menus show windowlist");
if (dsk->num > 0)
{
t = _("Hold down the mouse button and drag\n"
"the mouse to be able to drag the desktop\n"
"back and forth.\n"
"Click right mouse button for a list of all\n"
"Desktops and their applications.\n"
"Click middle mouse button for a list of all\n"
"applications currently running.\n");
ActionclassSetTooltipString(ac, t);
}
else
{
t = _("This is the Root desktop.\n"
"You cannot drag the root desktop around.\n"
"Click right mouse button for a list of all\n"
"Desktops and their applications.\n"
"Click middle mouse button for a list of all\n"
"applications currently running.\n");
ActionclassSetTooltipString(ac, t);
}
}
Esnprintf(ac2, sizeof(ac2), "RAISEBUTTON_DESKTOP_%i", dsk->num);
if (!ActionclassFind(ac2))
{
ac = ActionclassCreate(ac2, 0);
a = ActionCreate(EVENT_MOUSE_UP, 1, 0, 1, 0, 0, NULL, NULL);
ActionclassAddAction(ac, a);
ActionAddTo(a, "desk next");
t = _("Click here to raise this desktop\nto the top.");
ActionclassSetTooltipString(ac, t);
}
Esnprintf(ac3, sizeof(ac3), "LOWERBUTTON_DESKTOP_%i", dsk->num);
if (!ActionclassFind(ac3))
{
ac = ActionclassCreate(ac3, 0);
a = ActionCreate(EVENT_MOUSE_UP, 1, 0, 1, 0, 0, NULL, NULL);
ActionclassAddAction(ac, a);
ActionAddTo(a, "desk prev");
t = _("Click here to lower this desktop\nto the bottom.");
ActionclassSetTooltipString(ac, t);
}
if (Conf.desks.dragdir < 2)
{
ic1 = "DESKTOP_DRAGBUTTON_VERT";
ic2 = "DESKTOP_RAISEBUTTON_VERT";
ic3 = "DESKTOP_LOWERBUTTON_VERT";
#if ENABLE_DESKRAY
ic4 = "DESKTOP_DESKRAY_VERT";
#endif
}
else
{
ic1 = "DESKTOP_DRAGBUTTON_HORIZ";
ic2 = "DESKTOP_RAISEBUTTON_HORIZ";
ic3 = "DESKTOP_LOWERBUTTON_HORIZ";
#if ENABLE_DESKRAY
ic4 = "DESKTOP_DESKRAY_HORIZ";
#endif
}
switch (Conf.desks.dragbar_ordering)
{
case 0:
m = 0;
n = 1;
o = 2;
break;
case 1:
m = 0;
n = 2;
o = 1;
break;
case 2:
m = 2;
n = 0;
o = 1;
break;
case 3:
m = 1;
n = 0;
o = 2;
break;
case 4:
m = 1;
n = 2;
o = 0;
break;
case 5:
m = 2;
n = 1;
o = 0;
break;
default:
m = 0;
n = 1;
o = 2;
break;
}
switch (Conf.desks.dragdir)
{
default:
case 0:
w[0] = w[1] = w[2] = h[0] = h[1] = Conf.desks.dragbar_width;
if (Conf.desks.dragbar_length == 0)
h[2] = WinGetH(VROOT) - (Conf.desks.dragbar_width * 2);
else
h[2] = Conf.desks.dragbar_length;
x[0] = x[1] = x[2] = 0;
y[m] = 0;
y[n] = y[m] + h[m];
y[o] = y[n] + h[n];
break;
case 1:
w[0] = w[1] = w[2] = h[0] = h[1] = Conf.desks.dragbar_width;
if (Conf.desks.dragbar_length == 0)
h[2] = WinGetH(VROOT) - (Conf.desks.dragbar_width * 2);
else
h[2] = Conf.desks.dragbar_length;
x[0] = x[1] = x[2] = WinGetW(VROOT) - Conf.desks.dragbar_width;
y[m] = 0;
y[n] = y[m] + h[m];
y[o] = y[n] + h[n];
break;
case 2:
h[0] = h[1] = h[2] = w[0] = w[1] = Conf.desks.dragbar_width;
if (Conf.desks.dragbar_length == 0)
w[2] = WinGetW(VROOT) - (Conf.desks.dragbar_width * 2);
else
w[2] = Conf.desks.dragbar_length;
y[0] = y[1] = y[2] = 0;
x[m] = 0;
x[n] = x[m] + w[m];
x[o] = x[n] + w[n];
break;
case 3:
h[0] = h[1] = h[2] = w[0] = w[1] = Conf.desks.dragbar_width;
if (Conf.desks.dragbar_length == 0)
w[2] = WinGetW(VROOT) - (Conf.desks.dragbar_width * 2);
else
w[2] = Conf.desks.dragbar_length;
y[0] = y[1] = y[2] = WinGetH(VROOT) - Conf.desks.dragbar_width;
x[m] = 0;
x[n] = x[m] + w[m];
x[o] = x[n] + w[n];
break;
}
b = NULL;
if (Conf.desks.dragbar_width > 0)
{
ButtonCreate("_DESKTOP_DRAG_CONTROL", 1, ic2, ac2, NULL, NULL,
-1, FLAG_FIXED, 1, 99999, 1, 99999, 0, 0, x[0], 0,
y[0], 0, 0, w[0], 0, h[0], 0, dsk->num, 0);
ButtonCreate("_DESKTOP_DRAG_CONTROL", 1, ic3, ac3, NULL, NULL,
-1, FLAG_FIXED, 1, 99999, 1, 99999, 0, 0, x[1], 0,
y[1], 0, 0, w[1], 0, h[1], 0, dsk->num, 0);
b = ButtonCreate("_DESKTOP_DRAG_CONTROL", 1, ic1, ac1, NULL, NULL,
-1, FLAG_FIXED, 1, 99999, 1, 99999, 0, 0, x[2], 0,
y[2], 0, 0, w[2], 0, h[2], 0, dsk->num, 0);
ButtonSetCallback(b, DeskButtonCallback, dsk);
}
#if ENABLE_DESKRAY
if (dsk->num > 0)
{
if (Conf.desks.dragdir == 0)
{
b = ButtonCreate("_DESKTOP_DESKRAY_DRAG_CONTROL", 2, ic4, ac1,
NULL, NULL, 1, FLAG_FIXED_VERT, 1, 99999, 1,
99999, 0, 0, EoGetX(dsk), 0, EoGetY(dsk),
0, 0, 0, 0, 0, 1, 0, 1);
}
else if (Conf.desks.dragdir == 1)
{
b = ButtonCreate("_DESKTOP_DESKRAY_DRAG_CONTROL", 2, ic4, ac1,
NULL, NULL, 1, FLAG_FIXED_VERT, 1, 99999, 1,
99999, 0, 0,
EoGetX(dsk) + WinGetW(VROOT) -
Conf.desks.dragbar_width, 0, EoGetY(dsk),
0, 0, 0, 0, 0, 1, 0, 1);
}
else if (Conf.desks.dragdir == 2)
{
b = ButtonCreate("_DESKTOP_DESKRAY_DRAG_CONTROL", 2, ic4, ac1,
NULL, NULL, 1, FLAG_FIXED_HORIZ, 1, 99999, 1,
99999, 0, 0, EoGetX(dsk), 0, EoGetY(dsk),
0, 0, 0, 0, 0, 1, 0, 1);
}
else
{
b = ButtonCreate("_DESKTOP_DESKRAY_DRAG_CONTROL", 2, ic4, ac1,
NULL, NULL, 1, FLAG_FIXED_HORIZ, 1, 99999, 1,
99999, 0, 0, EoGetX(dsk), 0,
EoGetY(dsk) + WinGetH(VROOT) -
Conf.desks.dragbar_width, 0, 0, 0, 0, 0, 1, 0, 1);
}
}
#endif
dsk->tag = b;
}
static void
DeskControlsDestroy(Desk * dsk, int id)
{
ButtonsForeach(id, dsk, ButtonDestroy);
}
static void
DeskControlsShow(Desk * dsk, int id)
{
ButtonsForeach(id, dsk, ButtonShow);
}
static void
DeskConfigure(Desk * dsk)
{
Background *bg;
DeskControlsCreate(dsk);
DeskControlsShow(dsk, 1);
bg = BackgroundGetForDesk(dsk->num);
DeskBackgroundSet(dsk, bg);
dsk->bg.pixel = 0xffffffff;
if (dsk->num > 0)
{
EoMove(dsk, WinGetW(VROOT), 0);
EoMap(dsk, 0);
}
ModulesSignal(ESIGNAL_DESK_ADDED, dsk);
}
static Desk *
DeskCreate(int desk, int configure)
{
#if USE_COMPOSITE
EObj *eo;
#endif
Desk *dsk;
Win win;
char buf[64];
if (desk < 0 || desk >= ENLIGHTENMENT_CONF_NUM_DESKTOPS)
return NULL;
dsk = ECALLOC(Desk, 1);
if (!dsk)
return dsk;
desks.desk[desk] = dsk;
dsk->num = desk;
desks.order[desk] = desk;
win = (desk == 0) ? VROOT : NULL;
Esnprintf(buf, sizeof(buf), "Desk-%d", desk);
EoSetNoRedirect(dsk, 1);
EoInit(dsk, EOBJ_TYPE_DESK, win,
0, 0, WinGetW(VROOT), WinGetH(VROOT), 0, buf);
EventCallbackRegister(EoGetWin(dsk), DeskHandleEvents, dsk);
dsk->bg.o = EoObj(dsk);
if (desk == 0)
{
desks.current = dsk;
#if !USE_BG_WIN_ON_ALL_DESKS /* TBD - Use per virtual root bg window? */
#if USE_COMPOSITE
/* Add background window */
eo = EobjWindowCreate(EOBJ_TYPE_ROOT_BG,
0, 0, WinGetW(VROOT), WinGetH(VROOT),
0, "Root-bg");
eo->floating = 0;
EobjSetLayer(eo, 0);
EventCallbackRegister(EobjGetWin(eo), DeskHandleEvents, dsk);
dsk->bg.o_bg = eo;
ESelectInput(EobjGetWin(eo), EnterWindowMask);
#endif
#endif
}
else
{
EoSetFloating(dsk, 1);
EoSetLayer(dsk, 0);
/* Set the _XROOT... atoms so apps will find them even before the bg is set */
HintsSetRootInfo(EoGetWin(dsk), NoXID, 0);
}
#if USE_BG_WIN_ON_ALL_DESKS /* TBD - Use per virtual root bg window? */
#if USE_COMPOSITE
/* Add background window */
Esnprintf(buf, sizeof(buf), "Desk-bg-%d", desk);
eo = EobjWindowCreate(EOBJ_TYPE_MISC,
0, 0, WinGetW(VROOT), WinGetH(VROOT), 0, buf);
eo->floating = 0;
EobjReparent(eo, EoObj(dsk), 0, 0);
EobjSetLayer(eo, 0);
dsk->bg.o_bg = eo;
EventCallbackRegister(EobjGetWin(eo), DeskHandleEvents, dsk);
#endif
#endif
HintsSetRootHints(EoGetWin(dsk));
if (configure)
DeskConfigure(dsk);
/* Root window: Don't include ButtonPressMask as it may cause the event
* selection to fail for the other events too.
* The ButtonPress/ReleaseMask events are selected in SetupX(). */
if (desk == 0)
ESelectInputChange(EoGetWin(dsk), DESK_EVENT_MASK2, 0);
else
ESelectInput(EoGetWin(dsk), DESK_EVENT_MASK);
return dsk;
}
static void
DeskDestroy(Desk * dsk)
{
ModulesSignal(ESIGNAL_DESK_REMOVED, dsk);
#if USE_COMPOSITE
if (dsk->bg.o_bg)
{
EventCallbackUnregister(EobjGetWin(dsk->bg.o_bg), DeskHandleEvents,
dsk);
EobjWindowDestroy(dsk->bg.o_bg);
}
#endif
EventCallbackUnregister(EoGetWin(dsk), DeskHandleEvents, dsk);
DeskControlsDestroy(dsk, 1);
DeskControlsDestroy(dsk, 2);
if (dsk->bg.bg)
BackgroundDecRefcount(dsk->bg.bg);
EoFini(dsk);
desks.desk[dsk->num] = NULL;
Efree(dsk);
}
EObj *
DeskGetBackgroundObj(const Desk * dsk)
{
return (dsk) ? dsk->bg.o : NULL;
}
EX_Pixmap
DeskGetBackgroundPixmap(const Desk * dsk)
{
if (!dsk)
return NoXID;
return dsk->bg.pmap;
}
Background *
DeskBackgroundGet(const Desk * dsk)
{
return (dsk) ? dsk->bg.bg : NULL;
}
static void
DeskBackgroundConfigure(Desk * dsk)
{
Win win;
EX_Pixmap pmap = dsk->bg.pmap;
unsigned int pixel = dsk->bg.pixel;
if (EDebug(EDBUG_TYPE_DESKS))
Eprintf
("DeskBackgroundConfigure %d v=%d %#x/%#x: ext=%d pmap=%#x/%#x pixel=%#x/%#x\n",
dsk->num, dsk->viewable, EoGetXwin(dsk), EobjGetXwin(dsk->bg.o),
BackgroundIsNone(dsk->bg.bg), pmap, dsk->bg.pmap_set, pixel,
dsk->bg.pixel);
#if USE_COMPOSITE
if (dsk->bg.o_bg)
{
if (ECompMgrIsActive())
{
dsk->bg.o = dsk->bg.o_bg;
EobjMap(dsk->bg.o_bg, 0);
}
else
{
dsk->bg.o = EoObj(dsk);
EobjUnmap(dsk->bg.o_bg);
}
}
#endif
win = EobjGetWin(dsk->bg.o);
if (dsk->viewable || !dsk->bg.bg)
{
#if USE_COMPOSITE && !USE_BG_WIN_ON_ALL_DESKS
if (ECompMgrIsActive())
{
ECompMgrDeskConfigure(dsk);
ESetWindowBackgroundPixmap(win, NoXID, 0);
}
else
#endif
{
if (pmap != NoXID)
{
ESetWindowBackgroundPixmap(win, pmap, 1);
if (dsk->num == 0 && win != VROOT)
ESetWindowBackgroundPixmap(VROOT, pmap, 1);
}
else
{
ESetWindowBackground(win, pixel);
if (dsk->num == 0 && win != VROOT)
ESetWindowBackground(VROOT, pixel);
}
EClearWindow(win);
}
HintsSetRootInfo(EoGetWin(dsk), pmap, pixel);
}
else if (dsk->bg.bg)
{
if (!Conf.hints.set_xroot_info_on_root_window)
HintsSetRootInfo(EoGetWin(dsk), NoXID, 0);
ESetWindowBackgroundPixmap(win, NoXID, 0);
if (dsk->num == 0 && win != VROOT)
ESetWindowBackgroundPixmap(VROOT, NoXID, 0);
}
}
static void
DeskBackgroundRefresh(Desk * dsk, int why)
{
Background *bg = dsk->bg.bg;
EX_Pixmap pmap = dsk->bg.pmap;
unsigned int pixel = dsk->bg.pixel;
int changed = 0;
int reconfigure = 0;
if (EDebug(EDBUG_TYPE_DESKS))
Eprintf("DeskBackgroundRefresh %d v=%d why=%d pmap=%#x pixel=%#x\n",
dsk->num, dsk->viewable, why, pmap, pixel);
switch (why)
{
case DESK_BG_REFRESH:
if (bg && dsk->viewable)
BackgroundTouch(bg);
break;
case DESK_BG_RECONFIGURE_ALL:
reconfigure = 1;
break;
case DESK_BG_TIMEOUT:
if (bg && dsk->viewable)
BackgroundTouch(bg);
return;
case DESK_BG_FREE:
if (!bg || dsk->viewable)
return;
break;
}
if (bg)
{
if (dsk->viewable)
{
if (BackgroundGetSeqNo(bg) == dsk->bg.seq_no)
goto done;
pmap = BackgroundGetPixmap(bg);
pixel = 0;
if (pmap == NoXID)
BackgroundRealize(bg, EoGetWin(dsk), NoXID,
EoGetW(dsk), EoGetH(dsk), 1, &pmap, &pixel);
if (pmap != NoXID)
BackgroundPixmapSet(bg, pmap);
dsk->bg.seq_no = BackgroundGetSeqNo(bg);
changed = 1;
}
else
{
if (dsk->bg.pmap == NoXID)
return;
pmap = NoXID;
pixel = 0;
dsk->bg.seq_no = 0;
}
}
else
{
pmap = (Mode.root.ext_pmap_valid) ? Mode.root.ext_pmap : NoXID;
pixel = 0;
changed = pmap != dsk->bg.pmap_set;
}
done:
dsk->bg.pmap = pmap;
if (reconfigure || pmap != dsk->bg.pmap_set || pixel != dsk->bg.pixel)
{
dsk->bg.pixel = pixel;
DeskBackgroundConfigure(dsk);
dsk->bg.pmap_set = pmap;
}
if (bg && dsk->viewable)
if (Conf.hints.set_xroot_info_on_root_window)
HintsSetRootInfo(VROOT, pmap, pixel);
if (changed)
ModulesSignal(ESIGNAL_BACKGROUND_CHANGE, dsk);
}
void
DeskBackgroundSet(Desk * dsk, Background * bg)
{
if (!dsk)
return;
BackgroundSetForDesk(bg, dsk->num);
if (bg && BackgroundIsNone(bg))
bg = NULL;
if (dsk->bg.bg != bg)
{
if (dsk->bg.bg)
BackgroundDecRefcount(dsk->bg.bg);
if (bg)
BackgroundIncRefcount(bg);
}
dsk->bg.bg = bg;
DeskBackgroundRefresh(dsk, DESK_BG_REFRESH);
}
void
DesksBackgroundRefresh(Background * bg, int why)
{
Desk *dsk;
unsigned int i;
for (i = 0; i < Conf.desks.num; i++)
{
dsk = _DeskGet(i);
if (!dsk) /* May happen during init */
continue;
if (bg && dsk->bg.bg != bg)
continue;
DeskBackgroundRefresh(dsk, why);
}
}
static void
DeskResize(int desk, int w, int h)
{
Desk *dsk;
int x;
dsk = _DeskGet(desk);
if (dsk->num != 0)
{
x = (dsk->viewable) ? EoGetX(dsk) : WinGetW(VROOT);
EoMoveResize(dsk, x, 0, w, h);
}
#if USE_COMPOSITE
if (dsk->bg.o_bg)
EobjMoveResize(dsk->bg.o_bg, 0, 0, w, h);
#endif
DeskBackgroundRefresh(dsk, DESK_BG_REFRESH);
DeskControlsDestroy(dsk, 1);
DeskControlsCreate(dsk);
DeskControlsShow(dsk, 1);
}
Desk *
DeskGet(unsigned int desk)
{
if (desk >= Conf.desks.num)
return NULL;
return _DeskGet(desk);
}
Desk *
DeskGetValid(unsigned int desk)
{
if (desk >= Conf.desks.num)
desk = 0;
return _DeskGet(desk);
}
Desk *
DeskGetRelative(Desk * dsk, int inc)
{
unsigned int desk, num;
num = Conf.desks.num;
desk = (dsk) ? dsk->num : 0;
inc %= (int)num;
desk += num + inc;
desk %= num;
return _DeskGet(desk);
}
void
DeskGetArea(const Desk * dsk, int *ax, int *ay)
{
if (!dsk)
{
*ax = *ay = 0;
return;
}
*ax = dsk->current_area_x;
*ay = dsk->current_area_y;
}
void
DeskSetArea(Desk * dsk, int ax, int ay)
{
if (!dsk)
return;
dsk->current_area_x = ax;
dsk->current_area_y = ay;
}
void
DeskSetDirtyStack(Desk * dsk, EObj * eo)
{
dsk->stack.dirty++;
dsk->stack.latest = eo;
if (EobjGetType(eo) == EOBJ_TYPE_EWIN)
dsk->stack.update_client_list = 1;
if (EDebug(EDBUG_TYPE_STACKING))
Eprintf("DeskSetDirtyStack %d (%d): %s\n", dsk->num, dsk->stack.dirty,
EobjGetName(eo));
}
void
DeskCurrentGetArea(int *ax, int *ay)
{
DeskGetArea(desks.current, ax, ay);
}
static void
DeskCurrentSetArea(int ax, int ay)
{
DeskSetArea(desks.current, ax, ay);
}
unsigned int
DesksGetNumber(void)
{
return Conf.desks.num;
}
Desk *
DesksGetCurrent(void)
{
return desks.current;
}
unsigned int
DesksGetCurrentNum(void)
{
return desks.current->num;
}
void
DesksSetCurrent(Desk * dsk)
{
if (!dsk)
return;
desks.current = dsk;
}
static void
DesksResize(int w, int h)
{
unsigned int i;
BackgroundsInvalidate(0);
for (i = 0; i < Conf.desks.num; i++)
DeskResize(i, w, h);
EdgeWindowsShow();
ModulesSignal(ESIGNAL_DESK_RESIZE, NULL);
}
static void
ChangeNumberOfDesktops(unsigned int quantity)
{
unsigned int i;
int j, num;
EWin *const *lst;
if (quantity >= ENLIGHTENMENT_CONF_NUM_DESKTOPS)
quantity = ENLIGHTENMENT_CONF_NUM_DESKTOPS;
if (quantity <= 0 || quantity == Conf.desks.num)
return;
for (i = quantity; i < Conf.desks.num; i++)
DeskLower(i);
if (quantity > Conf.desks.num)
{
while (Conf.desks.num < quantity)
{
Conf.desks.num++;
DeskCreate(Conf.desks.num - 1, 1);
}
}
else if (quantity < Conf.desks.num)
{
lst = EwinListGetAll(&num);
for (j = 0; j < num; j++)
{
if (EoGetDeskNum(lst[j]) >= quantity)
EwinMoveToDesktop(lst[j], _DeskGet(0));
}
while (Conf.desks.num > quantity)
{
DeskDestroy(_DeskGet(Conf.desks.num - 1));
Conf.desks.num--;
}
}
if (DesksGetCurrentNum() >= Conf.desks.num)
DeskGotoNum(Conf.desks.num - 1);
HintsSetDesktopConfig();
autosave();
}
static void
DesksControlsCreate(void)
{
unsigned int i;
for (i = 0; i < Conf.desks.num; i++)
DeskControlsCreate(_DeskGet(i));
}
static void
DesksControlsDestroy(void)
{
unsigned int i;
for (i = 0; i < Conf.desks.num; i++)
DeskControlsDestroy(_DeskGet(i), 1);
}
static void
DesksControlsShow(void)
{
unsigned int i;
for (i = 0; i < Conf.desks.num; i++)
DeskControlsShow(_DeskGet(i), 1);
}
static void
DesksControlsRefresh(void)
{
DesksControlsDestroy();
DesksControlsCreate();
DesksControlsShow();
autosave();
}
#if 0 /* Unused */
static void
DeskShowTabs(void)
{
ButtonsForeach(2, NULL, ButtonShow);
}
static void
DeskHideTabs(void)
{
ButtonsForeach(2, NULL, ButtonHide);
}
#endif
static void
DeskButtonShowDefault(Button * b)
{
if (!ButtonDoShowDefault(b))
return;
ButtonShow(b);
}
static void
DeskShowButtons(void)
{
ButtonsForeach(0, NULL, DeskButtonShowDefault);
}
static void
MoveToDeskTop(Desk * dsk)
{
int i, j;
EoRaise(dsk);
j = -1;
i = 0;
while (j < 0 && i < (int)Conf.desks.num)
{
if (desks.order[i] == dsk->num)
j = i;
i++;
}
if (j < 0)
return;
if (j > 0)
{
for (i = j - 1; i >= 0; i--)
desks.order[i + 1] = desks.order[i];
desks.order[0] = dsk->num;
}
}
static void
MoveToDeskBottom(Desk * dsk)
{
int i, j;
EoLower(dsk);
j = -1;
i = 0;
while (j < 0 && i < (int)Conf.desks.num)
{
if (desks.order[i] == dsk->num)
j = i;
i++;
}
if (j < 0)
return;
if (j < (int)Conf.desks.num - 1)
{
for (i = j; i < (int)Conf.desks.num - 1; i++)
desks.order[i] = desks.order[i + 1];
desks.order[Conf.desks.num - 1] = dsk->num;
}
}
Desk *
DesktopAt(int x, int y)
{
Desk *dsk;
unsigned int i;
for (i = 0; i < Conf.desks.num; i++)
{
dsk = _DeskGet(desks.order[i]);
if (x >= EoGetX(dsk) && x < (EoGetX(dsk) + WinGetW(VROOT)) &&
y >= EoGetY(dsk) && y < (EoGetY(dsk) + WinGetH(VROOT)))
return _DeskGet(desks.order[i]);
}
return _DeskGet(0);
}
static void
DesksStackingCheck(void)
{
Desk *dsk;
unsigned int i;
for (i = 0; i < Conf.desks.num; i++)
{
dsk = _DeskGet(i);
if (i && !dsk->viewable)
continue;
if (!dsk->stack.dirty)
continue;
DeskRestack(dsk);
}
}
static void
_DesksIdler(void *data __UNUSED__)
{
DesksStackingCheck();
}
static void
DeskMove(Desk * dsk, int x, int y)
{
Desk *dd;
unsigned int i;
int n, v, dx, dy;
if (dsk->num <= 0)
return;
n = -1;
i = 0;
while (n < 0 && i < Conf.desks.num)
{
if (desks.order[i] == dsk->num)
n = i;
i++;
}
if (n < 0) /* Should not be possible */
return;
dx = x - EoGetX(dsk);
dy = y - EoGetY(dsk);
if (x == 0 && y == 0)
{
/* Desks below are obscured - touch and set unviewable */
for (i = n + 1; i < Conf.desks.num; i++)
{
dd = _DeskGet(desks.order[i]);
if (dd->viewable)
BackgroundTouch(dd->bg.bg);
dd->viewable = 0;
}
}
else
{
v = dsk->viewable;
for (i = n + 1; i < Conf.desks.num; i++)
{
dd = _DeskGet(desks.order[i]);
if (!dd->viewable && v)
{
dd->viewable = 1;
DeskBackgroundRefresh(_DeskGet(desks.order[i]),
DESK_BG_REFRESH);
}
else if (dd->viewable && !v)
{
BackgroundTouch(dd->bg.bg);
dd->viewable = 0;
}
if (EoGetX(dd) == 0 && EoGetY(dd) == 0)
v = 0;
}
}
EoMove(dsk, x, y);
if (dsk->tag)
ButtonMoveRelative(dsk->tag, dx, dy);
#if 0 /* FIXME - Remove? */
EWin *const *lst;
lst = EwinListGetAll(&n);
for (i = 0; i < (unsigned int)n; i++)
if (EoGetDesk(lst[i]) == dsk)
ICCCM_Configure(lst[i]);
#endif
}
static void
DeskHide(unsigned int desk)
{
Desk *dsk;
if (desk <= 0 || desk >= Conf.desks.num)
return;
dsk = _DeskGet(desk);
if (dsk->viewable)
BackgroundTouch(dsk->bg.bg);
dsk->viewable = 0;
EoMove(dsk, WinGetW(VROOT), 0);
}
static void
DeskEnter(Desk * dsk)
{
int i;
EGrabServer();
dsk->viewable = 1;
DeskBackgroundRefresh(dsk, DESK_BG_REFRESH);
MoveToDeskTop(dsk);
desks.prev_num = desks.current->num;
desks.previous = desks.current = dsk;
if (dsk->num == 0)
{
for (i = Conf.desks.num - 1; i > 0; i--)
DeskHide(desks.order[i]);
}
EwinsMoveStickyToDesk(dsk);
ButtonsMoveStickyToDesk(dsk);
DesksStackingCheck();
EdgeWindowsShow();
EUngrabServer();
}
void
DeskGotoNum(unsigned int desk)
{
Desk *dsk;
if (Conf.desks.desks_wraparound)
desk %= Conf.desks.num;
if (desk >= Conf.desks.num || desk == desks.current->num)
return;
dsk = _DeskGet(desk);
DeskGoto(dsk);
}
static void
DeskSwitchStart(void)
{
FocusNewDeskBegin();
}
static void
DeskSwitchDone(void)
{
HintsSetCurrentDesktop();
FocusNewDesk();
}
static void
_DeskGotoStart(Desk * dsk)
{
if (EDebug(EDBUG_TYPE_DESKS))
Eprintf("DeskGoto %d\n", dsk->num);
ModulesSignal(ESIGNAL_DESK_SWITCH_START, NULL);
MoveResizeSuspend();
DeskSwitchStart();
}
static void
_DeskGotoEnd(Desk * dsk)
{
DeskSwitchDone();
MoveResizeResume();
ModulesSignal(ESIGNAL_DESK_SWITCH_DONE, NULL);
if (EDebug(EDBUG_TYPE_DESKS))
Eprintf("DeskGoto %d done\n", dsk->num);
}
static int
_DeskGotoRun(EObj * eo, int run, void *state)
{
int *xy = (int *)state;
int x, y;
Desk *dsk = (Desk *) eo;
x = (run * xy[0]) >> 10;
y = (run * xy[1]) >> 10;
EobjMove(eo, x, y);
if (run == 0)
{
if (xy[2])
DeskEnter(dsk);
DeskMove(dsk, 0, 0);
_DeskGotoEnd(dsk);
EventsBlock(0);
}
return 0;
}
void
DeskGoto(Desk * dsk)
{
if (!dsk || dsk == desks.previous)
return;
_DeskGotoStart(dsk);
if (dsk->num > 0)
{
if (Conf.desks.slidein)
{
EventsBlock(1);
if (!dsk->viewable)
{
int x, y;
switch (Conf.desks.dragdir)
{
default:
case 0:
x = WinGetW(VROOT);
y = 0;
break;
case 1:
x = -WinGetW(VROOT);
y = 0;
break;
case 2:
x = 0;
y = WinGetH(VROOT);
break;
case 3:
x = 0;
y = -WinGetH(VROOT);
break;
}
DeskMove(dsk, x, y);
int xy[3] = { x, y, 0 };
DeskEnter(dsk);
AnimatorAdd(EoObj(dsk), ANIM_SLIDE, _DeskGotoRun,
1000000 / Conf.desks.slidespeed,
0, sizeof(xy), xy);
}
else
{
int xy[3] = { EoGetX(dsk), EoGetY(dsk), 1 };
AnimatorAdd(EoObj(dsk), ANIM_SLIDE, _DeskGotoRun,
1000000 / Conf.desks.slidespeed,
0, sizeof(xy), xy);
}
return;
}
else
{
DeskEnter(dsk);
}
DeskMove(dsk, 0, 0);
}
else
{
DeskEnter(dsk);
}
_DeskGotoEnd(dsk);
}
static void
UncoverDesktop(unsigned int desk)
{
Desk *dsk;
if (desk >= Conf.desks.num)
return;
dsk = _DeskGet(desk);
dsk->viewable = 1;
DeskBackgroundRefresh(dsk, DESK_BG_REFRESH);
}
static void
DeskRaise(unsigned int desk)
{
Desk *dsk;
if (desk >= Conf.desks.num)
return;
dsk = _DeskGet(desk);
if (EDebug(EDBUG_TYPE_DESKS))
Eprintf("DeskRaise(%d) current=%d\n", desk, desks.current->num);
DeskSwitchStart();
DeskEnter(dsk);
DeskSwitchDone();
ModulesSignal(ESIGNAL_DESK_SWITCH_DONE, NULL);
ESync(ESYNC_DESKS);
}
static void
DeskLower(unsigned int desk)
{
Desk *dsk;
if ((desk <= 0) || (desk >= Conf.desks.num))
return;
dsk = _DeskGet(desk);
DeskSwitchStart();
MoveToDeskBottom(dsk);
if (EDebug(EDBUG_TYPE_DESKS))
Eprintf("DeskLower(%d) %d -> %d\n", desk, desks.current->num,
desks.order[0]);
desks.previous = desks.current = DeskGet(desks.order[0]);
EGrabServer();
UncoverDesktop(desks.order[0]);
DeskHide(desk);
EwinsMoveStickyToDesk(desks.current);
ButtonsMoveStickyToDesk(desks.current);
DesksStackingCheck();
DeskSwitchDone();
if (Mode.mode == MODE_NONE)
ModulesSignal(ESIGNAL_DESK_SWITCH_DONE, NULL);
EUngrabServer();
ESync(ESYNC_DESKS);
}
#if 0 /* Unused */
void
DeskShow(int desk)
{
Desk *dsk;
int i;
if (desk < 0 || desk >= Conf.desks.num)
return;
dsk = _DeskGet(desk);
dsk->viewable = 1;
DeskBackgroundRefresh(dsk, DESK_BG_REFRESH);
MoveToDeskTop(desk);
if (desk == 0)
{
for (i = Conf.desks.num - 1; i > 0; i--)
DeskHide(desks.order[i]);
}
}
#endif
static void
DeskRestackSimple(Desk * dsk)
{
EObj *const *lst, *eo;
int i, num;
XWindowChanges xwc;
unsigned int value_mask;
eo = dsk->stack.latest;
lst = EobjListStackGetForDesk(&num, dsk);
if (num < 2)
return;
for (i = 0; i < num; i++)
if (lst[i] == eo)
break;
if (i >= num)
return;
eo->stacked = 1;
if (EDebug(EDBUG_TYPE_STACKING))
Eprintf("DeskRestackSimple %#x %s\n", EobjGetXwin(eo), EobjGetName(eo));
if (i < num - 1)
{
xwc.stack_mode = Above;
xwc.sibling = EobjGetXwin(lst[i + 1]);
}
else
{
xwc.stack_mode = Below;
xwc.sibling = EobjGetXwin(lst[i - 1]);
}
value_mask = CWSibling | CWStackMode;
if (EDebug(EDBUG_TYPE_STACKING))
Eprintf("DeskRestackSimple %#10x %s %#10lx\n", EobjGetXwin(eo),
(xwc.stack_mode == Above) ? "Above" : "Below", xwc.sibling);
XConfigureWindow(disp, EobjGetXwin(eo), value_mask, &xwc);
}
#define _APPEND_TO_WIN_LIST(win) \
{ \
wl = EREALLOC(EX_Window, wl, ++tot); \
wl[tot - 1] = win; \
}
void
DeskRestack(Desk * dsk)
{
EX_Window *wl;
int i, num, tot;
EObj *const *lst, *eo;
if (!dsk->stack.dirty)
return;
/* Special case if only one window needs restacking */
if (dsk->stack.dirty == 1)
{
DeskRestackSimple(dsk);
goto done;
}
/* Build the window stack, top to bottom */
tot = 0;
wl = NULL;
lst = EobjListStackGetForDesk(&num, dsk);
/* Normal objects */
for (i = 0; i < num; i++)
{
eo = lst[i];
_APPEND_TO_WIN_LIST(EobjGetXwin(eo));
eo->stacked = 1;
}
if (EDebug(EDBUG_TYPE_STACKING))
{
Eprintf("DeskRestack %d (%d):\n", dsk->num, dsk->stack.dirty);
for (i = 0; i < tot; i++)
Eprintf(" win=%#10x parent=%#10x\n", wl[i],
EXWindowGetParent(wl[i]));
}
EXRestackWindows(wl, tot);
Efree(wl);
done:
if (dsk->stack.update_client_list)
{
dsk->stack.update_client_list = 0;
HintsSetClientStacking();
ClickGrabsUpdate();
}
dsk->stack.dirty = 0;
dsk->stack.latest = NULL;
}
void
DeskGotoByEwin(EWin * ewin)
{
if (EoIsSticky(ewin) || EoIsFloating(ewin))
return;
DeskGoto(EoGetDesk(ewin));
DeskCurrentGotoArea(ewin->area_x, ewin->area_y);
}
/*
* Areas
*/
void
DesksFixArea(int *ax, int *ay)
{
if (*ax < 0)
{
if (Conf.desks.areas_wraparound)
*ax = Conf.desks.areas_nx - 1;
else
*ax = 0;
}
else if (*ax >= Conf.desks.areas_nx)
{
if (Conf.desks.areas_wraparound)
*ax = 0;
else
*ax = Conf.desks.areas_nx - 1;
}
if (*ay < 0)
{
if (Conf.desks.areas_wraparound)
*ay = Conf.desks.areas_ny - 1;
else
*ay = 0;
}
else if (*ay >= Conf.desks.areas_ny)
{
if (Conf.desks.areas_wraparound)
*ay = 0;
else
*ay = Conf.desks.areas_ny - 1;
}
}
static int
AreaXYToLinear(int ax, int ay)
{
DesksFixArea(&ax, &ay);
return (ay * Conf.desks.areas_nx) + ax;
}
static void
AreaLinearToXY(int a, int *ax, int *ay)
{
if (a < 0)
a = 0;
else if (a >= (Conf.desks.areas_nx * Conf.desks.areas_ny))
a = (Conf.desks.areas_nx * Conf.desks.areas_ny) - 1;
*ay = a / Conf.desks.areas_nx;
*ax = a - (*ay * Conf.desks.areas_nx);
}
static void
SetAreaSize(int aw, int ah)
{
if (aw < 1)
aw = 1;
if (ah < 1)
ah = 1;
Conf.desks.areas_nx = aw;
Conf.desks.areas_ny = ah;
HintsSetViewportConfig();
EdgeWindowsShow();
ModulesSignal(ESIGNAL_AREA_CONFIGURED, NULL);
}
void
DesksGetAreaSize(int *aw, int *ah)
{
*aw = Conf.desks.areas_nx;
*ah = Conf.desks.areas_ny;
}
static void
SetNewAreaSize(int ax, int ay)
{
int a, b, i, num;
EWin *const *lst;
if (ax <= 0)
return;
if (ay <= 0)
return;
DesksGetAreaSize(&a, &b);
if ((a == ax) && (b == ay))
return;
SetAreaSize(ax, ay);
lst = EwinListGetAll(&num);
for (i = 0; i < num; i++)
{
if (!EoIsSticky(lst[i]))
{
if (lst[i]->area_x >= ax)
EwinMoveToArea(lst[i], ax - 1, lst[i]->area_x);
if (lst[i]->area_y >= ay)
EwinMoveToArea(lst[i], lst[i]->area_x, ay - 1);
}
}
DeskCurrentGetArea(&a, &b);
if (a >= ax)
{
DeskCurrentGotoArea(ax - 1, b);
DeskCurrentGetArea(&a, &b);
}
if (b >= ay)
DeskCurrentGotoArea(a, ay - 1);
autosave();
}
static void
SetCurrentLinearArea(int a)
{
int ax, ay;
AreaLinearToXY(a, &ax, &ay);
DeskCurrentGotoArea(ax, ay);
}
static int
GetCurrentLinearArea(void)
{
int ax, ay;
DeskCurrentGetArea(&ax, &ay);
return AreaXYToLinear(ax, ay);
}
static void
MoveCurrentLinearAreaBy(int a)
{
SetCurrentLinearArea(GetCurrentLinearArea() + a);
}
/* Return 1 to disable area switch */
static int
_DeskAreaSwitchCheckEwins(void)
{
EWin *const *lst, *ewin;
int i, num;
lst = EwinListGetForDesk(&num, desks.current);
for (i = 0; i < num; i++)
{
ewin = lst[i];
/* Disable if there are non-sticky shading windows */
if (EoIsSticky(ewin) || ewin->state.iconified)
continue;
if (ewin->state.shading)
return 1;
}
return 0;
}
static void
DeskAreaSwitchStart(void)
{
FocusNewDeskBegin();
}
static void
DeskAreaSwitchDone(void)
{
HintsSetDesktopViewport();
FocusNewDesk();
}
static void
_DeskCurrentGotoAreaStart(int pax, int pay, int ax, int ay)
{
if (EDebug(EDBUG_TYPE_DESKS))
Eprintf("DeskCurrentGotoArea %d,%d\n", ax, ay);
ModulesSignal(ESIGNAL_AREA_SWITCH_START, NULL);
if (ax < pax)
SoundPlay(SOUND_MOVE_AREA_LEFT);
else if (ax > pax)
SoundPlay(SOUND_MOVE_AREA_RIGHT);
else if (ay < pay)
SoundPlay(SOUND_MOVE_AREA_UP);
else if (ay > pay)
SoundPlay(SOUND_MOVE_AREA_DOWN);
MoveResizeSuspend();
DeskAreaSwitchStart();
/* set the current area up in out data structs */
DeskCurrentSetArea(ax, ay);
}
typedef struct {
EWin *const *ewins_desk;
EWin **ewins_slide;
int n_ewins_desk, n_ewins_slide;
int slide_dx, slide_dy;
} slide_area_data_t;
static void
_DeskCurrentGotoAreaEnd(slide_area_data_t * sad)
{
EWin *const *lst, *ewin;
int i, num, dx, dy;
desks.anim_slide = NULL;
lst = sad->ewins_desk;
num = sad->n_ewins_desk;
dx = sad->slide_dx;
dy = sad->slide_dy;
/* move all windows to their final positions */
for (i = 0; i < num; i++)
{
ewin = lst[i];
if (EwinIsTransientChild(ewin))
continue;
if (EoGetDesk(ewin) != DesksGetCurrent() && !EoIsFloating(ewin))
continue;
if (EoIsSticky(ewin) ||
(EoIsFloating(ewin) && Conf.movres.mode_move == MR_OPAQUE) ||
(!ewin->state.iconified && Conf.desks.slidein))
EwinMove(ewin, EoGetX(ewin), EoGetY(ewin), MRF_NOCHECK_ONSCREEN);
else
EwinMove(ewin, EoGetX(ewin) - dx, EoGetY(ewin) - dy,
MRF_NOCHECK_ONSCREEN);
}
Efree(sad->ewins_slide);
if (!Conf.desks.slidein)
EobjsRepaint();
MoveResizeResume();
/* re-focus on a new ewin on that new desktop area */
DeskAreaSwitchDone();
if (EDebug(EDBUG_TYPE_DESKS))
Eprintf("%s done\n", __func__);
ModulesSignal(ESIGNAL_AREA_SWITCH_DONE, DesksGetCurrent());
/* update which "edge flip resistance" detector windows are visible */
EdgeWindowsShow();
}
static int
_DeskCurrentGotoAreaRun(EObj * eo __UNUSED__, int run, void *state)
{
slide_area_data_t *sad = (slide_area_data_t *) state;
EWin *ewin;
int i, dx, dy;
dx = (run * sad->slide_dx) >> 10;
dy = (run * sad->slide_dy) >> 10;
for (i = 0; i < sad->n_ewins_slide; i++)
{
ewin = sad->ewins_slide[i];
EoMove(ewin, ewin->trg_x + dx, ewin->trg_y + dy);
}
if (run == 0)
{
_DeskCurrentGotoAreaEnd(sad);
EventsBlock(0);
}
return 0;
}
void
DeskCurrentGotoArea(int ax, int ay)
{
slide_area_data_t _sad, *sad = &_sad;
EWin *const *lst, *ewin;
int i, num, dx, dy, pax, pay;
if (desks.anim_slide)
return;
if ((Mode.mode == MODE_RESIZE) || (Mode.mode == MODE_RESIZE_H)
|| (Mode.mode == MODE_RESIZE_V))
return;
if (_DeskAreaSwitchCheckEwins())
return;
DesksFixArea(&ax, &ay);
DeskCurrentGetArea(&pax, &pay);
if (ax == pax && ay == pay)
return;
_DeskCurrentGotoAreaStart(pax, pay, ax, ay);
/* move all the windows around */
dx = WinGetW(VROOT) * (ax - pax);
dy = WinGetH(VROOT) * (ay - pay);
lst = EwinListGetAll(&num);
sad->ewins_desk = lst;
sad->n_ewins_desk = num;
sad->ewins_slide = NULL;
sad->n_ewins_slide = 0;
sad->slide_dx = dx;
sad->slide_dy = dy;
if (Conf.desks.slidein && Conf.desks.slidespeed > 10)
{
int wnum = 0;
EWin **wl = NULL;
/* create the list of windwos to move */
for (i = 0; i < num; i++)
{
ewin = lst[i];
if (EoIsSticky(ewin) || ewin->state.iconified)
continue;
if (EoGetDesk(ewin) != DesksGetCurrent() && !EoIsFloating(ewin))
continue;
if (EoIsFloating(ewin) && Conf.movres.mode_move == MR_OPAQUE)
continue;
wnum++;
wl = EREALLOC(EWin *, wl, wnum);
wl[wnum - 1] = ewin;
ewin->trg_x = EoGetX(ewin) - dx;
ewin->trg_y = EoGetY(ewin) - dy;
}
sad->ewins_slide = wl;
sad->n_ewins_slide = wnum;
/* slide them */
if (wl)
{
desks.anim_slide =
AnimatorAdd(NULL, ANIM_SLIDE, _DeskCurrentGotoAreaRun,
1000000 / Conf.desks.slidespeed,
0, sizeof(slide_area_data_t), sad);
EventsBlock(1);
return;
}
}
_DeskCurrentGotoAreaEnd(sad);
}
void
DeskCurrentMoveAreaBy(int dx, int dy)
{
int ax, ay;
DeskCurrentGetArea(&ax, &ay);
DeskCurrentGotoArea(ax + dx, ay + dy);
}
/*
* Actions, events
*/
static char sentpress = 0;
static void
ButtonProxySendEvent(XEvent * ev)
{
if (Mode.button_proxy_win)
EXSendEvent(Mode.button_proxy_win, SubstructureNotifyMask, ev);
}
static void
DeskDragStart(int desk)
{
Desk *dsk;
dsk = DeskGet(desk);
if (!dsk)
return;
desks.drag_x0 = Mode.events.cx - EoGetX(dsk);
desks.drag_y0 = Mode.events.cy - EoGetY(dsk);
Mode.mode = MODE_DESKDRAG;
}
static void
DeskDragEnd(Desk * dsk __UNUSED__)
{
Mode.mode = MODE_NONE;
}
static void
DeskDragMotion(Desk * dsk)
{
int x, y;
x = Mode.events.mx - desks.drag_x0;
y = Mode.events.my - desks.drag_y0;
switch (Conf.desks.dragdir)
{
case 0:
if (x < 0)
x = 0;
y = 0;
break;
case 1:
if (x > 0)
x = 0;
y = 0;
break;
case 2:
x = 0;
if (y < 0)
y = 0;
break;
case 3:
x = 0;
if (y > 0)
y = 0;
break;
default:
break;
}
DeskMove(dsk, x, y);
}
static void
DeskButtonCallback(void *prm, XEvent * ev, ActionClass * ac)
{
Desk *dsk = (Desk *) prm;
if (Mode.mode != MODE_DESKDRAG)
{
if (ac)
ActionclassEvent(ac, ev, NULL);
return;
}
switch (ev->type)
{
case ButtonRelease:
DeskDragEnd(dsk);
break;
case MotionNotify:
DeskDragMotion(dsk);
break;
}
}
static int
DeskCheckAction(Desk * dsk __UNUSED__, XEvent * ev)
{
ActionClass *ac;
ac = ActionclassFind("DESKBINDINGS");
if (!ac)
return 0;
return ActionclassEvent(ac, ev, NULL);
}
static void
DeskEventButtonPress(Desk * dsk, XEvent * ev)
{
/* Don't handle desk bindings while doing stuff */
if (Mode.mode)
return;
GrabPointerRelease();
if (!DeskCheckAction(dsk, ev))
ButtonProxySendEvent(ev);
}
static void
DeskEventButtonRelease(Desk * dsk, XEvent * ev)
{
/* Don't handle desk bindings while doing stuff */
if (Mode.mode)
return;
if (sentpress)
{
/* We never get here? */
sentpress = 0;
ButtonProxySendEvent(ev);
}
DeskCheckAction(dsk, ev);
}
static void
DeskRootResize(int root, int w, int h)
{
if (EDebug(EDBUG_TYPE_DESKS))
Eprintf("DeskRootResize %d %dx%d\n", root, w, h);
if (root && (VROOT != RROOT))
{
WinGetW(RROOT) = w;
WinGetH(RROOT) = h;
}
/* Quit if no change */
if (w == WinGetW(VROOT) && h == WinGetH(VROOT))
return;
EWindowSync(VROOT);
/* Quit if size is not final */
if (w != WinGetW(VROOT) || h != WinGetH(VROOT))
return;
ScreenInit();
DesksResize(w, h);
HintsSetDesktopConfig();
Mode.screen.w_old = WinGetW(VROOT);
Mode.screen.h_old = WinGetH(VROOT);
}
static ActionClass *
DeskGetAclass(void *data __UNUSED__)
{
return ActionclassFind("DESKBINDINGS");
}
static void
DeskPropertyChange(Desk * dsk, XEvent * ev)
{
EX_Pixmap pmap;
if (ev->xproperty.atom == E_XROOTPMAP_ID)
{
/* Possible race here? */
pmap = HintsGetRootPixmap(EoGetWin(dsk));
if (EDebug(EDBUG_TYPE_DESKS))
Eprintf("DeskPropertyChange win=%#lx _XROOTPMAP_ID=%#x\n",
ev->xany.window, pmap);
if (ev->xany.window != WinGetXwin(VROOT))
return;
if (pmap == dsk->bg.pmap)
return;
if (pmap == Mode.root.ext_pmap)
return;
Mode.root.ext_pmap = pmap;
Mode.root.ext_pmap_valid = EXDrawableOk(pmap);
DesksBackgroundRefresh(NULL, DESK_BG_REFRESH);
}
else if (ev->xproperty.atom == E_XROOTCOLOR_PIXEL)
{
if (EDebug(EDBUG_TYPE_DESKS))
Eprintf("DeskPropertyChange win=%#lx _XROOTCOLOR_PIXEL\n",
ev->xany.window);
if (ev->xany.window != WinGetXwin(VROOT))
return;
}
}
static void
DeskHandleEvents(Win win __UNUSED__, XEvent * ev, void *prm)
{
Desk *dsk = (Desk *) prm;
switch (ev->type)
{
case ButtonPress:
DeskEventButtonPress(dsk, ev);
break;
case ButtonRelease:
DeskEventButtonRelease(dsk, ev);
break;
case EnterNotify:
FocusHandleEnter(NULL, ev);
break;
case LeaveNotify:
FocusHandleLeave(NULL, ev);
break;
case MotionNotify:
/* Motion over desk buttons doesn't go here - We probably don't care much. */
DesksSetCurrent(DesktopAt(Mode.events.mx, Mode.events.my));
TooltipsSetPending(1, DeskGetAclass, dsk);
break;
case ConfigureNotify:
if (ev->xconfigure.window != WinGetXwin(VROOT))
break;
if (Mode.wm.window) /* This test should not be necessary but... */
{
Mode.wm.win_x = ev->xconfigure.x;
Mode.wm.win_y = ev->xconfigure.y;
}
DeskRootResize(0, ev->xconfigure.width, ev->xconfigure.height);
break;
case PropertyNotify:
if (ev->xany.window == WinGetXwin(VROOT))
DeskPropertyChange(dsk, ev);
break;
#if USE_XRANDR
case EX_EVENT_SCREEN_CHANGE_NOTIFY:
{
XRRScreenChangeNotifyEvent *rrev = (XRRScreenChangeNotifyEvent *) ev;
EventsRandrScreenChange(ev);
DeskRootResize(1, rrev->width, rrev->height);
}
break;
#endif
}
}
/* Settings */
static void
DeskDragdirSet(const char *params)
{
Desk *dsk;
unsigned int i;
int pd;
pd = Conf.desks.dragdir;
if (params && params[0])
Conf.desks.dragdir = atoi(params);
else
{
Conf.desks.dragdir++;
if (Conf.desks.dragdir > 3)
Conf.desks.dragdir = 0;
}
if (pd == Conf.desks.dragdir)
return;
for (i = 1; i < Conf.desks.num; i++)
{
dsk = _DeskGet(i);
EoMove(dsk, (dsk->viewable) ? 0 : WinGetW(VROOT), 0);
}
DesksControlsRefresh();
}
static void
DeskDragbarOrderSet(const char *params)
{
int pd;
pd = Conf.desks.dragbar_ordering;
if (params && params[0])
Conf.desks.dragbar_ordering = atoi(params);
else
{
Conf.desks.dragbar_ordering++;
if (Conf.desks.dragbar_ordering > 5)
Conf.desks.dragbar_ordering = 0;
}
if (pd == Conf.desks.dragbar_ordering)
return;
DesksControlsRefresh();
}
#if 0 /* FIXME */
static int
doDragbarWidthSet(EWin * edummy, const char *params)
{
int pd;
Button *b;
pd = Conf.desks.dragbar_width;
if (params)
Conf.desks.dragbar_width = atoi(params);
if (pd != Conf.desks.dragbar_width)
{
DesksControlsRefresh();
}
return 0;
}
static int
doDragbarLengthSet(EWin * edummy, const char *params)
{
int pd;
Button *b;
pd = Conf.desks.dragbar_length;
if (params)
Conf.desks.dragbar_length = atoi(params);
if (pd != Conf.desks.dragbar_length)
{
DesksControlsRefresh();
}
return 0;
}
#endif
#if ENABLE_DESKRAY
static int
doDeskray(EWin * edummy, const char *params)
{
if (params)
{
if (!atoi(params))
{
DeskHideTabs();
Conf.deskmode = MODE_NONE;
}
else
{
Conf.deskmode = MODE_DESKRAY;
DeskShowTabs();
}
}
else
{
if (Conf.deskmode == MODE_DESKRAY)
{
DeskHideTabs();
Conf.deskmode = MODE_NONE;
}
else
{
Conf.deskmode = MODE_DESKRAY;
DeskShowTabs();
}
}
return 0;
}
#endif /* ENABLE_DESKRAY */
static void
DesksInit(void)
{
unsigned int i;
memset(&desks, 0, sizeof(desks));
Mode.screen.w_old = WinGetW(VROOT);
Mode.screen.h_old = WinGetH(VROOT);
Mode.backgrounds.mini_w = WinGetW(VROOT) / 12;
Mode.backgrounds.mini_h = WinGetH(VROOT) / 12;
/* Backward compatibility hack */
if (Conf.desks.edge_flip_resistance <= 0)
Conf.desks.edge_flip_mode = EDGE_FLIP_OFF;
desks.previous = NULL;
for (i = 0; i < Conf.desks.num; i++)
DeskCreate(i, 0);
SetAreaSize(Conf.desks.areas_nx, Conf.desks.areas_ny);
/* Retreive stuff from last time we were loaded if we're restarting */
EHintsGetDeskInfo();
HintsSetDesktopConfig();
HintsSetDesktopViewport();
}
static void
DesksConfigure(void)
{
unsigned int i;
for (i = 0; i < Conf.desks.num; i++)
DeskConfigure(_DeskGet(i));
UncoverDesktop(0);
}
/*
* Desktops Module
*/
static void
DesksSighan(int sig, void *prm __UNUSED__)
{
switch (sig)
{
case ESIGNAL_INIT:
DesksInit();
break;
case ESIGNAL_CONFIGURE:
DesksConfigure();
break;
case ESIGNAL_START:
/* Draw all the buttons that belong on the desktop */
DeskShowButtons();
IdlerAdd(_DesksIdler, NULL);
break;
}
}
#if ENABLE_DIALOGS
/*
* Dialogs
*/
typedef struct {
int desktops;
int prev_desktops;
DItem *desk_text;
char desktop_slide;
int desktop_slide_speed;
char desktop_wraparound;
char dragbar;
int dragdir;
char initialised;
Win wins[ENLIGHTENMENT_CONF_NUM_DESKTOPS];
} DeskDlgData;
static void
CB_ConfigureDesktops(Dialog * d, int val, void *data __UNUSED__)
{
DeskDlgData *dd = DLG_DATA_GET(d, DeskDlgData);
if (val >= 2)
return;
ChangeNumberOfDesktops(dd->desktops);
Conf.desks.slidein = dd->desktop_slide;
Conf.desks.slidespeed = dd->desktop_slide_speed;
Conf.desks.desks_wraparound = dd->desktop_wraparound;
if ((Conf.desks.dragdir != dd->dragdir) ||
((dd->dragbar) && (Conf.desks.dragbar_width < 1)) ||
((!dd->dragbar) && (Conf.desks.dragbar_width > 0)))
{
if (dd->dragbar)
Conf.desks.dragbar_width = 16;
else
Conf.desks.dragbar_width = 0;
Conf.desks.dragdir = dd->dragdir;
DesksControlsRefresh();
}
autosave();
}
static void
CB_DesktopDisplayRedraw(Dialog * d, int val, void *data)
{
DeskDlgData *dd = DLG_DATA_GET(d, DeskDlgData);
DItem *di = (DItem *) data;
int i;
int w, h;
Win win;
char s[64];
ImageClass *ic;
if ((val != 1) && (dd->prev_desktops == dd->desktops))
return;
dd->prev_desktops = dd->desktops;
win = DialogItemAreaGetWindow(di);
DialogItemAreaGetSize(di, &w, &h);
if (!dd->initialised)
{
ic = ImageclassFind("SETTINGS_DESKTOP_AREA", 1);
ImageclassApply(ic, win, 0, 0, STATE_NORMAL, ST_SOLID);
dd->initialised = 1;
}
for (i = 0; i < dd->desktops; i++)
{
if (!dd->wins[i])
{
Background *bg;
dd->wins[i] =
ECreateWindow(win, 0, 0, Mode.backgrounds.mini_w,
Mode.backgrounds.mini_h, 0);
ESetWindowBorderWidth(dd->wins[i], 1);
bg = DeskBackgroundGet(DeskGet(i));
if (bg)
{
EX_Pixmap pmap;
pmap = EGetWindowBackgroundPixmap(dd->wins[i]);
BackgroundApplyPmap(bg, dd->wins[i], pmap,
Mode.backgrounds.mini_w,
Mode.backgrounds.mini_h);
}
else
{
ic = ImageclassFind("SETTINGS_DESKTOP_AREA", 1);
ImageclassApply(ic, dd->wins[i], 0, 0, STATE_NORMAL,
ST_SOLID);
}
}
}
for (i = dd->desktops - 1; i >= 0; i--)
{
int num;
num = dd->desktops - 1;
if (num < 1)
num = 1;
EMoveWindow(dd->wins[i], (i * (w - Mode.backgrounds.mini_w - 2)) / num,
(i * (h - Mode.backgrounds.mini_h - 2)) / num);
ERaiseWindow(dd->wins[i]);
EMapWindow(dd->wins[i]);
}
for (i = dd->desktops; i < ENLIGHTENMENT_CONF_NUM_DESKTOPS; i++)
{
if (!dd->wins[i])
continue;
EUnmapWindow(dd->wins[i]);
}
Esnprintf(s, sizeof(s), "%i", dd->desktops);
DialogItemSetText(dd->desk_text, s);
}
static void
CB_DesktopDisplayAreaRedraw(DItem * di, int val __UNUSED__,
void *data __UNUSED__)
{
CB_DesktopDisplayRedraw(DialogItemGetDialog(di), 1, di);
}
static void
_DlgFillDesks(Dialog * d, DItem * table, void *data __UNUSED__)
{
DItem *di, *slider, *radio;
DeskDlgData *dd;
dd = DLG_DATA_SET(d, DeskDlgData);
if (!dd)
return;
dd->desktops = Conf.desks.num;
dd->prev_desktops = -1;
dd->desktop_slide = Conf.desks.slidein;
dd->desktop_slide_speed = Conf.desks.slidespeed;
dd->desktop_wraparound = Conf.desks.desks_wraparound;
if (Conf.desks.dragbar_width < 1)
dd->dragbar = 0;
else
dd->dragbar = 1;
dd->dragdir = Conf.desks.dragdir;
DialogItemTableSetOptions(table, 2, 0, 0, 0);
di = DialogAddItem(table, DITEM_TEXT);
DialogItemSetColSpan(di, 2);
DialogItemSetText(di, _("Number of virtual desktops:"));
di = dd->desk_text = DialogAddItem(table, DITEM_TEXT);
DialogItemSetColSpan(di, 2);
DialogItemSetText(di, "X");
di = slider = DialogAddItem(table, DITEM_SLIDER);
DialogItemSliderSetBounds(di, 1, 32);
DialogItemSliderSetUnits(di, 1);
DialogItemSliderSetJump(di, 1);
DialogItemSetColSpan(di, 2);
DialogItemSliderSetValPtr(di, &dd->desktops);
di = DialogAddItem(table, DITEM_AREA);
DialogItemSetColSpan(di, 2);
DialogItemAreaSetSize(di, 2 * Mode.backgrounds.mini_w,
2 * Mode.backgrounds.mini_h);
DialogItemAreaSetInitFunc(di, CB_DesktopDisplayAreaRedraw);
DialogItemSetCallback(slider, CB_DesktopDisplayRedraw, 0, di);
di = DialogAddItem(table, DITEM_SEPARATOR);
DialogItemSetColSpan(di, 2);
di = DialogAddItem(table, DITEM_CHECKBUTTON);
DialogItemSetColSpan(di, 2);
DialogItemSetText(di, _("Slide desktops around when changing"));
DialogItemCheckButtonSetPtr(di, &dd->desktop_slide);
di = DialogAddItem(table, DITEM_TEXT);
DialogItemSetColSpan(di, 2);
DialogItemSetAlign(di, 1024, 512);
DialogItemSetText(di, _("Desktop Slide speed:"));
di = DialogAddItem(table, DITEM_SLIDER);
DialogItemSetColSpan(di, 2);
DialogItemSliderSetBounds(di, 0, 20000);
DialogItemSliderSetUnits(di, 500);
DialogItemSliderSetJump(di, 1000);
DialogItemSliderSetValPtr(di, &dd->desktop_slide_speed);
di = DialogAddItem(table, DITEM_SEPARATOR);
DialogItemSetColSpan(di, 2);
di = DialogAddItem(table, DITEM_CHECKBUTTON);
DialogItemSetColSpan(di, 2);
DialogItemSetText(di, _("Wrap desktops around"));
DialogItemCheckButtonSetPtr(di, &dd->desktop_wraparound);
di = DialogAddItem(table, DITEM_SEPARATOR);
DialogItemSetColSpan(di, 2);
di = DialogAddItem(table, DITEM_CHECKBUTTON);
DialogItemSetColSpan(di, 2);
DialogItemSetText(di, _("Display desktop dragbar"));
DialogItemCheckButtonSetPtr(di, &dd->dragbar);
di = DialogAddItem(table, DITEM_TEXT);
DialogItemSetColSpan(di, 2);
DialogItemSetAlign(di, 0, 512);
DialogItemSetText(di, _("Drag bar position:"));
radio = di = DialogAddItem(table, DITEM_RADIOBUTTON);
DialogItemSetColSpan(di, 2);
DialogItemSetText(di, _("Top"));
DialogItemRadioButtonSetFirst(di, radio);
DialogItemRadioButtonGroupSetVal(di, 2);
di = DialogAddItem(table, DITEM_RADIOBUTTON);
DialogItemSetColSpan(di, 2);
DialogItemSetText(di, _("Bottom"));
DialogItemRadioButtonSetFirst(di, radio);
DialogItemRadioButtonGroupSetVal(di, 3);
di = DialogAddItem(table, DITEM_RADIOBUTTON);
DialogItemSetColSpan(di, 2);
DialogItemSetText(di, _("Left"));
DialogItemRadioButtonSetFirst(di, radio);
DialogItemRadioButtonGroupSetVal(di, 0);
di = DialogAddItem(table, DITEM_RADIOBUTTON);
DialogItemSetColSpan(di, 2);
DialogItemSetText(di, _("Right"));
DialogItemRadioButtonSetFirst(di, radio);
DialogItemRadioButtonGroupSetVal(di, 1);
DialogItemRadioButtonGroupSetValPtr(radio, &dd->dragdir);
}
const DialogDef DlgDesks = {
"CONFIGURE_DESKTOPS",
N_("Desks"),
N_("Multiple Desktop Settings"),
SOUND_SETTINGS_DESKTOPS,
"pix/desktops.png",
N_("Enlightenment Multiple Desktop\n" "Settings Dialog"),
_DlgFillDesks,
DLG_OAC, CB_ConfigureDesktops,
};
typedef struct {
int area_x;
int area_y;
int edge_flip;
int edge_resist;
DItem *area_text;
char area_wraparound;
int prev_ax, prev_ay;
Win awin;
} AreaDlgData;
static void
CB_ConfigureAreas(Dialog * d, int val, void *data __UNUSED__)
{
AreaDlgData *dd = DLG_DATA_GET(d, AreaDlgData);
if (val >= 2)
return;
SetNewAreaSize(dd->area_x, dd->area_y);
Conf.desks.areas_wraparound = dd->area_wraparound;
Conf.desks.edge_flip_mode = dd->edge_flip;
if (dd->edge_resist < 1)
dd->edge_resist = 1;
Conf.desks.edge_flip_resistance = dd->edge_resist;
autosave();
}
static void
CB_AreaDisplayRedraw(Dialog * d, int val, void *data)
{
AreaDlgData *dd = DLG_DATA_GET(d, AreaDlgData);
DItem *di = (DItem *) data;
char s[64];
Win win;
int w, h, ww, hh;
if ((val != 1) && (dd->prev_ax == dd->area_x) && (dd->prev_ay == dd->area_y))
return;
dd->prev_ax = dd->area_x;
dd->prev_ay = dd->area_y;
win = DialogItemAreaGetWindow(di);
DialogItemAreaGetSize(di, &w, &h);
if (val == 1)
{
ImageClass *ic;
EX_Pixmap pmap;
ic = ImageclassFind("SETTINGS_AREA_AREA", 1);
ImageclassApply(ic, win, 0, 0, STATE_NORMAL, ST_SOLID);
/* Note: awin is destroyed when the dialog is destroyed */
dd->awin = ECreateWindow(win, 0, 0, 18, 14, 0);
ic = ImageclassFind("SETTINGS_AREADESK_AREA", 1);
pmap = EGetWindowBackgroundPixmap(dd->awin);
ImageclassApplySimple(ic, dd->awin, pmap, STATE_NORMAL, 0, 0, 18, 14);
}
ww = 18 * dd->prev_ax;
hh = 14 * dd->prev_ay;
EMoveResizeWindow(dd->awin, (w - ww) / 2, (h - hh) / 2, ww, hh);
EMapWindow(dd->awin);
Esnprintf(s, sizeof(s), "%i x %i", dd->prev_ax, dd->prev_ay);
DialogItemSetText(dd->area_text, s);
}
static void
CB_AreaDisplayAreaRedraw(DItem * di, int val __UNUSED__, void *data __UNUSED__)
{
CB_AreaDisplayRedraw(DialogItemGetDialog(di), 1, di);
}
static void
_DlgFillAreas(Dialog * d, DItem * table, void *data __UNUSED__)
{
DItem *di, *slider, *slider2, *table2, *radio;
AreaDlgData *dd;
dd = DLG_DATA_SET(d, AreaDlgData);
if (!dd)
return;
dd->area_wraparound = Conf.desks.areas_wraparound;
dd->edge_flip = Conf.desks.edge_flip_mode;
dd->edge_resist = Conf.desks.edge_flip_resistance;
DesksGetAreaSize(&dd->area_x, &dd->area_y);
DialogItemTableSetOptions(table, 1, 0, 0, 0);
di = DialogAddItem(table, DITEM_TEXT);
DialogItemSetText(di, _("Virtual Desktop size:"));
di = dd->area_text = DialogAddItem(table, DITEM_TEXT);
DialogItemSetText(di, "X");
table2 = DialogAddItem(table, DITEM_TABLE);
DialogItemTableSetOptions(table2, 2, 0, 0, 0);
DialogAddItem(table2, DITEM_NONE);
di = slider = DialogAddItem(table2, DITEM_SLIDER);
DialogItemSliderSetMinLength(di, 10);
DialogItemSliderSetBounds(di, 1, 8);
DialogItemSliderSetUnits(di, 1);
DialogItemSliderSetJump(di, 1);
DialogItemSliderSetValPtr(di, &dd->area_x);
di = slider2 = DialogAddItem(table2, DITEM_SLIDER);
DialogItemSliderSetMinLength(di, 10);
DialogItemSliderSetOrientation(di, 0);
DialogItemSetFill(di, 0, 1);
DialogItemSliderSetBounds(di, 1, 8);
DialogItemSliderSetUnits(di, 1);
DialogItemSliderSetJump(di, 1);
DialogItemSliderSetValPtr(di, &dd->area_y);
di = DialogAddItem(table2, DITEM_AREA);
DialogItemAreaSetSize(di, 160, 120);
DialogItemAreaSetInitFunc(di, CB_AreaDisplayAreaRedraw);
DialogItemSetCallback(slider, CB_AreaDisplayRedraw, 0, di);
DialogItemSetCallback(slider2, CB_AreaDisplayRedraw, 0, di);
DialogAddItem(table, DITEM_SEPARATOR);
di = DialogAddItem(table, DITEM_CHECKBUTTON);
DialogItemSetText(di, _("Wrap virtual desktops around"));
DialogItemCheckButtonSetPtr(di, &dd->area_wraparound);
DialogAddItem(table, DITEM_SEPARATOR);
di = DialogAddItem(table, DITEM_TEXT);
DialogItemSetAlign(di, 0, 512);
DialogItemSetText(di, _("Edge Flip Mode:"));
radio = di = DialogAddItem(table, DITEM_RADIOBUTTON);
DialogItemSetText(di, _("Off"));
DialogItemRadioButtonSetFirst(di, radio);
DialogItemRadioButtonGroupSetVal(di, EDGE_FLIP_OFF);
di = DialogAddItem(table, DITEM_RADIOBUTTON);
DialogItemSetText(di, _("On"));
DialogItemRadioButtonSetFirst(di, radio);
DialogItemRadioButtonGroupSetVal(di, EDGE_FLIP_ON);
di = DialogAddItem(table, DITEM_RADIOBUTTON);
DialogItemSetText(di, _("Only when moving window"));
DialogItemRadioButtonSetFirst(di, radio);
DialogItemRadioButtonGroupSetVal(di, EDGE_FLIP_MOVE);
DialogItemRadioButtonGroupSetValPtr(radio, &dd->edge_flip);
di = DialogAddItem(table, DITEM_TEXT);
DialogItemSetText(di, _("Resistance at edge of screen:"));
di = DialogAddItem(table, DITEM_SLIDER);
DialogItemSliderSetMinLength(di, 10);
DialogItemSliderSetBounds(di, 1, 100);
DialogItemSliderSetUnits(di, 1);
DialogItemSliderSetJump(di, 10);
DialogItemSliderSetValPtr(di, &dd->edge_resist);
}
const DialogDef DlgAreas = {
"CONFIGURE_AREA",
N_("Areas"),
N_("Virtual Desktop Settings"),
SOUND_SETTINGS_AREA,
"pix/areas.png",
N_("Enlightenment Virtual Desktop\n" "Settings Dialog"),
_DlgFillAreas,
DLG_OAC, CB_ConfigureAreas,
};
#endif /* ENABLE_DIALOGS */
/*
* IPC functions
*/
static void
DeskOpGoto(unsigned int desk)
{
Desk *dsk;
Desk *pd = DesksGetCurrent();
if (desk >= Conf.desks.num)
return;
dsk = _DeskGet(desk);
DeskGoto(dsk);
if (DesksGetCurrent() != pd)
SoundPlay(SOUND_DESKTOP_SHUT);
}
static void
DeskOpGotoRel(int drel)
{
int desk;
desk = (int)DesksGetCurrentNum() + drel;
if (Conf.desks.desks_wraparound)
desk = (desk + Conf.desks.num) % Conf.desks.num;
DeskOpGoto((unsigned int)desk);
}
static void
DeskOpDrag(int desk)
{
DeskDragStart(desk);
}
static void
DesksIpcDesk(const char *params)
{
const char *p;
char cmd[128], prm[128];
int len, value;
unsigned int desk;
cmd[0] = prm[0] = '\0';
p = params;
if (p)
{
len = 0;
sscanf(p, "%100s %100s %n", cmd, prm, &len);
p += len;
}
desk = DesksGetCurrentNum();
if (!p || cmd[0] == '?')
{
IpcPrintf("Current Desktop: %d/%d\n", desk, Conf.desks.num);
}
else if (!strncmp(cmd, "set", 3))
{
sscanf(prm, "%u", &desk);
ChangeNumberOfDesktops(desk);
}
else if (!strncmp(cmd, "list", 2))
{
Desk *dsk;
for (desk = 0; desk < Conf.desks.num; desk++)
{
dsk = _DeskGet(desk);
IpcPrintf
("Desk %d: viewable=%d order=%d x,y=%4d,%4d wxh=%4dx%4d area x,y=%d,%d pmap=%#x\n",
desk, dsk->viewable, desks.order[desk],
EoGetX(dsk), EoGetY(dsk), EoGetW(dsk), EoGetH(dsk),
dsk->current_area_x, dsk->current_area_y, dsk->bg.pmap);
}
}
else if (!strncmp(cmd, "goto", 2))
{
sscanf(prm, "%u", &desk);
DeskOpGoto(desk);
}
else if (!strncmp(cmd, "next", 2))
{
DeskOpGotoRel(1);
}
else if (!strncmp(cmd, "prev", 2))
{
DeskOpGotoRel(-1);
}
else if (!strncmp(cmd, "back", 2))
{
DeskOpGoto(desks.prev_num);
}
else if (!strncmp(cmd, "this", 2))
{
DeskOpGotoRel(0);
}
else if (!strncmp(cmd, "raise", 2))
{
sscanf(prm, "%u", &desk);
SoundPlay(SOUND_DESKTOP_RAISE);
DeskRaise(desk);
}
else if (!strncmp(cmd, "lower", 2))
{
sscanf(prm, "%u", &desk);
SoundPlay(SOUND_DESKTOP_LOWER);
DeskLower(desk);
}
else if (!strcmp(cmd, "drag"))
{
if (prm[0])
desk = atoi(prm);
DeskOpDrag(desk);
}
else if (!strcmp(cmd, "clear"))
{
if (!strcmp(prm, "on"))
value = 1;
else if (!strcmp(prm, "off"))
value = 0;
else
value = !Mode.showing_desktop;
EwinsShowDesktop(value);
}
else if (!strncmp(cmd, "arrange", 3))
{
ArrangeEwins(prm);
}
}
static void
DesksIpcArea(const char *params)
{
const char *p;
char cmd[128], prm[128];
int len;
int ax, ay, dx, dy;
cmd[0] = prm[0] = '\0';
p = params;
if (p)
{
len = 0;
sscanf(p, "%100s %100s %n", cmd, prm, &len);
p += len;
}
DeskCurrentGetArea(&ax, &ay);
if (!p || cmd[0] == '?')
{
IpcPrintf("Current Area: %d %d\n", ax, ay);
}
else if (!strncmp(cmd, "set", 3))
{
sscanf(params, "%*s %i %i", &ax, &ay);
SetNewAreaSize(ax, ay);
}
else if (!strncmp(cmd, "goto", 2))
{
sscanf(params, "%*s %i %i", &ax, &ay);
DeskCurrentGotoArea(ax, ay);
}
else if (!strncmp(cmd, "move", 2))
{
dx = dy = 0;
sscanf(params, "%*s %i %i", &dx, &dy);
DeskCurrentMoveAreaBy(dx, dy);
}
else if (!strncmp(cmd, "lgoto", 2))
{
sscanf(params, "%*s %i", &ax);
SetCurrentLinearArea(ax);
}
else if (!strncmp(cmd, "lmove", 2))
{
dx = 0;
sscanf(params, "%*s %i", &dx);
MoveCurrentLinearAreaBy(dx);
}
}
static const IpcItem DesksIpcArray[] = {
{
DesksIpcDesk,
"desk", NULL,
"Desktop functions",
" desk ? Desktop info\n"
" desk drag Start deskdrag\n"
" desk set <nd> Set number of desktops\n"
" desk goto <d> Goto specified desktop\n"
" desk list Show desk info\n"
" desk next Goto next desktop\n"
" desk prev Goto previous desktop\n"
" desk back Goto previous active desktop\n"
" desk this Goto this desktop\n"
" desk lower <d> Lower desktop\n"
" desk raise <d> Raise desktop\n"
" desk arrange Arrange windows on desktop\"\n"
" desk clear [on/off] \"Show Desktop\"\n"}
,
{
DesksIpcArea,
"area", NULL,
"Area functions",
" area ? Area info\n"
" area set <nx> <ny> Set area size\n"
" area goto <ax> <ay> Goto specified area\n"
" area move <dx> <dy> Move relative to current area\n"
" area lgoto <al> Goto specified linear area\n"
" area lmove <dl> Move relative to current linear area\n"}
,
};
#define N_IPC_FUNCS (sizeof(DesksIpcArray)/sizeof(IpcItem))
static void
DesksCfgFuncCount(void *item __UNUSED__, const char *value)
{
ChangeNumberOfDesktops(atoi(value));
}
static void
DesksCfgFuncDragdir(void *item __UNUSED__, const char *value)
{
DeskDragdirSet(value);
}
static void
DesksCfgFuncDragdbarOrder(void *item __UNUSED__, const char *value)
{
DeskDragbarOrderSet(value);
}
static void
AreasCfgFuncSizeX(void *item __UNUSED__, const char *value)
{
int ax, ay;
DesksGetAreaSize(&ax, &ay);
SetNewAreaSize(atoi(value), ay);
}
static void
AreasCfgFuncSizeY(void *item __UNUSED__, const char *value)
{
int ax, ay;
DesksGetAreaSize(&ax, &ay);
SetNewAreaSize(ax, atoi(value));
}
static const CfgItem DesksCfgItems[] = {
CFG_FUNC_INT(Conf.desks, num, 2, DesksCfgFuncCount),
CFG_FUNC_INT(Conf.desks, dragdir, 2, DesksCfgFuncDragdir),
CFG_ITEM_INT(Conf.desks, dragbar_width, 16),
CFG_ITEM_INT(Conf.desks, dragbar_length, 0),
CFG_FUNC_INT(Conf.desks, dragbar_ordering, 1, DesksCfgFuncDragdbarOrder),
CFG_ITEM_BOOL(Conf.desks, desks_wraparound, 0),
CFG_ITEM_BOOL(Conf.desks, slidein, 1),
CFG_ITEM_INT(Conf.desks, slidespeed, 6000),
CFG_FUNC_INT(Conf.desks, areas_nx, 2, AreasCfgFuncSizeX),
CFG_FUNC_INT(Conf.desks, areas_ny, 1, AreasCfgFuncSizeY),
CFG_ITEM_BOOL(Conf.desks, areas_wraparound, 0),
CFG_ITEM_INT(Conf.desks, edge_flip_mode, EDGE_FLIP_ON),
CFG_ITEM_INT(Conf.desks, edge_flip_resistance, 25),
};
#define N_CFG_ITEMS (sizeof(DesksCfgItems)/sizeof(CfgItem))
/*
* Module descriptor
*/
extern const EModule ModDesktops;
const EModule ModDesktops = {
"desktops", "desk",
DesksSighan,
{N_IPC_FUNCS, DesksIpcArray},
{N_CFG_ITEMS, DesksCfgItems}
};
Reference in New Issue View Git Blame Copy Permalink