2258 lines
52 KiB
C
2258 lines
52 KiB
C
/*
|
|
* Copyright (C) 1999 Carsten Haitzler, Geoff Harrison and various contributors
|
|
* *
|
|
* 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"
|
|
|
|
char *
|
|
GetUniqueBGString(Background * bg)
|
|
{
|
|
char s[256];
|
|
const char *chmap =
|
|
"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_";
|
|
int n1, n2, n3, n4, n5, f1, f2, f3, f4, f5, f6;
|
|
|
|
n1 = (bg->bg.solid.r << 24) | (bg->bg.solid.g << 16) |
|
|
(bg->bg.solid.b << 8) | (bg->bg.tile << 7) | (bg->bg.keep_aspect << 6) |
|
|
(bg->top.keep_aspect << 5);
|
|
n2 = (bg->bg.xjust << 16) | (bg->bg.yjust);
|
|
n3 = (bg->bg.xperc << 16) | (bg->bg.yperc);
|
|
n4 = (bg->top.xjust << 16) | (bg->top.yjust);
|
|
n5 = (bg->top.xperc << 16) | (bg->top.yperc);
|
|
f1 = 0;
|
|
f2 = 0;
|
|
f3 = 0;
|
|
f4 = 0;
|
|
f5 = 0;
|
|
f6 = 0;
|
|
if (bg->bg.file)
|
|
{
|
|
char *f;
|
|
|
|
f = FindFile(bg->bg.file);
|
|
if (f)
|
|
{
|
|
f1 = fileinode(f);
|
|
f2 = filedev(f);
|
|
f3 = (int)moddate(f);
|
|
Efree(f);
|
|
}
|
|
}
|
|
if (bg->top.file)
|
|
{
|
|
char *f;
|
|
|
|
f = FindFile(bg->top.file);
|
|
if (f)
|
|
{
|
|
f4 = fileinode(f);
|
|
f5 = filedev(f);
|
|
f6 = (int)moddate(f);
|
|
Efree(f);
|
|
}
|
|
}
|
|
Esnprintf(s, sizeof(s),
|
|
"%c%c%c%c%c%c"
|
|
"%c%c%c%c%c%c"
|
|
"%c%c%c%c%c%c"
|
|
"%c%c%c%c%c%c"
|
|
"%c%c%c%c%c%c"
|
|
"%c%c%c%c%c%c"
|
|
"%c%c%c%c%c%c"
|
|
"%c%c%c%c%c%c"
|
|
"%c%c%c%c%c%c"
|
|
"%c%c%c%c%c%c"
|
|
"%c%c%c%c%c%c"
|
|
,
|
|
chmap[(n1 >> 0) & 0x3f],
|
|
chmap[(n1 >> 6) & 0x3f],
|
|
chmap[(n1 >> 12) & 0x3f],
|
|
chmap[(n1 >> 18) & 0x3f],
|
|
chmap[(n1 >> 24) & 0x3f],
|
|
chmap[(n1 >> 28) & 0x3f],
|
|
chmap[(n2 >> 0) & 0x3f],
|
|
chmap[(n2 >> 6) & 0x3f],
|
|
chmap[(n2 >> 12) & 0x3f],
|
|
chmap[(n2 >> 18) & 0x3f],
|
|
chmap[(n2 >> 24) & 0x3f],
|
|
chmap[(n2 >> 28) & 0x3f],
|
|
chmap[(n3 >> 0) & 0x3f],
|
|
chmap[(n3 >> 6) & 0x3f],
|
|
chmap[(n3 >> 12) & 0x3f],
|
|
chmap[(n3 >> 18) & 0x3f],
|
|
chmap[(n3 >> 24) & 0x3f],
|
|
chmap[(n3 >> 28) & 0x3f],
|
|
chmap[(n4 >> 0) & 0x3f],
|
|
chmap[(n4 >> 6) & 0x3f],
|
|
chmap[(n4 >> 12) & 0x3f],
|
|
chmap[(n4 >> 18) & 0x3f],
|
|
chmap[(n4 >> 24) & 0x3f],
|
|
chmap[(n4 >> 28) & 0x3f],
|
|
chmap[(n5 >> 0) & 0x3f],
|
|
chmap[(n5 >> 6) & 0x3f],
|
|
chmap[(n5 >> 12) & 0x3f],
|
|
chmap[(n5 >> 18) & 0x3f],
|
|
chmap[(n5 >> 24) & 0x3f],
|
|
chmap[(n5 >> 28) & 0x3f],
|
|
chmap[(f1 >> 0) & 0x3f],
|
|
chmap[(f1 >> 6) & 0x3f],
|
|
chmap[(f1 >> 12) & 0x3f],
|
|
chmap[(f1 >> 18) & 0x3f],
|
|
chmap[(f1 >> 24) & 0x3f],
|
|
chmap[(f1 >> 28) & 0x3f],
|
|
chmap[(f2 >> 0) & 0x3f],
|
|
chmap[(f2 >> 6) & 0x3f],
|
|
chmap[(f2 >> 12) & 0x3f],
|
|
chmap[(f2 >> 18) & 0x3f],
|
|
chmap[(f2 >> 24) & 0x3f],
|
|
chmap[(f2 >> 28) & 0x3f],
|
|
chmap[(f3 >> 0) & 0x3f],
|
|
chmap[(f3 >> 6) & 0x3f],
|
|
chmap[(f3 >> 12) & 0x3f],
|
|
chmap[(f3 >> 18) & 0x3f],
|
|
chmap[(f3 >> 24) & 0x3f],
|
|
chmap[(f3 >> 28) & 0x3f],
|
|
chmap[(f4 >> 0) & 0x3f],
|
|
chmap[(f4 >> 6) & 0x3f],
|
|
chmap[(f4 >> 12) & 0x3f],
|
|
chmap[(f4 >> 18) & 0x3f],
|
|
chmap[(f4 >> 24) & 0x3f],
|
|
chmap[(f4 >> 28) & 0x3f],
|
|
chmap[(f5 >> 0) & 0x3f],
|
|
chmap[(f5 >> 6) & 0x3f],
|
|
chmap[(f5 >> 12) & 0x3f],
|
|
chmap[(f5 >> 18) & 0x3f],
|
|
chmap[(f5 >> 24) & 0x3f],
|
|
chmap[(f5 >> 28) & 0x3f],
|
|
chmap[(f6 >> 0) & 0x3f],
|
|
chmap[(f6 >> 6) & 0x3f],
|
|
chmap[(f6 >> 12) & 0x3f],
|
|
chmap[(f6 >> 18) & 0x3f],
|
|
chmap[(f6 >> 24) & 0x3f],
|
|
chmap[(f6 >> 28) & 0x3f]
|
|
);
|
|
return duplicate(s);
|
|
}
|
|
|
|
void
|
|
ChangeNumberOfDesktops(int quantity)
|
|
{
|
|
int pnum, i, num;
|
|
EWin **lst;
|
|
|
|
pnum = mode.numdesktops;
|
|
for (i = quantity; i < ENLIGHTENMENT_CONF_NUM_DESKTOPS; i++)
|
|
LowerDesktop(i);
|
|
mode.numdesktops = quantity;
|
|
|
|
if (mode.numdesktops <= 0)
|
|
mode.numdesktops = 1;
|
|
else if (mode.numdesktops > ENLIGHTENMENT_CONF_NUM_DESKTOPS)
|
|
mode.numdesktops = ENLIGHTENMENT_CONF_NUM_DESKTOPS;
|
|
|
|
lst = (EWin **) ListItemType(&num, LIST_TYPE_EWIN);
|
|
if (lst)
|
|
{
|
|
for (i = 0; i < num; i++)
|
|
{
|
|
if (lst[i]->desktop >= mode.numdesktops)
|
|
MoveEwinToDesktop(lst[i], mode.numdesktops - 1);
|
|
}
|
|
Efree(lst);
|
|
}
|
|
if (mode.numdesktops > pnum)
|
|
{
|
|
Pager *p;
|
|
char s[1024];
|
|
|
|
for (i = pnum; i < mode.numdesktops; i++)
|
|
{
|
|
p = CreatePager();
|
|
if (p)
|
|
{
|
|
p->desktop = i;
|
|
Esnprintf(s, sizeof(s), "%i", i);
|
|
PagerTitle(p, s);
|
|
PagerShow(p);
|
|
}
|
|
}
|
|
}
|
|
else if (mode.numdesktops < pnum)
|
|
{
|
|
Pager **pl;
|
|
int j, num;
|
|
|
|
for (j = mode.numdesktops; j < pnum; j++)
|
|
{
|
|
pl = PagersForDesktop(j, &num);
|
|
if (pl)
|
|
{
|
|
for (i = 0; i < num; i++)
|
|
{
|
|
if (pl[i]->ewin)
|
|
ICCCM_Delete(pl[i]->ewin);
|
|
}
|
|
Efree(pl);
|
|
}
|
|
}
|
|
}
|
|
if (desks.current >= mode.numdesktops)
|
|
GotoDesktop(mode.numdesktops - 1);
|
|
|
|
GNOME_SetDeskCount();
|
|
GNOME_SetDeskNames();
|
|
|
|
if (mode.kde_support)
|
|
KDE_SetNumDesktops();
|
|
|
|
}
|
|
|
|
void
|
|
ShowDesktopControls()
|
|
{
|
|
Button **lst;
|
|
int num, i;
|
|
|
|
lst = (Button **) ListItemTypeID(&num, LIST_TYPE_BUTTON, 1);
|
|
if ((lst) && (num > 0))
|
|
{
|
|
for (i = 0; i < num; i++)
|
|
SimpleShowButton(lst[i]);
|
|
Efree(lst);
|
|
StackDesktops();
|
|
}
|
|
}
|
|
|
|
void
|
|
ShowDesktopTabs()
|
|
{
|
|
Button **lst;
|
|
int num, i;
|
|
|
|
lst = (Button **) ListItemTypeID(&num, LIST_TYPE_BUTTON, 2);
|
|
if ((lst) && (num > 0))
|
|
{
|
|
for (i = 0; i < num; i++)
|
|
SimpleShowButton(lst[i]);
|
|
Efree(lst);
|
|
StackDesktops();
|
|
}
|
|
}
|
|
|
|
void
|
|
HideDesktopTabs()
|
|
{
|
|
Button **lst;
|
|
int num, i;
|
|
|
|
lst = (Button **) ListItemTypeID(&num, LIST_TYPE_BUTTON, 2);
|
|
if ((lst) && (num > 0))
|
|
{
|
|
for (i = 0; i < num; i++)
|
|
HideButton(lst[i]);
|
|
Efree(lst);
|
|
StackDesktops();
|
|
}
|
|
}
|
|
|
|
void
|
|
MoveToDeskTop(int num)
|
|
{
|
|
int i, j;
|
|
|
|
EDBUG(6, "MoveToDeskTop");
|
|
j = -1;
|
|
i = 0;
|
|
while ((j < 0) && (i < ENLIGHTENMENT_CONF_NUM_DESKTOPS))
|
|
{
|
|
if (deskorder[i] == num)
|
|
j = i;
|
|
i++;
|
|
}
|
|
if (j < 0)
|
|
EDBUG_RETURN_;
|
|
if (j > 0)
|
|
{
|
|
for (i = j - 1; i >= 0; i--)
|
|
deskorder[i + 1] = deskorder[i];
|
|
deskorder[0] = num;
|
|
}
|
|
EDBUG_RETURN_;
|
|
}
|
|
|
|
void
|
|
MoveToDeskBottom(int num)
|
|
{
|
|
int i, j;
|
|
|
|
EDBUG(6, "MoveToDeskBottom");
|
|
j = -1;
|
|
i = 0;
|
|
while ((j < 0) && (i < ENLIGHTENMENT_CONF_NUM_DESKTOPS))
|
|
{
|
|
if (deskorder[i] == num)
|
|
j = i;
|
|
i++;
|
|
}
|
|
if (j < 0)
|
|
EDBUG_RETURN_;
|
|
if (j < ENLIGHTENMENT_CONF_NUM_DESKTOPS - 1)
|
|
{
|
|
for (i = j; i < ENLIGHTENMENT_CONF_NUM_DESKTOPS - 1; i++)
|
|
deskorder[i] = deskorder[i + 1];
|
|
deskorder[ENLIGHTENMENT_CONF_NUM_DESKTOPS - 1] = num;
|
|
}
|
|
EDBUG_RETURN_;
|
|
}
|
|
|
|
void
|
|
SlideWindowTo(Window win, int fx, int fy, int tx, int ty, int speed)
|
|
{
|
|
int k, spd, x, y, min;
|
|
struct timeval timev1, timev2;
|
|
int dsec, dusec;
|
|
double tm;
|
|
|
|
EDBUG(5, "SlideWindowTo");
|
|
spd = 16;
|
|
min = 2;
|
|
GrabX();
|
|
for (k = 0; k <= 1024; k += spd)
|
|
{
|
|
gettimeofday(&timev1, NULL);
|
|
x = ((fx * (1024 - k)) + (tx * k)) >> 10;
|
|
y = ((fy * (1024 - k)) + (ty * k)) >> 10;
|
|
EMoveWindow(disp, win, x, y);
|
|
XSync(disp, False);
|
|
gettimeofday(&timev2, NULL);
|
|
dsec = timev2.tv_sec - timev1.tv_sec;
|
|
dusec = timev2.tv_usec - timev1.tv_usec;
|
|
if (dusec < 0)
|
|
{
|
|
dsec--;
|
|
dusec += 1000000;
|
|
}
|
|
tm = (double)dsec + (((double)dusec) / 1000000);
|
|
spd = (int)((double)speed * tm);
|
|
if (spd < min)
|
|
spd = min;
|
|
}
|
|
EMoveWindow(disp, win, tx, ty);
|
|
UngrabX();
|
|
EDBUG_RETURN_;
|
|
}
|
|
|
|
void
|
|
KeepBGimages(Background * bg, char onoff)
|
|
{
|
|
if (onoff)
|
|
{
|
|
bg->keepim = 1;
|
|
}
|
|
else
|
|
{
|
|
bg->keepim = 0;
|
|
if (bg->bg.im)
|
|
Imlib_destroy_image(id, bg->bg.im);
|
|
bg->bg.im = NULL;
|
|
if (bg->top.im)
|
|
Imlib_destroy_image(id, bg->top.im);
|
|
bg->top.im = NULL;
|
|
if (bg->pmap)
|
|
Imlib_free_pixmap(id, bg->pmap);
|
|
bg->pmap = 0;
|
|
}
|
|
}
|
|
|
|
void
|
|
RemoveImagesFromBG(Background * bg)
|
|
{
|
|
if (bg->bg.file)
|
|
Efree(bg->bg.file);
|
|
if (bg->bg.real_file)
|
|
Efree(bg->bg.real_file);
|
|
bg->bg.file = NULL;
|
|
bg->bg.real_file = NULL;
|
|
if (bg->bg.im)
|
|
Imlib_destroy_image(id, bg->bg.im);
|
|
bg->bg.im = NULL;
|
|
if (bg->top.im)
|
|
Imlib_destroy_image(id, bg->top.im);
|
|
bg->top.im = NULL;
|
|
bg->keepim = 0;
|
|
if (bg->pmap)
|
|
Imlib_free_pixmap(id, bg->pmap);
|
|
bg->pmap = 0;
|
|
}
|
|
|
|
void
|
|
FreeDesktopBG(Background * bg)
|
|
{
|
|
|
|
EDBUG(6, "FreeDesktopBG");
|
|
|
|
if (!bg)
|
|
EDBUG_RETURN_;
|
|
|
|
if (bg->ref_count > 0)
|
|
{
|
|
char stuff[255];
|
|
|
|
Esnprintf(stuff, sizeof(stuff), "%u references remain", bg->ref_count);
|
|
DIALOG_OK("Background Error!", stuff);
|
|
|
|
EDBUG_RETURN_;
|
|
}
|
|
|
|
if (bg->bg.file)
|
|
Efree(bg->bg.file);
|
|
if (bg->bg.real_file)
|
|
Efree(bg->bg.real_file);
|
|
if (bg->bg.im)
|
|
Imlib_destroy_image(id, bg->bg.im);
|
|
if (bg->top.file)
|
|
Efree(bg->top.file);
|
|
if (bg->top.real_file)
|
|
Efree(bg->top.real_file);
|
|
if (bg->top.im)
|
|
Imlib_destroy_image(id, bg->top.im);
|
|
if (bg->pmap)
|
|
Imlib_free_pixmap(id, bg->pmap);
|
|
if (bg->name)
|
|
Efree(bg->name);
|
|
Efree(bg);
|
|
|
|
EDBUG_RETURN_;
|
|
}
|
|
|
|
Background *
|
|
CreateDesktopBG(char *name, ImlibColor * solid,
|
|
char *bg, char tile, char keep_aspect,
|
|
int xjust, int yjust, int xperc, int yperc,
|
|
char *top, char tkeep_aspect,
|
|
int txjust, int tyjust, int txperc, int typerc)
|
|
{
|
|
ImlibData *imd;
|
|
Background *d;
|
|
|
|
EDBUG(6, "CreateDesktopBG");
|
|
|
|
if (ird)
|
|
{
|
|
imd = ird;
|
|
}
|
|
else
|
|
{
|
|
imd = id;
|
|
}
|
|
|
|
d = Emalloc(sizeof(Background));
|
|
if (!d)
|
|
EDBUG_RETURN(NULL);
|
|
d->name = duplicate(name);
|
|
d->pmap = 0;
|
|
d->last_viewed = 0;
|
|
d->bg.solid.r = 160;
|
|
d->bg.solid.g = 160;
|
|
d->bg.solid.b = 160;
|
|
d->bg.file = NULL;
|
|
d->bg.real_file = NULL;
|
|
d->bg.im = NULL;
|
|
d->bg.tile = 1;
|
|
d->bg.keep_aspect = 1;
|
|
d->bg.xjust = 512;
|
|
d->bg.yjust = 512;
|
|
d->bg.xperc = 1024;
|
|
d->bg.yperc = 1024;
|
|
d->top.file = NULL;
|
|
d->top.real_file = NULL;
|
|
d->top.im = NULL;
|
|
d->top.keep_aspect = 1;
|
|
d->top.xjust = 512;
|
|
d->top.yjust = 512;
|
|
d->top.xperc = 0;
|
|
d->top.yperc = 0;
|
|
if (solid)
|
|
{
|
|
d->bg.solid.r = solid->r;
|
|
d->bg.solid.g = solid->g;
|
|
d->bg.solid.b = solid->b;
|
|
}
|
|
d->bg.file = NULL;
|
|
if (bg)
|
|
d->bg.file = duplicate(bg);
|
|
d->bg.tile = tile;
|
|
d->bg.keep_aspect = keep_aspect;
|
|
d->bg.xjust = xjust;
|
|
d->bg.yjust = yjust;
|
|
d->bg.xperc = xperc;
|
|
d->bg.yperc = yperc;
|
|
if (top)
|
|
d->top.file = duplicate(top);
|
|
d->top.keep_aspect = tkeep_aspect;
|
|
d->top.xjust = txjust;
|
|
d->top.yjust = tyjust;
|
|
d->top.xperc = txperc;
|
|
d->top.yperc = typerc;
|
|
d->cmclass = NULL;
|
|
d->keepim = 0;
|
|
d->ref_count = 0;
|
|
|
|
EDBUG_RETURN(d);
|
|
}
|
|
|
|
void
|
|
RefreshCurrentDesktop()
|
|
{
|
|
EDBUG(5, "RefreshCurrentDesktop");
|
|
RefreshDesktop(desks.current);
|
|
EDBUG_RETURN_;
|
|
}
|
|
|
|
void
|
|
RefreshDesktop(int num)
|
|
{
|
|
Background *dsk;
|
|
ImlibData *imd;
|
|
|
|
EDBUG(4, "RefreshDesktop");
|
|
|
|
num = num % ENLIGHTENMENT_CONF_NUM_DESKTOPS;
|
|
if (!desks.desk[num].viewable)
|
|
EDBUG_RETURN_;
|
|
dsk = desks.desk[num].bg;
|
|
if (!dsk)
|
|
EDBUG_RETURN_;
|
|
if ((ird) && (num == 0))
|
|
imd = ird;
|
|
else
|
|
imd = id;
|
|
|
|
SetBackgroundTo(imd, desks.desk[num].win, dsk, 1);
|
|
EDBUG_RETURN_;
|
|
}
|
|
|
|
void
|
|
SetBackgroundTo(ImlibData * imd, Window win, Background * dsk, char setbg)
|
|
{
|
|
int r, g, b, w, h, x, y, ww, hh;
|
|
unsigned int rw, rh;
|
|
Pixmap pmap, mask, dpmap;
|
|
GC gc;
|
|
XGCValues gcv;
|
|
char hasbg, hasfg;
|
|
int rt, depth;
|
|
ColorModifierClass *cm;
|
|
|
|
EDBUG(4, "SetBackgroundTo");
|
|
|
|
if (!WinExists(win))
|
|
EDBUG_RETURN_;
|
|
GetWinWH(win, &rw, &rh);
|
|
depth = GetWinDepth(win);
|
|
if ((depth != imd->x.depth) && (ird) && (depth == ird->x.depth))
|
|
imd = ird;
|
|
r = dsk->bg.solid.r;
|
|
g = dsk->bg.solid.g;
|
|
b = dsk->bg.solid.b;
|
|
dsk->bg.solid.pixel = Imlib_best_color_match(imd, &r, &g, &b);
|
|
pmap = 0;
|
|
gc = 0;
|
|
w = 0;
|
|
h = 0;
|
|
hasbg = 0;
|
|
hasfg = 0;
|
|
rt = Imlib_get_render_type(id);
|
|
|
|
if (desks.hiqualitybg)
|
|
Imlib_set_render_type(imd, RT_DITHER_TRUECOL);
|
|
|
|
dpmap = dsk->pmap;
|
|
if (!setbg)
|
|
dpmap = 0;
|
|
if (!dpmap)
|
|
{
|
|
cm = dsk->cmclass;
|
|
if (cm)
|
|
{
|
|
cm->ref_count--;
|
|
}
|
|
else
|
|
{
|
|
cm = (ColorModifierClass *) FindItem("BACKGROUND", 0,
|
|
LIST_FINDBY_NAME,
|
|
LIST_TYPE_COLORMODIFIER);
|
|
}
|
|
|
|
if (dsk->bg.file)
|
|
{
|
|
if (!dsk->bg.im)
|
|
{
|
|
if (!dsk->bg.real_file)
|
|
dsk->bg.real_file = FindFile(dsk->bg.file);
|
|
dsk->bg.im = ELoadImageImlibData(imd, dsk->bg.real_file);
|
|
}
|
|
}
|
|
if (dsk->top.file)
|
|
{
|
|
if (!dsk->top.im)
|
|
{
|
|
if (!dsk->top.real_file)
|
|
dsk->top.real_file = FindFile(dsk->top.file);
|
|
dsk->top.im = ELoadImageImlibData(imd, dsk->top.real_file);
|
|
}
|
|
}
|
|
if (cm)
|
|
{
|
|
cm->ref_count++;
|
|
if (dsk->top.im)
|
|
{
|
|
Imlib_set_image_red_curve(id, dsk->top.im,
|
|
cm->red.map);
|
|
Imlib_set_image_green_curve(id, dsk->top.im,
|
|
cm->green.map);
|
|
Imlib_set_image_blue_curve(id, dsk->top.im,
|
|
cm->blue.map);
|
|
}
|
|
if (dsk->bg.im)
|
|
{
|
|
Imlib_set_image_red_curve(id, dsk->bg.im,
|
|
cm->red.map);
|
|
Imlib_set_image_green_curve(id, dsk->bg.im,
|
|
cm->green.map);
|
|
Imlib_set_image_blue_curve(id, dsk->bg.im,
|
|
cm->blue.map);
|
|
}
|
|
}
|
|
}
|
|
if (dsk->top.im)
|
|
hasfg = 1;
|
|
if (dsk->bg.im)
|
|
hasbg = 1;
|
|
if ((hasfg) && (hasbg))
|
|
{
|
|
if (dsk->bg.xperc > 0)
|
|
{
|
|
w = (rw * dsk->bg.xperc) >> 10;
|
|
}
|
|
else
|
|
{
|
|
if (!setbg)
|
|
w = (dsk->bg.im->rgb_width * rw) / root.w;
|
|
else
|
|
w = dsk->bg.im->rgb_width;
|
|
}
|
|
if (dsk->bg.yperc > 0)
|
|
{
|
|
h = (rh * dsk->bg.yperc) >> 10;
|
|
}
|
|
else
|
|
{
|
|
if (!setbg)
|
|
{
|
|
h = (dsk->bg.im->rgb_height * rh) / root.h;
|
|
}
|
|
else
|
|
{
|
|
h = dsk->bg.im->rgb_height;
|
|
}
|
|
}
|
|
if (w <= 0)
|
|
w = 1;
|
|
if (h <= 0)
|
|
h = 1;
|
|
if (dsk->bg.keep_aspect)
|
|
{
|
|
if (dsk->bg.yperc <= 0)
|
|
{
|
|
if (((w << 10) / h) !=
|
|
((dsk->bg.im->rgb_width << 10) / dsk->bg.im->rgb_height))
|
|
h = ((w * dsk->bg.im->rgb_height) / dsk->bg.im->rgb_width);
|
|
}
|
|
else
|
|
{
|
|
if (((h << 10) / w) !=
|
|
((dsk->bg.im->rgb_height << 10) / dsk->bg.im->rgb_width))
|
|
w = ((h * dsk->bg.im->rgb_width) / dsk->bg.im->rgb_height);
|
|
}
|
|
}
|
|
dpmap = ECreatePixmap(disp, win, rw, rh, imd->x.depth);
|
|
gc = XCreateGC(disp, dpmap, 0, &gcv);
|
|
if (!dsk->bg.tile)
|
|
{
|
|
XSetForeground(disp, gc, dsk->bg.solid.pixel);
|
|
XFillRectangle(disp, dpmap, gc, 0, 0, rw, rh);
|
|
}
|
|
x = ((rw - w) * dsk->bg.xjust) >> 10;
|
|
y = ((rh - h) * dsk->bg.yjust) >> 10;
|
|
Imlib_render(imd, dsk->bg.im, w, h);
|
|
pmap = Imlib_move_image(imd, dsk->bg.im);
|
|
XSetTile(disp, gc, pmap);
|
|
XSetTSOrigin(disp, gc, x, y);
|
|
XSetFillStyle(disp, gc, FillTiled);
|
|
if (!dsk->bg.tile)
|
|
{
|
|
XFillRectangle(disp, dpmap, gc, x, y, w, h);
|
|
}
|
|
else
|
|
{
|
|
XFillRectangle(disp, dpmap, gc, 0, 0, rw, rh);
|
|
}
|
|
Imlib_free_pixmap(imd, pmap);
|
|
|
|
if (dsk->top.xperc > 0)
|
|
{
|
|
ww = (rw * dsk->top.xperc) >> 10;
|
|
}
|
|
else
|
|
{
|
|
if (!setbg)
|
|
{
|
|
ww = (dsk->top.im->rgb_width * rw) / root.w;
|
|
}
|
|
else
|
|
{
|
|
ww = dsk->top.im->rgb_width;
|
|
}
|
|
}
|
|
if (dsk->top.yperc > 0)
|
|
{
|
|
hh = (rh * dsk->top.yperc) >> 10;
|
|
}
|
|
else
|
|
{
|
|
if (!setbg)
|
|
{
|
|
hh = (dsk->top.im->rgb_height * rh) / root.h;
|
|
}
|
|
else
|
|
{
|
|
hh = dsk->top.im->rgb_height;
|
|
}
|
|
}
|
|
if (ww <= 0)
|
|
ww = 1;
|
|
if (hh <= 0)
|
|
hh = 1;
|
|
if (dsk->top.keep_aspect)
|
|
{
|
|
if (dsk->top.yperc <= 0)
|
|
{
|
|
if (((ww << 10) / hh) !=
|
|
((dsk->top.im->rgb_width << 10) / dsk->top.im->rgb_height))
|
|
hh = ((ww * dsk->top.im->rgb_height)
|
|
/ dsk->top.im->rgb_width);
|
|
}
|
|
else
|
|
{
|
|
if (((hh << 10) / ww) !=
|
|
((dsk->top.im->rgb_height << 10) / dsk->top.im->rgb_width))
|
|
ww = ((hh * dsk->top.im->rgb_width)
|
|
/ dsk->top.im->rgb_height);
|
|
}
|
|
}
|
|
Imlib_render(imd, dsk->top.im, ww, hh);
|
|
pmap = Imlib_move_image(imd, dsk->top.im);
|
|
mask = Imlib_move_mask(imd, dsk->top.im);
|
|
x = ((rw - ww) * dsk->top.xjust) >> 10;
|
|
y = ((rh - hh) * dsk->top.yjust) >> 10;
|
|
XSetTile(disp, gc, pmap);
|
|
XSetTSOrigin(disp, gc, x, y);
|
|
XSetFillStyle(disp, gc, FillTiled);
|
|
if (mask)
|
|
{
|
|
XSetClipMask(disp, gc, mask);
|
|
XSetClipOrigin(disp, gc, x, y);
|
|
}
|
|
XFillRectangle(disp, dpmap, gc, x, y, ww, hh);
|
|
Imlib_free_pixmap(imd, pmap);
|
|
}
|
|
else if (hasbg)
|
|
{
|
|
if (dsk->bg.xperc > 0)
|
|
w = (rw * dsk->bg.xperc) >> 10;
|
|
else
|
|
{
|
|
if (!setbg)
|
|
w = (dsk->bg.im->rgb_width * rw) / root.w;
|
|
else
|
|
w = dsk->bg.im->rgb_width;
|
|
}
|
|
if (dsk->bg.yperc > 0)
|
|
h = (rh * dsk->bg.yperc) >> 10;
|
|
else
|
|
{
|
|
if (!setbg)
|
|
h = (dsk->bg.im->rgb_height * rh) / root.h;
|
|
else
|
|
h = dsk->bg.im->rgb_height;
|
|
}
|
|
if (w <= 0)
|
|
w = 1;
|
|
if (h <= 0)
|
|
h = 1;
|
|
if (dsk->bg.keep_aspect)
|
|
{
|
|
if (dsk->bg.yperc <= 0)
|
|
{
|
|
if (((w << 10) / h) !=
|
|
((dsk->bg.im->rgb_width << 10) / dsk->bg.im->rgb_height))
|
|
h = ((w * dsk->bg.im->rgb_height) / dsk->bg.im->rgb_width);
|
|
}
|
|
else
|
|
{
|
|
if (((h << 10) / w) !=
|
|
((dsk->bg.im->rgb_height << 10) / dsk->bg.im->rgb_width))
|
|
w = ((h * dsk->bg.im->rgb_width) / dsk->bg.im->rgb_height);
|
|
}
|
|
}
|
|
dpmap = 0;
|
|
x = ((rw - w) * dsk->bg.xjust) >> 10;
|
|
y = ((rh - h) * dsk->bg.yjust) >> 10;
|
|
if (setbg)
|
|
{
|
|
if (dsk->bg.tile)
|
|
{
|
|
if ((x != 0) || (y != 0))
|
|
{
|
|
dpmap = ECreatePixmap(disp, win, w, h, imd->x.depth);
|
|
gc = XCreateGC(disp, dpmap, 0, &gcv);
|
|
}
|
|
}
|
|
else if ((x != 0) || (y != 0) || ((int)rw != (int)w)
|
|
|| ((int)rh != (int)h))
|
|
{
|
|
dpmap = ECreatePixmap(disp, win, rw, rh, imd->x.depth);
|
|
gc = XCreateGC(disp, dpmap, 0, &gcv);
|
|
XSetForeground(disp, gc, dsk->bg.solid.pixel);
|
|
XFillRectangle(disp, dpmap, gc, 0, 0, rw, rh);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (dsk->bg.tile)
|
|
{
|
|
dpmap = ECreatePixmap(disp, win, w, h, imd->x.depth);
|
|
gc = XCreateGC(disp, dpmap, 0, &gcv);
|
|
}
|
|
else
|
|
{
|
|
dpmap = ECreatePixmap(disp, win, rw, rh, imd->x.depth);
|
|
gc = XCreateGC(disp, dpmap, 0, &gcv);
|
|
XSetForeground(disp, gc, dsk->bg.solid.pixel);
|
|
XFillRectangle(disp, dpmap, gc, 0, 0, rw, rh);
|
|
}
|
|
}
|
|
Imlib_render(imd, dsk->bg.im, w, h);
|
|
pmap = Imlib_move_image(imd, dsk->bg.im);
|
|
if (dpmap)
|
|
{
|
|
XSetTile(disp, gc, pmap);
|
|
XSetTSOrigin(disp, gc, x, y);
|
|
XSetFillStyle(disp, gc, FillTiled);
|
|
if (dsk->bg.tile)
|
|
{
|
|
XFillRectangle(disp, dpmap, gc, 0, 0, w, h);
|
|
}
|
|
else
|
|
{
|
|
XFillRectangle(disp, dpmap, gc, x, y, w, h);
|
|
}
|
|
Imlib_free_pixmap(imd, pmap);
|
|
}
|
|
else
|
|
dpmap = pmap;
|
|
}
|
|
else if (hasfg)
|
|
{
|
|
dpmap = ECreatePixmap(disp, win, rw, rh, imd->x.depth);
|
|
gc = XCreateGC(disp, dpmap, 0, &gcv);
|
|
XSetForeground(disp, gc, dsk->bg.solid.pixel);
|
|
XFillRectangle(disp, dpmap, gc, 0, 0, rw, rh);
|
|
|
|
if (dsk->top.xperc > 0)
|
|
{
|
|
ww = (rw * dsk->top.xperc) >> 10;
|
|
}
|
|
else
|
|
{
|
|
if (!setbg)
|
|
{
|
|
ww = (dsk->top.im->rgb_width * rw) / root.w;
|
|
}
|
|
else
|
|
{
|
|
ww = dsk->top.im->rgb_width;
|
|
}
|
|
}
|
|
|
|
if (dsk->top.yperc > 0)
|
|
{
|
|
hh = (rh * dsk->top.yperc) >> 10;
|
|
}
|
|
else
|
|
{
|
|
if (!setbg)
|
|
{
|
|
hh = (dsk->top.im->rgb_height * rh) / root.h;
|
|
}
|
|
else
|
|
{
|
|
hh = dsk->top.im->rgb_height;
|
|
}
|
|
}
|
|
if (ww <= 0)
|
|
ww = 1;
|
|
if (hh <= 0)
|
|
hh = 1;
|
|
if (dsk->top.keep_aspect)
|
|
{
|
|
if (dsk->top.yperc <= 0)
|
|
{
|
|
if (((ww << 10) / hh) !=
|
|
((dsk->top.im->rgb_width << 10) / dsk->top.im->rgb_height))
|
|
hh = ((ww * dsk->top.im->rgb_height)
|
|
/ dsk->top.im->rgb_width);
|
|
}
|
|
else
|
|
{
|
|
if (((hh << 10) / ww) !=
|
|
((dsk->top.im->rgb_height << 10) / dsk->top.im->rgb_width))
|
|
ww = ((hh * dsk->top.im->rgb_width)
|
|
/ dsk->top.im->rgb_height);
|
|
}
|
|
}
|
|
Imlib_render(imd, dsk->top.im, ww, hh);
|
|
pmap = Imlib_move_image(imd, dsk->top.im);
|
|
mask = Imlib_move_mask(imd, dsk->top.im);
|
|
x = ((rw - ww) * dsk->top.xjust) >> 10;
|
|
y = ((rh - hh) * dsk->top.yjust) >> 10;
|
|
XSetTile(disp, gc, pmap);
|
|
XSetTSOrigin(disp, gc, x, y);
|
|
XSetFillStyle(disp, gc, FillTiled);
|
|
if (mask)
|
|
{
|
|
XSetClipMask(disp, gc, mask);
|
|
XSetClipOrigin(disp, gc, x, y);
|
|
}
|
|
XFillRectangle(disp, dpmap, gc, x, y, ww, hh);
|
|
Imlib_free_pixmap(imd, pmap);
|
|
}
|
|
if (!dsk->keepim)
|
|
{
|
|
if (dsk->top.im)
|
|
Imlib_destroy_image(imd, dsk->top.im);
|
|
if (dsk->bg.im)
|
|
Imlib_destroy_image(imd, dsk->bg.im);
|
|
dsk->top.im = NULL;
|
|
dsk->bg.im = NULL;
|
|
}
|
|
if (setbg)
|
|
{
|
|
if (dpmap)
|
|
{
|
|
SetBG(win, dpmap, 0);
|
|
}
|
|
else
|
|
{
|
|
SetBG(win, 0, dsk->bg.solid.pixel);
|
|
}
|
|
dsk->pmap = dpmap;
|
|
}
|
|
else
|
|
{
|
|
if (dpmap)
|
|
{
|
|
if (!gc)
|
|
gc = XCreateGC(disp, dpmap, 0, &gcv);
|
|
XSetClipMask(disp, gc, 0);
|
|
XSetTile(disp, gc, dpmap);
|
|
XSetTSOrigin(disp, gc, 0, 0);
|
|
XSetFillStyle(disp, gc, FillTiled);
|
|
XFillRectangle(disp, win, gc, 0, 0, rw, rh);
|
|
Imlib_free_pixmap(imd, dpmap);
|
|
}
|
|
else
|
|
{
|
|
if (!gc)
|
|
gc = XCreateGC(disp, win, 0, &gcv);
|
|
XSetClipMask(disp, gc, 0);
|
|
XSetFillStyle(disp, gc, FillSolid);
|
|
XSetForeground(disp, gc, dsk->bg.solid.pixel);
|
|
XFillRectangle(disp, win, gc, 0, 0, rw, rh);
|
|
}
|
|
XSync(disp, False);
|
|
}
|
|
if (gc)
|
|
XFreeGC(disp, gc);
|
|
Imlib_set_render_type(imd, rt);
|
|
|
|
EDBUG_RETURN_;
|
|
|
|
}
|
|
|
|
void
|
|
InitDesktopBgs()
|
|
{
|
|
int i;
|
|
Desk *d;
|
|
Atom at;
|
|
|
|
EDBUG(6, "InitDesktopBgs");
|
|
for (i = 0; i < ENLIGHTENMENT_CONF_NUM_DESKTOPS; i++)
|
|
{
|
|
d = &desks.desk[i];
|
|
d->bg = NULL;
|
|
deskorder[i] = i;
|
|
d->num = 0;
|
|
d->list = NULL;
|
|
d->tag = NULL;
|
|
d->x = 0;
|
|
d->y = 0;
|
|
d->current_area_x = 0;
|
|
d->current_area_y = 0;
|
|
if (i == 0)
|
|
{
|
|
d->win = root.win;
|
|
d->viewable = 0;
|
|
}
|
|
else
|
|
{
|
|
d->win = ECreateWindow(root.win, -root.w, -root.h, root.w, root.h, 0);
|
|
XSelectInput(disp, d->win,
|
|
SubstructureNotifyMask | ButtonPressMask |
|
|
ButtonReleaseMask | EnterWindowMask |
|
|
LeaveWindowMask | ButtonMotionMask |
|
|
PropertyChangeMask | SubstructureRedirectMask |
|
|
KeyPressMask | KeyReleaseMask | PointerMotionMask);
|
|
d->viewable = 0;
|
|
}
|
|
at = XInternAtom(disp, "ENLIGHTENMENT_DESKTOP", False);
|
|
XChangeProperty(disp, d->win, at, XA_CARDINAL, 32, PropModeReplace,
|
|
(unsigned char *)&i, 1);
|
|
/* I don't believe it.. this property causes xv and Xscreensaver to barf
|
|
* stupid bloody clients - I cant' believe peope write such shitty code
|
|
*/
|
|
/*
|
|
* at = XInternAtom(disp, "__SWM_VROOT", False);
|
|
* XChangeProperty(disp, d->win, at, XA_CARDINAL, 32, PropModeReplace,
|
|
* (unsigned char *)&i, 1);
|
|
*/
|
|
}
|
|
|
|
EDBUG_RETURN_;
|
|
|
|
}
|
|
|
|
void
|
|
InitDesktopControls()
|
|
{
|
|
int i;
|
|
ActionClass *ac, *ac2, *ac3;
|
|
ImageClass *ic, *ic2, *ic3, *ic4;
|
|
Button *b;
|
|
Action *a;
|
|
int x[3], y[3], w[3], h[3], m, n, o;
|
|
char s[512], *param;
|
|
|
|
EDBUG(6, "InitDesktopControls");
|
|
|
|
for (i = 0; i < ENLIGHTENMENT_CONF_NUM_DESKTOPS; i++)
|
|
{
|
|
Esnprintf(s, sizeof(s), "DRAGBAR_DESKTOP_%i", i);
|
|
ac = FindItem(s, 0, LIST_FINDBY_NAME, LIST_TYPE_ACLASS);
|
|
if (!ac)
|
|
{
|
|
ac = CreateAclass(s);
|
|
AddItem(ac, ac->name, 0, LIST_TYPE_ACLASS);
|
|
a = CreateAction(EVENT_MOUSE_DOWN, 0, 0, 0, 1, 0, NULL, NULL);
|
|
AddAction(ac, a);
|
|
param = Emalloc(3);
|
|
Esnprintf(param, 3, "%i", i);
|
|
AddToAction(a, ACTION_DESKTOP_DRAG, param);
|
|
a = CreateAction(EVENT_MOUSE_DOWN, 0, 0, 0, 3, 0, NULL, NULL);
|
|
AddAction(ac, a);
|
|
Esnprintf(s, sizeof(s), "deskmenu");
|
|
AddToAction(a, ACTION_SHOW_MENU, duplicate(s));
|
|
a = CreateAction(EVENT_MOUSE_DOWN, 0, 0, 0, 2, 0, NULL, NULL);
|
|
AddAction(ac, a);
|
|
Esnprintf(s, sizeof(s), "taskmenu");
|
|
AddToAction(a, ACTION_SHOW_MENU, duplicate(s));
|
|
if (i > 0)
|
|
{
|
|
ac->tooltipstring = duplicate("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");
|
|
}
|
|
else
|
|
{
|
|
ac->tooltipstring = duplicate("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");
|
|
}
|
|
}
|
|
Esnprintf(s, sizeof(s), "RAISEBUTTON_DESKTOP_%i", i);
|
|
ac2 = FindItem(s, 0, LIST_FINDBY_NAME, LIST_TYPE_ACLASS);
|
|
if (!ac2)
|
|
{
|
|
ac2 = CreateAclass(s);
|
|
AddItem(ac2, ac2->name, 0, LIST_TYPE_ACLASS);
|
|
a = CreateAction(EVENT_MOUSE_UP, 1, 0, 1, 0, 0, NULL, NULL);
|
|
AddAction(ac2, a);
|
|
param = Emalloc(3);
|
|
Esnprintf(param, 3, "%i", i);
|
|
AddToAction(a, ACTION_DESKTOP_RAISE, param);
|
|
ac2->tooltipstring = duplicate("Click here to raise this desktop\n"
|
|
"to the top.\n");
|
|
}
|
|
Esnprintf(s, sizeof(s), "LOWERBUTTON_DESKTOP_%i", i);
|
|
ac3 = FindItem(s, 0, LIST_FINDBY_NAME, LIST_TYPE_ACLASS);
|
|
if (!ac3)
|
|
{
|
|
ac3 = CreateAclass(s);
|
|
AddItem(ac3, ac3->name, 0, LIST_TYPE_ACLASS);
|
|
a = CreateAction(EVENT_MOUSE_UP, 1, 0, 1, 0, 0, NULL, NULL);
|
|
AddAction(ac3, a);
|
|
param = Emalloc(3);
|
|
Esnprintf(param, 3, "%i", i);
|
|
AddToAction(a, ACTION_DESKTOP_LOWER, param);
|
|
ac3->tooltipstring = duplicate("Click here to lower this desktop\n"
|
|
"to the bottom.\n");
|
|
}
|
|
b = NULL;
|
|
|
|
if (desks.dragdir < 2)
|
|
{
|
|
ic = FindItem("DESKTOP_DRAGBUTTON_VERT", 0, LIST_FINDBY_NAME,
|
|
LIST_TYPE_ICLASS);
|
|
ic2 = FindItem("DESKTOP_RAISEBUTTON_VERT", 0, LIST_FINDBY_NAME,
|
|
LIST_TYPE_ICLASS);
|
|
ic3 = FindItem("DESKTOP_LOWERBUTTON_VERT", 0, LIST_FINDBY_NAME,
|
|
LIST_TYPE_ICLASS);
|
|
ic4 = FindItem("DESKTOP_DESKRAY_VERT", 0, LIST_FINDBY_NAME,
|
|
LIST_TYPE_ICLASS);
|
|
}
|
|
else
|
|
{
|
|
ic = FindItem("DESKTOP_DRAGBUTTON_HORIZ", 0, LIST_FINDBY_NAME,
|
|
LIST_TYPE_ICLASS);
|
|
ic2 = FindItem("DESKTOP_RAISEBUTTON_HORIZ", 0, LIST_FINDBY_NAME,
|
|
LIST_TYPE_ICLASS);
|
|
ic3 = FindItem("DESKTOP_LOWERBUTTON_HORIZ", 0, LIST_FINDBY_NAME,
|
|
LIST_TYPE_ICLASS);
|
|
ic4 = FindItem("DESKTOP_DESKRAY_HORIZ", 0, LIST_FINDBY_NAME,
|
|
LIST_TYPE_ICLASS);
|
|
}
|
|
|
|
switch (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 (desks.dragdir)
|
|
{
|
|
case 0:
|
|
w[0] = w[1] = w[2] = h[0] = h[1] = desks.dragbar_width;
|
|
if (desks.dragbar_length == 0)
|
|
h[2] = root.h - (desks.dragbar_width * 2);
|
|
else
|
|
h[2] = 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] = desks.dragbar_width;
|
|
if (desks.dragbar_length == 0)
|
|
h[2] = root.h - (desks.dragbar_width * 2);
|
|
else
|
|
h[2] = desks.dragbar_length;
|
|
x[0] = x[1] = x[2] = root.w - 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] = desks.dragbar_width;
|
|
if (desks.dragbar_length == 0)
|
|
w[2] = root.w - (desks.dragbar_width * 2);
|
|
else
|
|
w[2] = 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] = desks.dragbar_width;
|
|
if (desks.dragbar_length == 0)
|
|
w[2] = root.w - (desks.dragbar_width * 2);
|
|
else
|
|
w[2] = desks.dragbar_length;
|
|
y[0] = y[1] = y[2] = root.h - desks.dragbar_width;
|
|
x[m] = 0;
|
|
x[n] = x[m] + w[m];
|
|
x[o] = x[n] + w[n];
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (desks.dragbar_width > 0)
|
|
{
|
|
b = CreateButton("_DESKTOP_DRAG_CONTROL", 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, i, 0);
|
|
AddItem(b, b->name, 1, LIST_TYPE_BUTTON);
|
|
b = CreateButton("_DESKTOP_DRAG_CONTROL", 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, i, 0);
|
|
AddItem(b, b->name, 1, LIST_TYPE_BUTTON);
|
|
b = CreateButton("_DESKTOP_DRAG_CONTROL", ic, ac, NULL, NULL, -1,
|
|
FLAG_FIXED, 1, 99999, 1, 99999, 0, 0, x[2],
|
|
0, y[2], 0, 0, w[2], 0, h[2], 0, i, 0);
|
|
AddItem(b, b->name, 1, LIST_TYPE_BUTTON);
|
|
}
|
|
if (i > 0)
|
|
{
|
|
if (desks.dragdir == 0)
|
|
{
|
|
b = CreateButton("_DESKTOP_DESKRAY_DRAG_CONTROL", ic4, ac,
|
|
NULL, NULL, 1, FLAG_FIXED_VERT, 1, 99999, 1,
|
|
99999, 0, 0, desks.desk[i].x, 0,
|
|
desks.desk[i].y, 0, 0, 0, 0, 0, 1, 0, 1);
|
|
}
|
|
else if (desks.dragdir == 1)
|
|
{
|
|
b = CreateButton("_DESKTOP_DESKRAY_DRAG_CONTROL", ic4, ac,
|
|
NULL, NULL, 1, FLAG_FIXED_VERT, 1,
|
|
99999, 1, 99999, 0, 0,
|
|
desks.desk[i].x + root.w
|
|
- desks.dragbar_width,
|
|
0, desks.desk[i].y, 0, 0, 0, 0, 0, 1, 0, 1);
|
|
}
|
|
else if (desks.dragdir == 2)
|
|
{
|
|
b = CreateButton("_DESKTOP_DESKRAY_DRAG_CONTROL", ic4, ac,
|
|
NULL, NULL, 1, FLAG_FIXED_HORIZ, 1, 99999, 1,
|
|
99999, 0, 0, desks.desk[i].x, 0,
|
|
desks.desk[i].y, 0, 0, 0, 0, 0, 1, 0, 1);
|
|
}
|
|
else
|
|
{
|
|
b = CreateButton("_DESKTOP_DESKRAY_DRAG_CONTROL", ic4, ac,
|
|
NULL, NULL, 1, FLAG_FIXED_HORIZ, 1, 99999, 1,
|
|
99999, 0, 0, desks.desk[i].x, 0,
|
|
desks.desk[i].y + root.h - desks.dragbar_width,
|
|
0, 0, 0, 0, 0, 1, 0, 1);
|
|
}
|
|
AddItem(b, b->name, 2, LIST_TYPE_BUTTON);
|
|
desks.desk[i].tag = b;
|
|
}
|
|
else
|
|
desks.desk[i].tag = NULL;
|
|
}
|
|
EDBUG_RETURN_;
|
|
}
|
|
|
|
void
|
|
SetDesktopBg(int desk, Background * bg)
|
|
{
|
|
EDBUG(5, "SetDesktopBg");
|
|
|
|
if (desk < 0)
|
|
EDBUG_RETURN_;
|
|
if (desk >= ENLIGHTENMENT_CONF_NUM_DESKTOPS)
|
|
EDBUG_RETURN_;
|
|
|
|
if (desks.desk[desk].bg)
|
|
{
|
|
if (desks.desk[desk].bg != bg)
|
|
{
|
|
desks.desk[desk].bg->ref_count--;
|
|
if (desks.desk[desk].bg->ref_count < 1)
|
|
{
|
|
desks.desk[desk].bg->last_viewed = 0;
|
|
DesktopAccounting();
|
|
}
|
|
if (bg)
|
|
bg->ref_count++;
|
|
}
|
|
}
|
|
desks.desk[desk].bg = bg;
|
|
if (desks.desk[desk].viewable)
|
|
RefreshDesktop(desk);
|
|
if (desk == desks.current)
|
|
{
|
|
RedrawPagersForDesktop(desk, 2);
|
|
ForceUpdatePagersForDesktop(desk);
|
|
}
|
|
else
|
|
RedrawPagersForDesktop(desk, 1);
|
|
EDBUG_RETURN_;
|
|
}
|
|
|
|
void
|
|
ConformEwinToDesktop(EWin * ewin)
|
|
{
|
|
int xo, yo;
|
|
|
|
EDBUG(3, "ConformEwinToDesktop");
|
|
|
|
if ((ewin->iconified) &&
|
|
(ewin->parent != desks.desk[ewin->desktop].win))
|
|
{
|
|
ewin->parent = desks.desk[ewin->desktop].win;
|
|
DesktopAddEwinToTop(ewin);
|
|
EReparentWindow(disp, ewin->win, desks.desk[ewin->desktop].win,
|
|
ewin->x, ewin->y);
|
|
ICCCM_Configure(ewin);
|
|
StackDesktops();
|
|
GNOME_SetEwinDesk(ewin);
|
|
EDBUG_RETURN_;
|
|
}
|
|
if (ewin->floating)
|
|
{
|
|
DesktopRemoveEwin(ewin);
|
|
xo = desks.desk[ewin->desktop].x;
|
|
yo = desks.desk[ewin->desktop].y;
|
|
if ((ewin->parent != root.win) && (ewin->floating == 2))
|
|
{
|
|
ewin->parent = root.win;
|
|
EReparentWindow(disp, ewin->win, root.win, ewin->x, ewin->y);
|
|
ewin->desktop = 0;
|
|
}
|
|
XRaiseWindow(disp, ewin->win);
|
|
ShowEdgeWindows();
|
|
ICCCM_Configure(ewin);
|
|
GNOME_SetEwinDesk(ewin);
|
|
EDBUG_RETURN_;
|
|
}
|
|
if (ewin->parent != desks.desk[ewin->desktop].win)
|
|
{
|
|
ewin->parent = desks.desk[ewin->desktop].win;
|
|
DesktopAddEwinToTop(ewin);
|
|
EReparentWindow(disp, ewin->win, desks.desk[ewin->desktop].win,
|
|
ewin->x, ewin->y);
|
|
RaiseEwin(ewin);
|
|
/* ShowEwin(ewin); */
|
|
ICCCM_Configure(ewin);
|
|
GNOME_SetEwinDesk(ewin);
|
|
StackDesktops();
|
|
SetEwinToCurrentArea(ewin);
|
|
}
|
|
EDBUG_RETURN_;
|
|
|
|
}
|
|
|
|
int
|
|
DesktopAt(int x, int y)
|
|
{
|
|
int i;
|
|
|
|
EDBUG(3, "DesktopAt");
|
|
|
|
for (i = 0; i < ENLIGHTENMENT_CONF_NUM_DESKTOPS; i++)
|
|
{
|
|
if ((x >= desks.desk[deskorder[i]].x) &&
|
|
(x < (desks.desk[deskorder[i]].x + root.w)) &&
|
|
(y >= desks.desk[deskorder[i]].y) &&
|
|
(y < (desks.desk[deskorder[i]].y + root.h)))
|
|
EDBUG_RETURN(deskorder[i]);
|
|
}
|
|
|
|
EDBUG_RETURN(0);
|
|
}
|
|
|
|
void
|
|
MoveStickyWindowsToCurrentDesk(void)
|
|
{
|
|
EWin **lst, *ewin, *last_ewin;
|
|
int i, num;
|
|
|
|
lst = (EWin **) ListItemType(&num, LIST_TYPE_EWIN);
|
|
if ((lst) && (num > 0))
|
|
{
|
|
last_ewin = NULL;
|
|
for (i = 0; i < num; i++)
|
|
{
|
|
ewin = (EWin *) lst[i];
|
|
if (ewin->sticky)
|
|
{
|
|
DesktopRemoveEwin(ewin);
|
|
ewin->desktop = DESKTOPS_WRAP_NUM(desks.current);
|
|
ewin->parent = desks.desk[ewin->desktop].win;
|
|
EReparentWindow(disp, ewin->win, desks.desk[ewin->desktop].win,
|
|
root.w, root.h);
|
|
XLowerWindow(disp, ewin->win);
|
|
EMoveWindow(disp, ewin->win, ewin->x, ewin->y);
|
|
DesktopAddEwinToTop(ewin);
|
|
last_ewin = ewin;
|
|
}
|
|
}
|
|
if (last_ewin)
|
|
RestackEwin(last_ewin);
|
|
Efree(lst);
|
|
}
|
|
}
|
|
|
|
void
|
|
GotoDesktop(int num)
|
|
{
|
|
int x, y, pdesk;
|
|
|
|
EDBUG(2, "GotoDesktop");
|
|
|
|
if (num < 0)
|
|
EDBUG_RETURN_;
|
|
if (num >= mode.numdesktops)
|
|
EDBUG_RETURN_;
|
|
if (num == desks.current)
|
|
EDBUG_RETURN_;
|
|
pdesk = desks.current;
|
|
|
|
WarpFocusFinish();
|
|
if (mode.slideout)
|
|
HideSlideout(mode.slideout, mode.context_win);
|
|
|
|
if ((mode.mode == MODE_RESIZE) ||
|
|
(mode.mode == MODE_RESIZE_H) ||
|
|
(mode.mode == MODE_RESIZE_V))
|
|
{
|
|
doResizeEnd(NULL);
|
|
}
|
|
else if ((mode.mode == MODE_MOVE) && (mode.ewin))
|
|
{
|
|
if ((mode.movemode > 0) && (!mode.moveresize_pending_ewin))
|
|
{
|
|
if (mode.ewin)
|
|
{
|
|
x = mode.ewin->x;
|
|
y = mode.ewin->y;
|
|
mode.ewin->x = -99999;
|
|
mode.ewin->y = -99999;
|
|
mode.ewin->reqx = -99999;
|
|
mode.ewin->reqy = -99999;
|
|
DrawEwinShape(mode.ewin, mode.movemode,
|
|
x, y,
|
|
mode.ewin->client.w, mode.ewin->client.h,
|
|
3);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
FloatEwinAt(mode.ewin, mode.ewin->x +
|
|
desks.desk[mode.ewin->desktop].x,
|
|
mode.ewin->y + desks.desk[mode.ewin->desktop].y);
|
|
}
|
|
}
|
|
FocusToEWin(NULL);
|
|
BeginNewDeskFocus();
|
|
CloneDesktop(desks.current);
|
|
ICCCM_Cmap(NULL);
|
|
desks.current = num;
|
|
MoveStickyWindowsToCurrentDesk();
|
|
|
|
GNOME_SetCurrentDesk();
|
|
|
|
if (mode.kde_support)
|
|
KDE_SetRootArea();
|
|
|
|
if (num > 0)
|
|
{
|
|
if (desks.slidein)
|
|
{
|
|
if (!desks.desk[num].viewable)
|
|
{
|
|
switch (desks.dragdir)
|
|
{
|
|
case 0:
|
|
MoveDesktop(num, root.w, 0);
|
|
RaiseDesktop(num);
|
|
SlideWindowTo(desks.desk[num].win, root.w,
|
|
0, 0, 0, desks.slidespeed);
|
|
break;
|
|
case 1:
|
|
MoveDesktop(num, -root.w, 0);
|
|
RaiseDesktop(num);
|
|
SlideWindowTo(desks.desk[num].win, -root.w,
|
|
0, 0, 0, desks.slidespeed);
|
|
break;
|
|
case 2:
|
|
MoveDesktop(num, 0, root.h);
|
|
RaiseDesktop(num);
|
|
SlideWindowTo(desks.desk[num].win, 0,
|
|
root.h, 0, 0, desks.slidespeed);
|
|
break;
|
|
case 3:
|
|
MoveDesktop(num, 0, -root.h);
|
|
RaiseDesktop(num);
|
|
SlideWindowTo(desks.desk[num].win, 0,
|
|
-root.h, 0, 0, desks.slidespeed);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
GetWinXY(desks.desk[num].win, &x, &y);
|
|
SlideWindowTo(desks.desk[num].win, desks.desk[num].x,
|
|
desks.desk[num].y, 0, 0, desks.slidespeed);
|
|
RaiseDesktop(num);
|
|
}
|
|
StackDesktops();
|
|
}
|
|
else
|
|
{
|
|
RaiseDesktop(num);
|
|
StackDesktops();
|
|
}
|
|
MoveDesktop(num, 0, 0);
|
|
}
|
|
else
|
|
{
|
|
RaiseDesktop(num);
|
|
}
|
|
|
|
mode.moveresize_pending_ewin = NULL;
|
|
|
|
if ((mode.mode == MODE_MOVE) && (mode.movemode > 0) && (mode.ewin))
|
|
{
|
|
if (mode.ewin)
|
|
{
|
|
XLowerWindow(disp, mode.ewin->win);
|
|
x = mode.ewin->x;
|
|
y = mode.ewin->y;
|
|
mode.ewin->x = -99999;
|
|
mode.ewin->y = -99999;
|
|
mode.ewin->reqx = -99999;
|
|
mode.ewin->reqy = -99999;
|
|
if (mode.movemode == 5)
|
|
{
|
|
DrawEwinShape(mode.ewin, mode.movemode, x, y,
|
|
mode.ewin->client.w, mode.ewin->client.h,
|
|
4);
|
|
}
|
|
else
|
|
{
|
|
DrawEwinShape(mode.ewin, mode.movemode, x, y,
|
|
mode.ewin->client.w, mode.ewin->client.h,
|
|
0);
|
|
}
|
|
}
|
|
}
|
|
NewDeskFocus();
|
|
FX_DeskChange();
|
|
RemoveClones();
|
|
RedrawPagersForDesktop(num, 3);
|
|
ForceUpdatePagersForDesktop(num);
|
|
UpdatePagerSel();
|
|
HandleDrawQueue();
|
|
EDBUG_RETURN_;
|
|
}
|
|
|
|
void
|
|
MoveDesktop(int num, int x, int y)
|
|
{
|
|
int i;
|
|
EWin **lst;
|
|
int n, v, dx, dy;
|
|
|
|
EDBUG(3, "MoveDesktop");
|
|
if (num < 0)
|
|
EDBUG_RETURN_;
|
|
if (num >= mode.numdesktops)
|
|
EDBUG_RETURN_;
|
|
if (num == 0)
|
|
EDBUG_RETURN_;
|
|
dx = x - desks.desk[num].x;
|
|
dy = y - desks.desk[num].y;
|
|
if ((x == 0) && (y == 0))
|
|
{
|
|
n = -1;
|
|
i = 0;
|
|
while ((n < 0) && (i < ENLIGHTENMENT_CONF_NUM_DESKTOPS))
|
|
{
|
|
if (deskorder[i] == num)
|
|
n = i;
|
|
i++;
|
|
}
|
|
if (n >= 0)
|
|
{
|
|
for (i = n + 1; i < ENLIGHTENMENT_CONF_NUM_DESKTOPS; i++)
|
|
{
|
|
if ((desks.desk[deskorder[i]].viewable)
|
|
&& (desks.desk[deskorder[i]].bg))
|
|
desks.desk[deskorder[i]].bg->last_viewed = time(NULL);
|
|
desks.desk[deskorder[i]].viewable = 0;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
n = -1;
|
|
i = 0;
|
|
|
|
while ((n < 0) && (i < ENLIGHTENMENT_CONF_NUM_DESKTOPS))
|
|
{
|
|
if (deskorder[i] == num)
|
|
n = i;
|
|
i++;
|
|
}
|
|
|
|
if (n >= 0)
|
|
{
|
|
if (desks.desk[deskorder[n]].viewable)
|
|
{
|
|
v = 1;
|
|
}
|
|
else
|
|
{
|
|
v = 0;
|
|
}
|
|
|
|
for (i = n + 1; i < ENLIGHTENMENT_CONF_NUM_DESKTOPS; i++)
|
|
{
|
|
|
|
if ((!desks.desk[deskorder[i]].viewable) && (v))
|
|
{
|
|
desks.desk[deskorder[i]].viewable = v;
|
|
RefreshDesktop(deskorder[i]);
|
|
}
|
|
else
|
|
{
|
|
if ((!v) && (desks.desk[deskorder[i]].viewable)
|
|
&& (desks.desk[deskorder[i]].bg))
|
|
{
|
|
desks.desk[deskorder[i]].bg->last_viewed = time(NULL);
|
|
}
|
|
desks.desk[deskorder[i]].viewable = v;
|
|
}
|
|
|
|
if ((desks.desk[deskorder[i]].x == 0) &&
|
|
(desks.desk[deskorder[i]].y == 0))
|
|
{
|
|
v = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
EMoveWindow(disp, desks.desk[num].win, x, y);
|
|
|
|
if (desks.desk[num].tag)
|
|
{
|
|
MovebuttonToCoord(desks.desk[num].tag,
|
|
desks.desk[num].tag->x + dx,
|
|
desks.desk[num].tag->y + dy);
|
|
}
|
|
desks.desk[num].x = x;
|
|
desks.desk[num].y = y;
|
|
|
|
lst = (EWin **) ListItemType(&n, LIST_TYPE_EWIN);
|
|
if (lst)
|
|
{
|
|
for (i = 0; i < n; i++)
|
|
if (lst[i]->desktop == num)
|
|
ICCCM_Configure(lst[i]);
|
|
Efree(lst);
|
|
}
|
|
EDBUG_RETURN_;
|
|
|
|
}
|
|
|
|
void
|
|
RaiseDesktop(int num)
|
|
{
|
|
int i;
|
|
|
|
EDBUG(3, "RaiseDesktop");
|
|
|
|
if ((num < 0) || (num >= mode.numdesktops))
|
|
EDBUG_RETURN_;
|
|
|
|
BeginNewDeskFocus();
|
|
CloneDesktop(deskorder[0]);
|
|
desks.desk[num].viewable = 1;
|
|
RefreshDesktop(num);
|
|
MoveToDeskTop(num);
|
|
|
|
if (num == 0)
|
|
{
|
|
for (i = ENLIGHTENMENT_CONF_NUM_DESKTOPS - 1; i > 0; i--)
|
|
{
|
|
HideDesktop(deskorder[i]);
|
|
}
|
|
}
|
|
StackDesktops();
|
|
desks.current = num;
|
|
MoveStickyWindowsToCurrentDesk();
|
|
NewDeskFocus();
|
|
FX_DeskChange();
|
|
RemoveClones();
|
|
RedrawPagersForDesktop(num, 3);
|
|
ForceUpdatePagersForDesktop(num);
|
|
UpdatePagerSel();
|
|
HandleDrawQueue();
|
|
GNOME_SetCurrentDesk();
|
|
EMapWindow(disp, desks.desk[num].win);
|
|
XSync(disp, False);
|
|
|
|
EDBUG_RETURN_;
|
|
|
|
}
|
|
|
|
void
|
|
LowerDesktop(int num)
|
|
{
|
|
EDBUG(3, "LowerDesktop");
|
|
|
|
if ((num < 0) || (num >= mode.numdesktops))
|
|
EDBUG_RETURN_;
|
|
|
|
BeginNewDeskFocus();
|
|
CloneDesktop(num);
|
|
MoveToDeskBottom(num);
|
|
UncoverDesktop(deskorder[0]);
|
|
HideDesktop(num);
|
|
StackDesktops();
|
|
desks.current = deskorder[0];
|
|
MoveStickyWindowsToCurrentDesk();
|
|
NewDeskFocus();
|
|
FX_DeskChange();
|
|
RemoveClones();
|
|
RedrawPagersForDesktop(deskorder[0], 3);
|
|
ForceUpdatePagersForDesktop(deskorder[0]);
|
|
UpdatePagerSel();
|
|
HandleDrawQueue();
|
|
GNOME_SetCurrentDesk();
|
|
XSync(disp, False);
|
|
|
|
EDBUG_RETURN_;
|
|
|
|
}
|
|
|
|
void
|
|
HideDesktop(int num)
|
|
{
|
|
EDBUG(3, "HideDesktop");
|
|
|
|
if ((num < 0) || (num >= mode.numdesktops))
|
|
EDBUG_RETURN_;
|
|
if (num == 0)
|
|
EDBUG_RETURN_;
|
|
|
|
if ((desks.desk[num].viewable) && (desks.desk[num].bg))
|
|
desks.desk[num].bg->last_viewed = time(NULL);
|
|
desks.desk[num].viewable = 0;
|
|
EMoveWindow(disp, desks.desk[num].win, root.w, 0);
|
|
|
|
EDBUG_RETURN_;
|
|
|
|
}
|
|
|
|
void
|
|
ShowDesktop(int num)
|
|
{
|
|
int i;
|
|
|
|
EDBUG(3, "ShowDesktop");
|
|
|
|
if (num < 0)
|
|
EDBUG_RETURN_;
|
|
if (num >= mode.numdesktops)
|
|
EDBUG_RETURN_;
|
|
|
|
desks.desk[num].viewable = 1;
|
|
RefreshDesktop(num);
|
|
MoveToDeskTop(num);
|
|
|
|
if (num == 0)
|
|
{
|
|
for (i = ENLIGHTENMENT_CONF_NUM_DESKTOPS - 1; i > 0; i--)
|
|
HideDesktop(deskorder[i]);
|
|
}
|
|
else
|
|
{
|
|
StackDesktops();
|
|
EMapWindow(disp, desks.desk[num].win);
|
|
}
|
|
|
|
EDBUG_RETURN_;
|
|
}
|
|
|
|
void
|
|
StackDesktops()
|
|
{
|
|
Window *wl, *wl2;
|
|
int i, num, tot, bnum, n;
|
|
EWin **lst;
|
|
Button **blst;
|
|
|
|
EDBUG(2, "StackDesktops");
|
|
tot = 0;
|
|
wl = NULL;
|
|
|
|
wl2 = ListProgressWindows(&n);
|
|
if (wl2)
|
|
{
|
|
tot += n;
|
|
wl = Erealloc(wl, tot * sizeof(Window));
|
|
for (i = 0; i < n; i++)
|
|
wl[tot - n + i] = wl2[i];
|
|
Efree(wl2);
|
|
}
|
|
if (init_win_ext)
|
|
{
|
|
tot += 1;
|
|
wl = Erealloc(wl, tot * sizeof(Window));
|
|
wl[tot - 1] = init_win_ext;
|
|
}
|
|
if (init_win1)
|
|
{
|
|
tot += 2;
|
|
wl = Erealloc(wl, tot * sizeof(Window));
|
|
wl[tot - 2] = init_win1;
|
|
wl[tot - 1] = init_win2;
|
|
}
|
|
lst = (EWin **) ListItemType(&num, LIST_TYPE_EWIN);
|
|
blst = (Button **) ListItemType(&bnum, LIST_TYPE_BUTTON);
|
|
|
|
if (blst)
|
|
{
|
|
for (i = 0; i < bnum; i++)
|
|
{
|
|
if (blst[i]->sticky)
|
|
{
|
|
tot++;
|
|
wl = Erealloc(wl, tot * sizeof(Window));
|
|
wl[tot - 1] = blst[i]->win;
|
|
}
|
|
}
|
|
}
|
|
if (lst)
|
|
{
|
|
for (i = 0; i < num; i++)
|
|
{
|
|
if ( /* ** (lst[i]->sticky) || */ (lst[i]->floating))
|
|
{
|
|
tot++;
|
|
wl = Erealloc(wl, tot * sizeof(Window));
|
|
wl[tot - 1] = lst[i]->win;
|
|
}
|
|
}
|
|
}
|
|
for (i = 0; i < ENLIGHTENMENT_CONF_NUM_DESKTOPS; i++)
|
|
{
|
|
if (deskorder[i] == 0)
|
|
i = ENLIGHTENMENT_CONF_NUM_DESKTOPS;
|
|
else
|
|
{
|
|
tot++;
|
|
wl = Erealloc(wl, tot * sizeof(Window));
|
|
wl[tot - 1] = desks.desk[deskorder[i]].win;
|
|
}
|
|
}
|
|
if (blst)
|
|
{
|
|
for (i = 0; i < bnum; i++)
|
|
{
|
|
if ((blst[i]->desktop == 0) && (blst[i]->ontop == 1) &&
|
|
(!blst[i]->sticky))
|
|
{
|
|
tot++;
|
|
wl = Erealloc(wl, tot * sizeof(Window));
|
|
wl[tot - 1] = blst[i]->win;
|
|
}
|
|
}
|
|
}
|
|
for (i = 0; i < desks.desk[0].num; i++)
|
|
{
|
|
tot++;
|
|
wl = Erealloc(wl, tot * sizeof(Window));
|
|
wl[tot - 1] = desks.desk[0].list[i]->win;
|
|
}
|
|
if (blst)
|
|
{
|
|
for (i = 0; i < bnum; i++)
|
|
{
|
|
if ((blst[i]->desktop == 0) && (blst[i]->ontop == -1) &&
|
|
(!blst[i]->sticky))
|
|
{
|
|
tot++;
|
|
wl = Erealloc(wl, tot * sizeof(Window));
|
|
wl[tot - 1] = blst[i]->win;
|
|
}
|
|
}
|
|
}
|
|
tot++;
|
|
wl = Erealloc(wl, tot * sizeof(Window));
|
|
wl[tot - 1] = desks.desk[0].win;
|
|
if (wl)
|
|
{
|
|
XRestackWindows(disp, wl, tot);
|
|
Efree(wl);
|
|
}
|
|
if (lst)
|
|
Efree(lst);
|
|
if (blst)
|
|
Efree(blst);
|
|
ShowEdgeWindows();
|
|
EDBUG_RETURN_;
|
|
}
|
|
|
|
void
|
|
UncoverDesktop(int num)
|
|
{
|
|
EDBUG(3, "UncoverDesktop");
|
|
if (num < 0)
|
|
EDBUG_RETURN_;
|
|
if (num >= mode.numdesktops)
|
|
EDBUG_RETURN_;
|
|
desks.desk[num].viewable = 1;
|
|
RefreshDesktop(num);
|
|
if (num != 0)
|
|
EMapWindow(disp, desks.desk[num].win);
|
|
EDBUG_RETURN_;
|
|
}
|
|
|
|
void
|
|
MoveEwinToDesktop(EWin * ewin, int num)
|
|
{
|
|
int pdesk;
|
|
|
|
EDBUG(3, "MoveEwinToDesktop");
|
|
/* ** ewin->sticky = 0; */
|
|
ewin->floating = 0;
|
|
DesktopRemoveEwin(ewin);
|
|
pdesk = ewin->desktop;
|
|
ewin->desktop = DESKTOPS_WRAP_NUM(num);
|
|
DesktopAddEwinToTop(ewin);
|
|
ConformEwinToDesktop(ewin);
|
|
if (ewin->has_transients)
|
|
{
|
|
EWin **lst;
|
|
int i, nn;
|
|
|
|
lst = ListTransientsFor(ewin->client.win, &nn);
|
|
if (lst)
|
|
{
|
|
for (i = 0; i < nn; i++)
|
|
{
|
|
MoveEwinToDesktop(lst[i], num);
|
|
}
|
|
Efree(lst);
|
|
}
|
|
}
|
|
ForceUpdatePagersForDesktop(pdesk);
|
|
ForceUpdatePagersForDesktop(ewin->desktop);
|
|
if (mode.kde_support)
|
|
KDE_UpdateClient(ewin);
|
|
EDBUG_RETURN_;
|
|
}
|
|
|
|
void
|
|
DesktopRemoveEwin(EWin * ewin)
|
|
{
|
|
int i, j;
|
|
|
|
EDBUG(5, "DesktopRemoveEwin");
|
|
if ((ewin->desktop < 0) || (ewin->desktop > ENLIGHTENMENT_CONF_NUM_DESKTOPS - 1))
|
|
EDBUG_RETURN_;
|
|
for (i = 0; i < desks.desk[ewin->desktop].num; i++)
|
|
{
|
|
if (desks.desk[ewin->desktop].list[i] == ewin)
|
|
{
|
|
for (j = i; j < desks.desk[ewin->desktop].num - 1; j++)
|
|
desks.desk[ewin->desktop].list[j] =
|
|
desks.desk[ewin->desktop].list[j + 1];
|
|
desks.desk[ewin->desktop].num--;
|
|
if (desks.desk[ewin->desktop].num <= 0)
|
|
{
|
|
desks.desk[ewin->desktop].num = 0;
|
|
if (desks.desk[ewin->desktop].list)
|
|
Efree(desks.desk[ewin->desktop].list);
|
|
desks.desk[ewin->desktop].list = NULL;
|
|
}
|
|
else
|
|
{
|
|
desks.desk[ewin->desktop].list =
|
|
Erealloc(desks.desk[ewin->desktop].list,
|
|
desks.desk[ewin->desktop].num * sizeof(EWin *));
|
|
}
|
|
EDBUG_RETURN_;
|
|
}
|
|
}
|
|
EDBUG_RETURN_;
|
|
}
|
|
|
|
void
|
|
DesktopAddEwinToTop(EWin * ewin)
|
|
{
|
|
int i, j;
|
|
|
|
EDBUG(5, "DesktopAddEwinToTop");
|
|
if ((ewin->desktop < 0) ||
|
|
(ewin->desktop > ENLIGHTENMENT_CONF_NUM_DESKTOPS - 1))
|
|
EDBUG_RETURN_;
|
|
|
|
DesktopRemoveEwin(ewin);
|
|
desks.desk[ewin->desktop].num++;
|
|
if (desks.desk[ewin->desktop].list)
|
|
desks.desk[ewin->desktop].list =
|
|
Erealloc(desks.desk[ewin->desktop].list,
|
|
desks.desk[ewin->desktop].num * sizeof(EWin *));
|
|
else
|
|
desks.desk[ewin->desktop].list = Emalloc(sizeof(EWin *));
|
|
if (desks.desk[ewin->desktop].num == 1)
|
|
{
|
|
desks.desk[ewin->desktop].list[0] = ewin;
|
|
ForceUpdatePagersForDesktop(ewin->desktop);
|
|
EDBUG_RETURN_;
|
|
}
|
|
for (i = 0; i < desks.desk[ewin->desktop].num - 1; i++)
|
|
{
|
|
if (desks.desk[ewin->desktop].list[i]->layer <= ewin->layer)
|
|
{
|
|
for (j = desks.desk[ewin->desktop].num - 1; j > i; j--)
|
|
desks.desk[ewin->desktop].list[j] =
|
|
desks.desk[ewin->desktop].list[j - 1];
|
|
desks.desk[ewin->desktop].list[i] = ewin;
|
|
ForceUpdatePagersForDesktop(ewin->desktop);
|
|
EDBUG_RETURN_;
|
|
}
|
|
}
|
|
desks.desk[ewin->desktop].list[desks.desk[ewin->desktop].num - 1] = ewin;
|
|
ForceUpdatePagersForDesktop(ewin->desktop);
|
|
EDBUG_RETURN_;
|
|
}
|
|
|
|
void
|
|
DesktopAddEwinToBottom(EWin * ewin)
|
|
{
|
|
int i, j;
|
|
|
|
EDBUG(5, "DesktopAddEwinToBottom");
|
|
if ((ewin->desktop < 0) ||
|
|
(ewin->desktop > ENLIGHTENMENT_CONF_NUM_DESKTOPS - 1))
|
|
EDBUG_RETURN_;
|
|
|
|
DesktopRemoveEwin(ewin);
|
|
desks.desk[ewin->desktop].num++;
|
|
if (desks.desk[ewin->desktop].list)
|
|
desks.desk[ewin->desktop].list =
|
|
Erealloc(desks.desk[ewin->desktop].list,
|
|
desks.desk[ewin->desktop].num * sizeof(EWin *));
|
|
else
|
|
desks.desk[ewin->desktop].list = Emalloc(sizeof(EWin *));
|
|
if (desks.desk[ewin->desktop].num == 1)
|
|
{
|
|
desks.desk[ewin->desktop].list[0] = ewin;
|
|
ForceUpdatePagersForDesktop(ewin->desktop);
|
|
EDBUG_RETURN_;
|
|
}
|
|
for (i = 0; i < desks.desk[ewin->desktop].num - 1; i++)
|
|
{
|
|
if (desks.desk[ewin->desktop].list[i]->layer < ewin->layer)
|
|
{
|
|
for (j = desks.desk[ewin->desktop].num - 1; j > i; j--)
|
|
desks.desk[ewin->desktop].list[j] =
|
|
desks.desk[ewin->desktop].list[j - 1];
|
|
desks.desk[ewin->desktop].list[i] = ewin;
|
|
ForceUpdatePagersForDesktop(ewin->desktop);
|
|
EDBUG_RETURN_;
|
|
}
|
|
}
|
|
desks.desk[ewin->desktop].list[desks.desk[ewin->desktop].num - 1] = ewin;
|
|
ForceUpdatePagersForDesktop(ewin->desktop);
|
|
EDBUG_RETURN_;
|
|
}
|
|
|
|
void
|
|
MoveEwinToDesktopAt(EWin * ewin, int num, int x, int y)
|
|
{
|
|
int dx, dy, pdesk;
|
|
|
|
EDBUG(3, "MoveEwinToDesktopAt");
|
|
/* ** ewin->sticky = 0; */
|
|
pdesk = ewin->desktop;
|
|
ewin->floating = 0;
|
|
DesktopRemoveEwin(ewin);
|
|
ewin->desktop = DESKTOPS_WRAP_NUM(num);
|
|
DesktopAddEwinToTop(ewin);
|
|
dx = x - ewin->x;
|
|
dy = y - ewin->y;
|
|
ewin->x = x;
|
|
ewin->y = y;
|
|
ConformEwinToDesktop(ewin);
|
|
if (ewin->has_transients)
|
|
{
|
|
EWin **lst;
|
|
int i, nn;
|
|
|
|
lst = ListTransientsFor(ewin->client.win, &nn);
|
|
if (lst)
|
|
{
|
|
for (i = 0; i < nn; i++)
|
|
{
|
|
MoveEwinToDesktopAt(lst[i], num, lst[i]->x + dx, lst[i]->y + dy);
|
|
}
|
|
Efree(lst);
|
|
}
|
|
}
|
|
ForceUpdatePagersForDesktop(pdesk);
|
|
ForceUpdatePagersForDesktop(ewin->desktop);
|
|
EDBUG_RETURN_;
|
|
}
|
|
|
|
void
|
|
FloatEwinAboveDesktops(EWin * ewin)
|
|
{
|
|
int xo, yo;
|
|
|
|
EDBUG(2, "FloatEwinAboveDesktops");
|
|
xo = desks.desk[ewin->desktop].x;
|
|
yo = desks.desk[ewin->desktop].y;
|
|
ewin->desktop = 0;
|
|
ewin->floating = 1;
|
|
ConformEwinToDesktop(ewin);
|
|
if (ewin->has_transients)
|
|
{
|
|
EWin **lst;
|
|
int i, num;
|
|
|
|
lst = ListTransientsFor(ewin->client.win, &num);
|
|
if (lst)
|
|
{
|
|
for (i = 0; i < num; i++)
|
|
FloatEwinAboveDesktops(lst[i]);
|
|
Efree(lst);
|
|
}
|
|
}
|
|
EDBUG_RETURN_;
|
|
}
|
|
|
|
void
|
|
DesktopAccounting()
|
|
{
|
|
time_t now;
|
|
int i, j, num;
|
|
Background **lst;
|
|
ImlibData *imd = 0;
|
|
|
|
EDBUG(3, "DesktopAccounting");
|
|
now = time(NULL);
|
|
for (i = 0; i < ENLIGHTENMENT_CONF_NUM_DESKTOPS; i++)
|
|
{
|
|
if ((desks.desk[i].bg) && (desks.desk[i].viewable))
|
|
desks.desk[i].bg->last_viewed = now;
|
|
}
|
|
lst = (Background **) ListItemType(&num, LIST_TYPE_BACKGROUND);
|
|
if (lst)
|
|
{
|
|
for (i = 0; i < num; i++)
|
|
{
|
|
if (lst[i]->pmap)
|
|
{
|
|
if ((now - lst[i]->last_viewed) > mode.desktop_bg_timeout)
|
|
{
|
|
imd = id;
|
|
for (j = 0; j < ENLIGHTENMENT_CONF_NUM_DESKTOPS; j++)
|
|
{
|
|
if (desks.desk[j].bg == lst[i])
|
|
{
|
|
if ((ird) && (j == 0))
|
|
imd = ird;
|
|
else
|
|
imd = id;
|
|
j = ENLIGHTENMENT_CONF_NUM_DESKTOPS;
|
|
}
|
|
}
|
|
Imlib_free_pixmap(imd, lst[i]->pmap);
|
|
lst[i]->pmap = 0;
|
|
for (j = 0; j < ENLIGHTENMENT_CONF_NUM_DESKTOPS; j++)
|
|
{
|
|
if ((desks.desk[j].bg == lst[i])
|
|
&& (!desks.desk[j].viewable))
|
|
SetBG(desks.desk[j].win, 0, 0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Efree(lst);
|
|
}
|
|
EDBUG_RETURN_;
|
|
}
|