1999-10-04 15:06:00 -07:00
|
|
|
/*
|
2005-03-19 08:40:18 -08:00
|
|
|
* Copyright (C) 2000-2005 Carsten Haitzler, Geoff Harrison and various contributors
|
|
|
|
* Copyright (C) 2004-2005 Kim Woelders
|
2000-04-05 16:22:56 -07:00
|
|
|
*
|
1999-10-04 15:06:00 -07:00
|
|
|
* 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:
|
2000-04-05 16:22:56 -07:00
|
|
|
*
|
1999-10-04 15:06:00 -07:00
|
|
|
* 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.
|
2000-04-05 16:22:56 -07:00
|
|
|
*
|
1999-10-04 15:06:00 -07:00
|
|
|
* 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.
|
|
|
|
*/
|
1999-08-17 15:56:46 -07:00
|
|
|
#include "E.h"
|
2005-03-24 01:40:59 -08:00
|
|
|
#include "snaps.h"
|
2003-11-09 15:17:15 -08:00
|
|
|
#include <sys/time.h>
|
1999-08-17 15:56:46 -07:00
|
|
|
|
2004-04-15 12:44:38 -07:00
|
|
|
#define EWIN_BORDER_PART_EVENT_MASK \
|
|
|
|
(KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | \
|
2005-01-28 23:41:49 -08:00
|
|
|
EnterWindowMask | LeaveWindowMask | PointerMotionMask)
|
2004-04-15 12:44:38 -07:00
|
|
|
#define EWIN_BORDER_TITLE_EVENT_MASK \
|
2005-01-28 23:41:49 -08:00
|
|
|
(EWIN_BORDER_PART_EVENT_MASK)
|
2004-04-15 12:44:38 -07:00
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
static void BorderWinpartHandleEvents(XEvent * ev, void *prm);
|
|
|
|
static void BorderFrameHandleEvents(XEvent * ev, void *prm);
|
1999-08-17 15:56:46 -07:00
|
|
|
|
1999-10-07 18:57:20 -07:00
|
|
|
void
|
1999-08-17 15:56:46 -07:00
|
|
|
SyncBorderToEwin(EWin * ewin)
|
|
|
|
{
|
2004-12-28 15:46:49 -08:00
|
|
|
const Border *b;
|
1999-08-17 15:56:46 -07:00
|
|
|
|
|
|
|
b = ewin->border;
|
|
|
|
ICCCM_GetShapeInfo(ewin);
|
2003-12-27 11:20:15 -08:00
|
|
|
EwinSetBorder(ewin, b, 1);
|
1999-08-17 15:56:46 -07:00
|
|
|
}
|
|
|
|
|
1999-10-07 18:57:20 -07:00
|
|
|
void
|
2004-06-07 09:46:08 -07:00
|
|
|
EwinBorderUpdateState(EWin * ewin)
|
|
|
|
{
|
2005-01-29 07:00:00 -08:00
|
|
|
EwinBorderDraw(ewin, 0, 0, 0);
|
2004-06-07 09:46:08 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
BorderWinpartRealise(EWin * ewin, int i)
|
1999-08-17 15:56:46 -07:00
|
|
|
{
|
2004-06-07 09:46:08 -07:00
|
|
|
EWinBit *ewb = &ewin->bits[i];
|
|
|
|
|
|
|
|
if ((ewb->cx != ewb->x) || (ewb->cy != ewb->y) ||
|
|
|
|
(ewb->cw != ewb->w) || (ewb->ch != ewb->h))
|
2000-07-26 11:00:47 -07:00
|
|
|
{
|
2004-06-07 09:46:08 -07:00
|
|
|
if ((ewb->w < 0) || (ewb->h < 0))
|
|
|
|
{
|
2005-02-02 09:12:07 -08:00
|
|
|
EUnmapWindow(ewb->win);
|
2004-06-07 09:46:08 -07:00
|
|
|
}
|
2003-05-22 12:15:03 -07:00
|
|
|
else
|
2004-06-07 09:46:08 -07:00
|
|
|
{
|
2005-02-02 09:12:07 -08:00
|
|
|
EMapWindow(ewb->win);
|
|
|
|
EMoveResizeWindow(ewb->win, ewb->x, ewb->y, ewb->w, ewb->h);
|
2004-06-07 09:46:08 -07:00
|
|
|
}
|
2000-07-26 11:00:47 -07:00
|
|
|
}
|
1999-08-17 15:56:46 -07:00
|
|
|
}
|
|
|
|
|
2004-04-09 06:45:59 -07:00
|
|
|
static void
|
2004-06-26 10:49:01 -07:00
|
|
|
BorderWinpartITclassApply(EWin * ewin, int i, int force)
|
2004-04-09 06:45:59 -07:00
|
|
|
{
|
2004-06-07 09:46:08 -07:00
|
|
|
EWinBit *ewb = &ewin->bits[i];
|
2004-06-26 10:49:01 -07:00
|
|
|
ImageState *is;
|
2004-12-12 12:00:18 -08:00
|
|
|
TextState *ts;
|
2005-01-28 23:41:49 -08:00
|
|
|
const char *txt;
|
2004-05-24 10:39:51 -07:00
|
|
|
|
2004-06-26 10:49:01 -07:00
|
|
|
if (ewb->win == None)
|
|
|
|
return;
|
|
|
|
|
2005-01-29 07:00:00 -08:00
|
|
|
#if 0 /* Debug */
|
|
|
|
Eprintf("BorderWinpartITclassApply: %#lx %#lx %2d %d %s\n",
|
|
|
|
EwinGetClientWin(ewin), EoGetWin(ewin), i, force, EwinGetName(ewin));
|
|
|
|
#endif
|
|
|
|
|
2005-01-28 23:41:49 -08:00
|
|
|
is = ImageclassGetImageState(ewin->border->part[i].iclass, ewb->state,
|
2004-12-28 15:46:49 -08:00
|
|
|
ewin->active, EoIsSticky(ewin));
|
2004-04-09 06:45:59 -07:00
|
|
|
|
2005-01-28 23:41:49 -08:00
|
|
|
ts = NULL;
|
|
|
|
txt = NULL;
|
2004-06-26 10:49:01 -07:00
|
|
|
switch (ewin->border->part[i].flags)
|
2004-05-24 10:39:51 -07:00
|
|
|
{
|
2004-06-26 10:49:01 -07:00
|
|
|
case FLAG_TITLE:
|
2005-01-28 23:41:49 -08:00
|
|
|
txt = EwinGetName(ewin);
|
|
|
|
if (txt && ewin->border->part[i].tclass)
|
|
|
|
ts = TextclassGetTextState(ewin->border->part[i].tclass, ewb->state,
|
|
|
|
ewin->active, EoIsSticky(ewin));
|
2004-06-26 10:49:01 -07:00
|
|
|
break;
|
|
|
|
case FLAG_MINIICON:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
2004-05-24 10:39:51 -07:00
|
|
|
}
|
2005-01-28 23:41:49 -08:00
|
|
|
|
|
|
|
if (!force && ewb->is == is && ewb->ts == ts)
|
|
|
|
return;
|
|
|
|
ewb->is = is;
|
|
|
|
ewb->ts = ts;
|
|
|
|
|
|
|
|
#if 0 /* FIXME - Remove? */
|
|
|
|
ImageclassApply(ewin->border->part[i].iclass, ewb->win,
|
|
|
|
ewb->w, ewb->h, ewin->active,
|
|
|
|
EoIsSticky(ewin), ewb->state, ewb->expose, ST_BORDER);
|
|
|
|
if (ts)
|
|
|
|
TextclassApply(ewin->border->part[i].iclass, ewb->win,
|
|
|
|
ewb->w, ewb->h, ewin->active,
|
|
|
|
EoIsSticky(ewin), ewb->state, ewb->expose,
|
|
|
|
ewin->border->part[i].tclass, txt);
|
|
|
|
#else
|
|
|
|
ITApply(ewb->win, ewin->border->part[i].iclass, is, ewb->w, ewb->h,
|
|
|
|
ewb->state, ewin->active, EoIsSticky(ewin), ewb->expose, ST_BORDER,
|
|
|
|
ewin->border->part[i].tclass, ts, txt);
|
|
|
|
#endif
|
2004-04-09 06:45:59 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2004-06-07 09:46:08 -07:00
|
|
|
BorderWinpartDraw(EWin * ewin, int i)
|
1999-08-17 15:56:46 -07:00
|
|
|
{
|
2004-06-07 09:46:08 -07:00
|
|
|
EWinBit *ewb = &ewin->bits[i];
|
2004-04-09 06:45:59 -07:00
|
|
|
int move = 0, resize = 0, ret = 0;
|
1999-08-17 15:56:46 -07:00
|
|
|
|
2004-06-07 09:46:08 -07:00
|
|
|
if ((ewb->x != ewb->cx) || (ewb->y != ewb->cy))
|
|
|
|
{
|
|
|
|
move = 1;
|
|
|
|
ewb->cx = ewb->x;
|
|
|
|
ewb->cy = ewb->y;
|
2003-05-22 12:15:03 -07:00
|
|
|
ret = 1;
|
2000-07-26 11:00:47 -07:00
|
|
|
}
|
2004-06-07 09:46:08 -07:00
|
|
|
|
|
|
|
if ((ewb->w != ewb->cw) || (ewb->h != ewb->ch))
|
2000-07-26 11:00:47 -07:00
|
|
|
{
|
2004-06-07 09:46:08 -07:00
|
|
|
resize = 1;
|
|
|
|
ewb->cw = ewb->w;
|
|
|
|
ewb->ch = ewb->h;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((resize) || (ewb->expose))
|
|
|
|
{
|
2004-06-26 10:49:01 -07:00
|
|
|
BorderWinpartITclassApply(ewin, i, 1);
|
2004-06-07 09:46:08 -07:00
|
|
|
ewb->expose = 0;
|
2003-05-22 12:15:03 -07:00
|
|
|
ret = 1;
|
2000-07-26 11:00:47 -07:00
|
|
|
}
|
2004-06-07 09:46:08 -07:00
|
|
|
|
2005-01-25 13:58:28 -08:00
|
|
|
return ret;
|
1999-08-17 15:56:46 -07:00
|
|
|
}
|
|
|
|
|
2004-04-09 06:45:59 -07:00
|
|
|
void
|
2004-06-26 10:49:01 -07:00
|
|
|
BorderWinpartChange(EWin * ewin, int i, int force)
|
1999-08-17 15:56:46 -07:00
|
|
|
{
|
2004-06-26 10:49:01 -07:00
|
|
|
BorderWinpartITclassApply(ewin, i, force);
|
2004-04-09 06:45:59 -07:00
|
|
|
|
|
|
|
if (!ewin->shapedone || ewin->border->changes_shape)
|
2004-08-31 10:24:40 -07:00
|
|
|
EwinPropagateShapes(ewin);
|
1999-08-17 15:56:46 -07:00
|
|
|
ewin->shapedone = 1;
|
|
|
|
}
|
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
void
|
2005-01-29 07:00:00 -08:00
|
|
|
EwinBorderDraw(EWin * ewin, int do_shape, int do_paint, int queue_off)
|
1999-08-17 15:56:46 -07:00
|
|
|
{
|
2004-04-09 06:45:59 -07:00
|
|
|
int i, pq;
|
1999-08-17 15:56:46 -07:00
|
|
|
|
|
|
|
if (!ewin)
|
2005-01-25 13:58:28 -08:00
|
|
|
return;
|
2004-04-09 06:45:59 -07:00
|
|
|
|
|
|
|
pq = Mode.queue_up;
|
|
|
|
if (queue_off)
|
|
|
|
Mode.queue_up = 0;
|
|
|
|
|
1999-08-17 15:56:46 -07:00
|
|
|
for (i = 0; i < ewin->border->num_winparts; i++)
|
2005-01-29 07:00:00 -08:00
|
|
|
BorderWinpartITclassApply(ewin, i, do_shape || do_paint);
|
2004-04-09 06:45:59 -07:00
|
|
|
|
|
|
|
if (do_shape || !ewin->shapedone || ewin->border->changes_shape)
|
2004-08-31 10:24:40 -07:00
|
|
|
EwinPropagateShapes(ewin);
|
1999-08-17 15:56:46 -07:00
|
|
|
ewin->shapedone = 1;
|
2004-04-09 06:45:59 -07:00
|
|
|
|
|
|
|
if (queue_off)
|
|
|
|
Mode.queue_up = pq;
|
1999-08-17 15:56:46 -07:00
|
|
|
}
|
|
|
|
|
2004-06-26 10:49:01 -07:00
|
|
|
void
|
|
|
|
EwinBorderUpdateInfo(EWin * ewin)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < ewin->border->num_winparts; i++)
|
|
|
|
{
|
|
|
|
if (ewin->border->part[i].flags == FLAG_TITLE)
|
|
|
|
BorderWinpartITclassApply(ewin, i, 1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-02-01 08:48:05 -08:00
|
|
|
static void
|
2004-06-07 09:46:08 -07:00
|
|
|
BorderWinpartCalc(EWin * ewin, int i)
|
1999-08-17 15:56:46 -07:00
|
|
|
{
|
|
|
|
int x, y, w, h, ox, oy, max, min;
|
|
|
|
int topleft, bottomright;
|
|
|
|
|
|
|
|
topleft = ewin->border->part[i].geom.topleft.originbox;
|
|
|
|
bottomright = ewin->border->part[i].geom.bottomright.originbox;
|
|
|
|
if (topleft >= 0)
|
2004-06-07 09:46:08 -07:00
|
|
|
BorderWinpartCalc(ewin, topleft);
|
1999-08-17 15:56:46 -07:00
|
|
|
if (bottomright >= 0)
|
2004-06-07 09:46:08 -07:00
|
|
|
BorderWinpartCalc(ewin, bottomright);
|
1999-08-17 15:56:46 -07:00
|
|
|
x = y = 0;
|
|
|
|
if (topleft == -1)
|
2000-07-26 11:00:47 -07:00
|
|
|
{
|
2004-12-28 15:46:49 -08:00
|
|
|
x = ((ewin->border->part[i].geom.topleft.x.percent *
|
|
|
|
EoGetW(ewin)) >> 10) +
|
2003-05-22 12:15:03 -07:00
|
|
|
ewin->border->part[i].geom.topleft.x.absolute;
|
2004-12-28 15:46:49 -08:00
|
|
|
y = ((ewin->border->part[i].geom.topleft.y.percent *
|
|
|
|
EoGetH(ewin)) >> 10) +
|
2003-05-22 12:15:03 -07:00
|
|
|
ewin->border->part[i].geom.topleft.y.absolute;
|
2000-07-26 11:00:47 -07:00
|
|
|
}
|
1999-08-17 15:56:46 -07:00
|
|
|
else if (topleft >= 0)
|
2000-07-26 11:00:47 -07:00
|
|
|
{
|
2003-05-22 12:15:03 -07:00
|
|
|
x = ((ewin->border->part[i].geom.topleft.x.percent *
|
|
|
|
ewin->bits[topleft].w) >> 10) +
|
|
|
|
ewin->border->part[i].geom.topleft.x.absolute +
|
|
|
|
ewin->bits[topleft].x;
|
|
|
|
y = ((ewin->border->part[i].geom.topleft.y.percent *
|
|
|
|
ewin->bits[topleft].h) >> 10) +
|
|
|
|
ewin->border->part[i].geom.topleft.y.absolute +
|
|
|
|
ewin->bits[topleft].y;
|
2000-07-26 11:00:47 -07:00
|
|
|
}
|
1999-08-17 15:56:46 -07:00
|
|
|
ox = oy = 0;
|
|
|
|
if (bottomright == -1)
|
2000-07-26 11:00:47 -07:00
|
|
|
{
|
2003-05-22 12:15:03 -07:00
|
|
|
ox = ((ewin->border->
|
2004-12-28 15:46:49 -08:00
|
|
|
part[i].geom.bottomright.x.percent * EoGetW(ewin)) >> 10) +
|
2003-05-22 12:15:03 -07:00
|
|
|
ewin->border->part[i].geom.bottomright.x.absolute;
|
|
|
|
oy = ((ewin->border->
|
2004-12-28 15:46:49 -08:00
|
|
|
part[i].geom.bottomright.y.percent * EoGetH(ewin)) >> 10) +
|
2003-05-22 12:15:03 -07:00
|
|
|
ewin->border->part[i].geom.bottomright.y.absolute;
|
2000-07-26 11:00:47 -07:00
|
|
|
}
|
1999-08-17 15:56:46 -07:00
|
|
|
else if (bottomright >= 0)
|
2000-07-26 11:00:47 -07:00
|
|
|
{
|
2003-05-22 12:15:03 -07:00
|
|
|
ox = ((ewin->border->part[i].geom.bottomright.x.percent *
|
|
|
|
ewin->bits[bottomright].w) >> 10) +
|
|
|
|
ewin->border->part[i].geom.bottomright.x.absolute +
|
|
|
|
ewin->bits[bottomright].x;
|
|
|
|
oy = ((ewin->border->part[i].geom.bottomright.y.percent *
|
|
|
|
ewin->bits[bottomright].h) >> 10) +
|
|
|
|
ewin->border->part[i].geom.bottomright.y.absolute +
|
|
|
|
ewin->bits[bottomright].y;
|
2000-07-26 11:00:47 -07:00
|
|
|
}
|
1999-08-17 15:56:46 -07:00
|
|
|
/*
|
2000-04-05 16:22:56 -07:00
|
|
|
* calculate height before width, because we may need it in order to
|
|
|
|
* determine the font size. But we might do it the other way around for
|
|
|
|
* side borders :-)
|
1999-08-17 15:56:46 -07:00
|
|
|
*/
|
|
|
|
|
|
|
|
h = (oy - y) + 1;
|
|
|
|
max = ewin->border->part[i].geom.height.max;
|
|
|
|
min = ewin->border->part[i].geom.height.min;
|
|
|
|
|
|
|
|
/*
|
2000-04-05 16:22:56 -07:00
|
|
|
* If the title bar max size is set to zero, then set the title bar size to
|
|
|
|
* just a little bit more than the size of the title text.
|
1999-08-17 15:56:46 -07:00
|
|
|
*/
|
|
|
|
|
|
|
|
if (max == 0 && ewin->border->part[i].flags == FLAG_TITLE)
|
2000-07-26 11:00:47 -07:00
|
|
|
{
|
2003-05-22 12:15:03 -07:00
|
|
|
int dummywidth, wmax, wmin;
|
|
|
|
ImageClass *iclass;
|
|
|
|
TextClass *tclass;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* calculate width before height, because we need it in order to
|
|
|
|
* determine the font size.
|
|
|
|
*/
|
|
|
|
|
|
|
|
w = (ox - x) + 1;
|
|
|
|
wmax = ewin->border->part[i].geom.width.max;
|
|
|
|
wmin = ewin->border->part[i].geom.width.min;
|
|
|
|
if (w > wmax)
|
|
|
|
{
|
|
|
|
w = wmax;
|
|
|
|
x = ((x + ox) - w) >> 1;
|
|
|
|
}
|
|
|
|
else if (w < wmin)
|
|
|
|
{
|
|
|
|
w = wmin;
|
|
|
|
}
|
|
|
|
iclass = ewin->border->part[i].iclass;
|
|
|
|
tclass = ewin->border->part[i].tclass;
|
2004-12-28 15:46:49 -08:00
|
|
|
TextSize(tclass, ewin->active, EoIsSticky(ewin), ewin->bits[i].state,
|
2005-01-09 14:36:01 -08:00
|
|
|
EwinGetName(ewin), &max, &dummywidth,
|
2003-05-22 12:15:03 -07:00
|
|
|
w - (iclass->padding.top + iclass->padding.bottom));
|
|
|
|
max += iclass->padding.left + iclass->padding.right;
|
|
|
|
if (h > max)
|
|
|
|
{
|
|
|
|
y = y + (((h - max) * tclass->justification) >> 10);
|
|
|
|
h = max;
|
|
|
|
}
|
|
|
|
if (h < min)
|
|
|
|
{
|
|
|
|
h = min;
|
|
|
|
}
|
2000-07-26 11:00:47 -07:00
|
|
|
}
|
1999-12-21 00:09:27 -08:00
|
|
|
else
|
2000-07-26 11:00:47 -07:00
|
|
|
{
|
2003-05-22 12:15:03 -07:00
|
|
|
if (h > max)
|
|
|
|
{
|
|
|
|
h = max;
|
|
|
|
y = ((y + oy) - h) >> 1;
|
|
|
|
}
|
|
|
|
else if (h < min)
|
|
|
|
{
|
|
|
|
h = min;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* and now the width.
|
|
|
|
*/
|
|
|
|
|
|
|
|
w = (ox - x) + 1;
|
|
|
|
max = ewin->border->part[i].geom.width.max;
|
|
|
|
min = ewin->border->part[i].geom.width.min;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the title bar max size is set to zero, then set the title bar
|
|
|
|
* size to just a little bit more than the size of the title text.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (max == 0 && ewin->border->part[i].flags == FLAG_TITLE)
|
|
|
|
{
|
|
|
|
int dummyheight;
|
|
|
|
|
|
|
|
ImageClass *iclass;
|
|
|
|
TextClass *tclass;
|
|
|
|
|
|
|
|
iclass = ewin->border->part[i].iclass;
|
|
|
|
tclass = ewin->border->part[i].tclass;
|
2004-12-28 15:46:49 -08:00
|
|
|
TextSize(tclass, ewin->active, EoIsSticky(ewin),
|
2005-01-09 14:36:01 -08:00
|
|
|
ewin->bits[i].state, EwinGetName(ewin), &max,
|
2004-12-28 15:46:49 -08:00
|
|
|
&dummyheight,
|
2003-05-22 12:15:03 -07:00
|
|
|
h - (iclass->padding.top + iclass->padding.bottom));
|
|
|
|
max += iclass->padding.left + iclass->padding.right;
|
|
|
|
|
|
|
|
if (w > max)
|
|
|
|
{
|
|
|
|
x = x + (((w - max) * tclass->justification) >> 10);
|
|
|
|
w = max;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (w > max)
|
|
|
|
{
|
|
|
|
w = max;
|
|
|
|
x = ((x + ox) - w) >> 1;
|
|
|
|
}
|
|
|
|
else if (w < min)
|
|
|
|
{
|
|
|
|
w = min;
|
|
|
|
}
|
2000-07-26 11:00:47 -07:00
|
|
|
}
|
1999-12-21 00:09:27 -08:00
|
|
|
if ((ewin->shaded) && (!ewin->border->part[i].keep_for_shade))
|
2000-07-26 11:00:47 -07:00
|
|
|
{
|
2003-05-22 12:15:03 -07:00
|
|
|
ewin->bits[i].x = -100;
|
|
|
|
ewin->bits[i].y = -100;
|
|
|
|
ewin->bits[i].w = -1;
|
|
|
|
ewin->bits[i].h = -1;
|
2000-07-26 11:00:47 -07:00
|
|
|
}
|
1999-12-21 00:09:27 -08:00
|
|
|
else
|
2000-07-26 11:00:47 -07:00
|
|
|
{
|
2003-05-22 12:15:03 -07:00
|
|
|
ewin->bits[i].x = x;
|
|
|
|
ewin->bits[i].y = y;
|
|
|
|
ewin->bits[i].w = w;
|
|
|
|
ewin->bits[i].h = h;
|
2000-07-26 11:00:47 -07:00
|
|
|
}
|
1999-12-21 00:09:27 -08:00
|
|
|
}
|
1999-08-17 15:56:46 -07:00
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
void
|
|
|
|
EwinBorderCalcSizes(EWin * ewin)
|
1999-12-21 00:09:27 -08:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
char reshape;
|
1999-08-17 15:56:46 -07:00
|
|
|
|
1999-12-21 00:09:27 -08:00
|
|
|
if (!ewin)
|
2005-01-25 13:58:28 -08:00
|
|
|
return;
|
1999-12-21 00:09:27 -08:00
|
|
|
if (!ewin->border)
|
2005-01-25 13:58:28 -08:00
|
|
|
return;
|
1999-11-19 11:50:49 -08:00
|
|
|
|
1999-12-21 00:09:27 -08:00
|
|
|
for (i = 0; i < ewin->border->num_winparts; i++)
|
|
|
|
ewin->bits[i].w = -2;
|
|
|
|
for (i = 0; i < ewin->border->num_winparts; i++)
|
|
|
|
if (ewin->bits[i].w == -2)
|
2004-06-07 09:46:08 -07:00
|
|
|
BorderWinpartCalc(ewin, i);
|
1999-12-21 00:09:27 -08:00
|
|
|
for (i = 0; i < ewin->border->num_winparts; i++)
|
2004-06-07 09:46:08 -07:00
|
|
|
BorderWinpartRealise(ewin, i);
|
2003-09-28 12:08:27 -07:00
|
|
|
|
1999-12-21 00:09:27 -08:00
|
|
|
reshape = 0;
|
|
|
|
for (i = 0; i < ewin->border->num_winparts; i++)
|
2000-07-26 11:00:47 -07:00
|
|
|
{
|
2004-06-07 09:46:08 -07:00
|
|
|
reshape |= BorderWinpartDraw(ewin, i);
|
2003-05-22 12:15:03 -07:00
|
|
|
ewin->bits[i].no_expose = 1;
|
2000-07-26 11:00:47 -07:00
|
|
|
}
|
2003-12-27 11:20:15 -08:00
|
|
|
|
2004-03-20 07:49:05 -08:00
|
|
|
if ((reshape) || (Mode.have_place_grab))
|
2000-07-26 11:00:47 -07:00
|
|
|
{
|
2004-03-20 07:49:05 -08:00
|
|
|
if (Mode.have_place_grab)
|
2003-05-22 12:15:03 -07:00
|
|
|
{
|
|
|
|
char pq;
|
2000-07-26 11:00:47 -07:00
|
|
|
|
2004-04-09 05:59:56 -07:00
|
|
|
pq = Mode.queue_up;
|
|
|
|
Mode.queue_up = 0;
|
2004-08-31 10:24:40 -07:00
|
|
|
EwinPropagateShapes(ewin);
|
2004-04-09 05:59:56 -07:00
|
|
|
Mode.queue_up = pq;
|
2003-05-22 12:15:03 -07:00
|
|
|
}
|
|
|
|
else
|
2004-08-31 10:24:40 -07:00
|
|
|
EwinPropagateShapes(ewin);
|
2003-05-22 12:15:03 -07:00
|
|
|
ewin->shapedone = 1;
|
2000-07-26 11:00:47 -07:00
|
|
|
}
|
1999-12-21 00:09:27 -08:00
|
|
|
}
|
1999-09-16 16:21:57 -07:00
|
|
|
|
2005-02-06 11:13:34 -08:00
|
|
|
void
|
2005-01-23 10:23:04 -08:00
|
|
|
BorderIncRefcount(const Border * b)
|
|
|
|
{
|
|
|
|
((Border *) b)->ref_count++;
|
|
|
|
}
|
|
|
|
|
2005-02-06 11:13:34 -08:00
|
|
|
void
|
2005-01-23 10:23:04 -08:00
|
|
|
BorderDecRefcount(const Border * b)
|
|
|
|
{
|
|
|
|
((Border *) b)->ref_count--;
|
|
|
|
}
|
|
|
|
|
2005-02-06 11:13:34 -08:00
|
|
|
const char *
|
|
|
|
BorderGetName(const Border * b)
|
|
|
|
{
|
|
|
|
return (b) ? b->name : NULL;
|
|
|
|
}
|
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
void
|
2004-07-01 02:13:22 -07:00
|
|
|
EwinBorderSelect(EWin * ewin)
|
|
|
|
{
|
2004-12-28 15:46:49 -08:00
|
|
|
const Border *b;
|
2004-07-01 02:13:22 -07:00
|
|
|
|
2005-01-30 03:02:43 -08:00
|
|
|
/* Quit if we allready have a border that isn't an internal one */
|
2004-07-01 02:13:22 -07:00
|
|
|
b = ewin->border;
|
2005-01-30 03:02:43 -08:00
|
|
|
if (b && strncmp(b->name, "__", 2))
|
|
|
|
goto done;
|
2004-07-01 02:13:22 -07:00
|
|
|
|
|
|
|
ICCCM_GetShapeInfo(ewin);
|
|
|
|
|
2005-02-06 11:13:34 -08:00
|
|
|
if ((!ewin->client.mwm_decor_title && !ewin->client.mwm_decor_border) ||
|
|
|
|
(Conf.dock.enable && ewin->docked))
|
|
|
|
b = FindItem("BORDERLESS", 0, LIST_FINDBY_NAME, LIST_TYPE_BORDER);
|
2004-07-01 02:13:22 -07:00
|
|
|
else
|
2005-02-06 11:13:34 -08:00
|
|
|
b = WindowMatchEwinBorder(ewin);
|
|
|
|
|
2004-07-01 02:13:22 -07:00
|
|
|
if (!b)
|
2005-02-06 11:13:34 -08:00
|
|
|
b = FindItem("DEFAULT", 0, LIST_FINDBY_NAME, LIST_TYPE_BORDER);
|
2004-07-01 02:13:22 -07:00
|
|
|
|
|
|
|
if (!b)
|
|
|
|
b = FindItem("__FALLBACK_BORDER", 0, LIST_FINDBY_NAME, LIST_TYPE_BORDER);
|
|
|
|
|
2005-01-30 03:02:43 -08:00
|
|
|
done:
|
2004-08-14 22:02:14 -07:00
|
|
|
ewin->normal_border = ewin->border = b;
|
2004-07-01 02:13:22 -07:00
|
|
|
}
|
|
|
|
|
2005-01-23 10:23:04 -08:00
|
|
|
void
|
|
|
|
EwinBorderDetach(EWin * ewin)
|
|
|
|
{
|
|
|
|
const Border *b = ewin->border;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (!b)
|
|
|
|
return;
|
|
|
|
|
|
|
|
EventCallbackUnregister(EoGetWin(ewin), 0, BorderFrameHandleEvents, ewin);
|
|
|
|
for (i = 0; i < b->num_winparts; i++)
|
|
|
|
{
|
|
|
|
EventCallbackUnregister(ewin->bits[i].win, 0,
|
|
|
|
BorderWinpartHandleEvents, &ewin->bits[i]);
|
|
|
|
if (ewin->bits[i].win)
|
2005-02-02 09:12:07 -08:00
|
|
|
EDestroyWindow(ewin->bits[i].win);
|
2005-01-23 10:23:04 -08:00
|
|
|
}
|
|
|
|
if (ewin->bits)
|
|
|
|
Efree(ewin->bits);
|
|
|
|
ewin->bits = NULL;
|
|
|
|
BorderDecRefcount(b);
|
|
|
|
|
|
|
|
ewin->border = NULL;
|
2005-01-30 03:02:43 -08:00
|
|
|
|
|
|
|
if (b->throwaway)
|
|
|
|
BorderDestroy((Border *) b);
|
2005-01-23 10:23:04 -08:00
|
|
|
}
|
|
|
|
|
2004-06-27 08:59:32 -07:00
|
|
|
void
|
2004-12-28 15:46:49 -08:00
|
|
|
EwinBorderSetTo(EWin * ewin, const Border * b)
|
2004-06-27 08:59:32 -07:00
|
|
|
{
|
2004-12-28 15:46:49 -08:00
|
|
|
int i;
|
|
|
|
|
|
|
|
if (ewin->border == b)
|
2005-01-25 13:58:28 -08:00
|
|
|
return;
|
2004-06-27 08:59:32 -07:00
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
if (b == NULL)
|
2004-06-27 08:59:32 -07:00
|
|
|
{
|
2004-12-28 15:46:49 -08:00
|
|
|
b = ewin->border;
|
|
|
|
ewin->border = NULL;
|
2004-06-27 08:59:32 -07:00
|
|
|
}
|
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
if (ewin->border)
|
2005-01-23 10:23:04 -08:00
|
|
|
EwinBorderDetach(ewin);
|
2003-12-27 11:20:15 -08:00
|
|
|
|
1999-12-21 00:09:27 -08:00
|
|
|
ewin->border = b;
|
2004-12-28 15:46:49 -08:00
|
|
|
BorderIncRefcount(b);
|
2003-12-27 11:20:15 -08:00
|
|
|
HintsSetWindowBorder(ewin);
|
1999-12-21 00:09:27 -08:00
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
EventCallbackRegister(EoGetWin(ewin), 0, BorderFrameHandleEvents, ewin);
|
|
|
|
|
1999-12-21 00:09:27 -08:00
|
|
|
if (b->num_winparts > 0)
|
|
|
|
ewin->bits = Emalloc(sizeof(EWinBit) * b->num_winparts);
|
2004-12-28 15:46:49 -08:00
|
|
|
|
1999-12-21 00:09:27 -08:00
|
|
|
for (i = 0; i < b->num_winparts; i++)
|
2000-07-26 11:00:47 -07:00
|
|
|
{
|
2004-12-28 15:46:49 -08:00
|
|
|
ewin->bits[i].ewin = ewin; /* Reference to associated Ewin */
|
2005-03-20 07:58:51 -08:00
|
|
|
|
|
|
|
ewin->bits[i].win = ECreateWindow(EoGetWin(ewin), -10, -10, 1, 1, 0);
|
|
|
|
ECursorApply(b->part[i].ec, ewin->bits[i].win);
|
|
|
|
EMapWindow(ewin->bits[i].win);
|
|
|
|
EventCallbackRegister(ewin->bits[i].win, 0,
|
|
|
|
BorderWinpartHandleEvents, &ewin->bits[i]);
|
|
|
|
/*
|
|
|
|
* KeyPressMask KeyReleaseMask ButtonPressMask
|
|
|
|
* ButtonReleaseMask
|
|
|
|
* EnterWindowMask LeaveWindowMask PointerMotionMask
|
|
|
|
* PointerMotionHintMask Button1MotionMask
|
|
|
|
* Button2MotionMask
|
|
|
|
* Button3MotionMask Button4MotionMask Button5MotionMask
|
|
|
|
* ButtonMotionMask KeymapStateMask ExposureMask
|
|
|
|
* VisibilityChangeMask StructureNotifyMask
|
|
|
|
* ResizeRedirectMask
|
|
|
|
* SubstructureNotifyMask SubstructureRedirectMask
|
|
|
|
* FocusChangeMask PropertyChangeMas ColormapChangeMask
|
|
|
|
* OwnerGrabButtonMask
|
|
|
|
*/
|
|
|
|
if (b->part[i].flags & FLAG_TITLE)
|
|
|
|
ESelectInput(ewin->bits[i].win, EWIN_BORDER_TITLE_EVENT_MASK);
|
2003-05-22 12:15:03 -07:00
|
|
|
else
|
2005-03-20 07:58:51 -08:00
|
|
|
ESelectInput(ewin->bits[i].win, EWIN_BORDER_PART_EVENT_MASK);
|
|
|
|
ewin->bits[i].x = -10;
|
|
|
|
ewin->bits[i].y = -10;
|
|
|
|
ewin->bits[i].w = -10;
|
|
|
|
ewin->bits[i].h = -10;
|
|
|
|
ewin->bits[i].cx = -99;
|
|
|
|
ewin->bits[i].cy = -99;
|
|
|
|
ewin->bits[i].cw = -99;
|
|
|
|
ewin->bits[i].ch = -99;
|
|
|
|
ewin->bits[i].state = 0;
|
|
|
|
ewin->bits[i].expose = 0;
|
|
|
|
ewin->bits[i].no_expose = 0;
|
|
|
|
ewin->bits[i].left = 0;
|
|
|
|
ewin->bits[i].is = NULL;
|
2000-07-26 11:00:47 -07:00
|
|
|
}
|
1999-08-17 15:56:46 -07:00
|
|
|
|
1999-12-21 00:09:27 -08:00
|
|
|
{
|
|
|
|
Window *wl;
|
|
|
|
int j = 0;
|
|
|
|
|
|
|
|
wl = Emalloc((b->num_winparts + 1) * sizeof(Window));
|
|
|
|
for (i = b->num_winparts - 1; i >= 0; i--)
|
2003-05-22 12:15:03 -07:00
|
|
|
{
|
|
|
|
if (b->part[i].ontop)
|
|
|
|
wl[j++] = ewin->bits[i].win;
|
|
|
|
}
|
1999-12-21 00:09:27 -08:00
|
|
|
wl[j++] = ewin->win_container;
|
|
|
|
for (i = b->num_winparts - 1; i >= 0; i--)
|
2003-05-22 12:15:03 -07:00
|
|
|
{
|
|
|
|
if (!b->part[i].ontop)
|
|
|
|
wl[j++] = ewin->bits[i].win;
|
|
|
|
}
|
1999-12-21 00:09:27 -08:00
|
|
|
XRestackWindows(disp, wl, j);
|
|
|
|
Efree(wl);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!ewin->shaded)
|
2005-02-02 09:12:07 -08:00
|
|
|
EMoveWindow(ewin->win_container, b->border.left, b->border.top);
|
2004-06-26 11:24:39 -07:00
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
EwinBorderCalcSizes(ewin);
|
2004-08-31 10:24:40 -07:00
|
|
|
EwinPropagateShapes(ewin);
|
2005-03-24 01:40:59 -08:00
|
|
|
|
|
|
|
SnapshotEwinUpdate(ewin, SNAP_USE_BORDER);
|
1999-12-21 00:09:27 -08:00
|
|
|
}
|
|
|
|
|
2003-12-27 11:20:15 -08:00
|
|
|
void
|
2004-12-28 15:46:49 -08:00
|
|
|
EwinSetBorder(EWin * ewin, const Border * b, int apply)
|
2003-12-27 11:20:15 -08:00
|
|
|
{
|
2005-01-30 03:02:43 -08:00
|
|
|
if (!b || ewin->border == b)
|
2003-12-27 11:20:15 -08:00
|
|
|
return;
|
|
|
|
|
|
|
|
if (apply)
|
|
|
|
{
|
2005-01-30 03:02:43 -08:00
|
|
|
EwinBorderSetTo(ewin, b);
|
|
|
|
ICCCM_MatchSize(ewin);
|
|
|
|
MoveResizeEwin(ewin, EoGetX(ewin), EoGetY(ewin),
|
|
|
|
ewin->client.w, ewin->client.h);
|
2003-12-27 11:20:15 -08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2004-12-28 15:46:49 -08:00
|
|
|
if (ewin->border)
|
|
|
|
BorderDecRefcount(ewin->border);
|
2003-12-27 11:20:15 -08:00
|
|
|
ewin->border = b;
|
2004-12-28 15:46:49 -08:00
|
|
|
if (b)
|
|
|
|
BorderIncRefcount(b);
|
2003-12-27 11:20:15 -08:00
|
|
|
}
|
2004-07-02 13:59:32 -07:00
|
|
|
|
|
|
|
if (!ewin->st.fullscreen)
|
|
|
|
ewin->normal_border = b;
|
2003-12-27 11:20:15 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
EwinSetBorderByName(EWin * ewin, const char *name, int apply)
|
|
|
|
{
|
|
|
|
Border *b;
|
|
|
|
|
|
|
|
b = (Border *) FindItem(name, 0, LIST_FINDBY_NAME, LIST_TYPE_BORDER);
|
|
|
|
|
|
|
|
EwinSetBorder(ewin, b, apply);
|
|
|
|
}
|
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
Border *
|
|
|
|
BorderCreate(const char *name)
|
1999-12-21 00:09:27 -08:00
|
|
|
{
|
2004-12-28 15:46:49 -08:00
|
|
|
Border *b;
|
2004-02-08 14:51:50 -08:00
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
b = Ecalloc(1, sizeof(Border));
|
|
|
|
if (!b)
|
2005-01-25 13:58:28 -08:00
|
|
|
return NULL;
|
2004-03-02 11:17:17 -08:00
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
b->name = Estrdup(name);
|
|
|
|
b->group_border_name = NULL;
|
|
|
|
b->shadedir = 2;
|
2003-12-28 09:57:31 -08:00
|
|
|
|
2005-01-25 13:58:28 -08:00
|
|
|
return b;
|
1999-12-21 00:09:27 -08:00
|
|
|
}
|
|
|
|
|
2004-06-06 09:38:17 -07:00
|
|
|
void
|
2004-12-28 15:46:49 -08:00
|
|
|
BorderDestroy(Border * b)
|
2004-06-06 09:38:17 -07:00
|
|
|
{
|
2004-12-28 15:46:49 -08:00
|
|
|
int i;
|
2004-06-06 09:38:17 -07:00
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
if (!b)
|
2005-01-25 13:58:28 -08:00
|
|
|
return;
|
2004-02-17 15:28:25 -08:00
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
if (b->ref_count > 0)
|
2004-02-21 11:48:32 -08:00
|
|
|
{
|
2004-12-28 15:46:49 -08:00
|
|
|
DialogOK(_("Border Error!"), _("%u references remain\n"), b->ref_count);
|
2005-01-25 13:58:28 -08:00
|
|
|
return;
|
2004-02-21 11:48:32 -08:00
|
|
|
}
|
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
while (RemoveItemByPtr(b, LIST_TYPE_BORDER));
|
2004-02-17 15:28:25 -08:00
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
for (i = 0; i < b->num_winparts; i++)
|
2004-02-17 15:28:25 -08:00
|
|
|
{
|
2004-12-28 15:46:49 -08:00
|
|
|
if (b->part[i].iclass)
|
|
|
|
b->part[i].iclass->ref_count--;
|
|
|
|
if (b->part[i].tclass)
|
|
|
|
b->part[i].tclass->ref_count--;
|
|
|
|
if (b->part[i].aclass)
|
|
|
|
ActionclassDecRefcount(b->part[i].aclass);
|
|
|
|
if (b->part[i].ec)
|
|
|
|
ECursorDecRefcount(b->part[i].ec);
|
2004-02-17 15:28:25 -08:00
|
|
|
}
|
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
if (b->num_winparts > 0)
|
|
|
|
Efree(b->part);
|
2004-02-17 15:28:25 -08:00
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
if (b->name)
|
|
|
|
Efree(b->name);
|
|
|
|
if (b->group_border_name)
|
|
|
|
Efree(b->group_border_name);
|
|
|
|
if (b->aclass)
|
|
|
|
ActionclassDecRefcount(b->aclass);
|
2004-02-17 15:28:25 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2004-12-28 15:46:49 -08:00
|
|
|
BorderWinpartAdd(Border * b, ImageClass * iclass, ActionClass * aclass,
|
|
|
|
TextClass * tclass, ECursor * ec, char ontop, int flags,
|
|
|
|
char isregion, int wmin, int wmax, int hmin, int hmax,
|
|
|
|
int torigin, int txp, int txa, int typ, int tya, int borigin,
|
|
|
|
int bxp, int bxa, int byp, int bya, char keep_for_shade)
|
2004-02-17 15:28:25 -08:00
|
|
|
{
|
2004-12-28 15:46:49 -08:00
|
|
|
int n;
|
2004-02-17 15:28:25 -08:00
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
b->num_winparts++;
|
|
|
|
n = b->num_winparts;
|
2004-02-17 15:28:25 -08:00
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
isregion = 0;
|
1999-12-21 00:09:27 -08:00
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
b->part = Erealloc(b->part, n * sizeof(WinPart));
|
1999-12-21 00:09:27 -08:00
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
if (!iclass)
|
|
|
|
iclass = ImageclassFind(NULL, 0);
|
1999-12-21 00:09:27 -08:00
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
b->part[n - 1].iclass = iclass;
|
|
|
|
if (iclass)
|
|
|
|
iclass->ref_count++;
|
2004-04-04 14:44:45 -07:00
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
b->part[n - 1].aclass = aclass;
|
|
|
|
if (aclass)
|
|
|
|
ActionclassDecRefcount(aclass);
|
1999-12-21 00:09:27 -08:00
|
|
|
|
|
|
|
b->part[n - 1].tclass = tclass;
|
|
|
|
if (tclass)
|
|
|
|
tclass->ref_count++;
|
|
|
|
|
|
|
|
b->part[n - 1].ec = ec;
|
|
|
|
if (ec)
|
2004-07-15 09:46:06 -07:00
|
|
|
ECursorIncRefcount(ec);
|
1999-12-21 00:09:27 -08:00
|
|
|
|
|
|
|
b->part[n - 1].ontop = ontop;
|
|
|
|
b->part[n - 1].flags = flags;
|
|
|
|
b->part[n - 1].keep_for_shade = keep_for_shade;
|
|
|
|
b->part[n - 1].geom.width.min = wmin;
|
|
|
|
b->part[n - 1].geom.width.max = wmax;
|
|
|
|
b->part[n - 1].geom.height.min = hmin;
|
|
|
|
b->part[n - 1].geom.height.max = hmax;
|
|
|
|
b->part[n - 1].geom.topleft.originbox = torigin;
|
|
|
|
b->part[n - 1].geom.topleft.x.percent = txp;
|
|
|
|
b->part[n - 1].geom.topleft.x.absolute = txa;
|
|
|
|
b->part[n - 1].geom.topleft.y.percent = typ;
|
|
|
|
b->part[n - 1].geom.topleft.y.absolute = tya;
|
|
|
|
b->part[n - 1].geom.bottomright.originbox = borigin;
|
|
|
|
b->part[n - 1].geom.bottomright.x.percent = bxp;
|
|
|
|
b->part[n - 1].geom.bottomright.x.absolute = bxa;
|
|
|
|
b->part[n - 1].geom.bottomright.y.percent = byp;
|
|
|
|
b->part[n - 1].geom.bottomright.y.absolute = bya;
|
|
|
|
}
|
1999-08-17 15:56:46 -07:00
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
void
|
|
|
|
EwinBorderMinShadeSize(EWin * ewin, int *mw, int *mh)
|
1999-12-21 00:09:27 -08:00
|
|
|
{
|
2004-02-01 08:48:05 -08:00
|
|
|
int i, pw, ph, w, h, min_w, min_h;
|
1999-12-21 00:09:27 -08:00
|
|
|
int leftborderwidth, rightborderwidth;
|
|
|
|
int topborderwidth, bottomborderwidth;
|
1999-08-17 15:56:46 -07:00
|
|
|
|
2004-02-01 08:48:05 -08:00
|
|
|
min_w = 32;
|
|
|
|
min_h = 32;
|
|
|
|
|
1999-12-21 00:09:27 -08:00
|
|
|
if (!ewin)
|
2004-03-20 07:49:05 -08:00
|
|
|
goto done;
|
2004-02-01 08:48:05 -08:00
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
pw = EoGetW(ewin);
|
|
|
|
ph = EoGetH(ewin);
|
2004-02-01 08:48:05 -08:00
|
|
|
|
|
|
|
for (i = 0; i < ewin->border->num_winparts; i++)
|
|
|
|
ewin->bits[i].w = -2;
|
|
|
|
for (i = 0; i < ewin->border->num_winparts; i++)
|
|
|
|
if (ewin->bits[i].w == -2)
|
2004-06-07 09:46:08 -07:00
|
|
|
BorderWinpartCalc(ewin, i);
|
2004-02-01 08:48:05 -08:00
|
|
|
|
1999-12-21 00:09:27 -08:00
|
|
|
switch (ewin->border->shadedir)
|
2000-07-26 11:00:47 -07:00
|
|
|
{
|
2003-05-22 12:15:03 -07:00
|
|
|
case 0:
|
|
|
|
case 1:
|
|
|
|
/* get the correct width, based on the borderparts that */
|
|
|
|
/*are remaining visible */
|
|
|
|
leftborderwidth = rightborderwidth = 0;
|
|
|
|
for (i = 0; i < ewin->border->num_winparts; i++)
|
|
|
|
{
|
2004-02-01 08:48:05 -08:00
|
|
|
if (!ewin->border->part[i].keep_for_shade)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
w = ewin->border->border.left - ewin->bits[i].x;
|
|
|
|
if (leftborderwidth < w)
|
|
|
|
leftborderwidth = w;
|
|
|
|
|
|
|
|
w = ewin->bits[i].x + ewin->bits[i].w -
|
2004-12-28 15:46:49 -08:00
|
|
|
(EoGetW(ewin) - ewin->border->border.right);
|
2004-02-01 08:48:05 -08:00
|
|
|
if (rightborderwidth < w)
|
|
|
|
rightborderwidth = w;
|
2003-05-22 12:15:03 -07:00
|
|
|
}
|
2004-12-28 15:46:49 -08:00
|
|
|
EoSetW(ewin, rightborderwidth + leftborderwidth);
|
2003-05-22 12:15:03 -07:00
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
case 3:
|
|
|
|
topborderwidth = bottomborderwidth = 0;
|
|
|
|
for (i = 0; i < ewin->border->num_winparts; i++)
|
|
|
|
{
|
2004-02-01 08:48:05 -08:00
|
|
|
if (!ewin->border->part[i].keep_for_shade)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
h = ewin->border->border.top - ewin->bits[i].y;
|
|
|
|
if (topborderwidth < h)
|
|
|
|
topborderwidth = h;
|
|
|
|
|
|
|
|
h = ewin->bits[i].y + ewin->bits[i].h -
|
2004-12-28 15:46:49 -08:00
|
|
|
(EoGetH(ewin) - ewin->border->border.bottom);
|
2004-03-26 13:51:22 -08:00
|
|
|
if (bottomborderwidth < h)
|
|
|
|
bottomborderwidth = h;
|
2003-05-22 12:15:03 -07:00
|
|
|
}
|
2004-12-28 15:46:49 -08:00
|
|
|
EoSetH(ewin, bottomborderwidth + topborderwidth);
|
2003-05-22 12:15:03 -07:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
2000-07-26 11:00:47 -07:00
|
|
|
}
|
2004-02-01 08:48:05 -08:00
|
|
|
|
|
|
|
for (i = 0; i < ewin->border->num_winparts; i++)
|
|
|
|
ewin->bits[i].w = -2;
|
|
|
|
for (i = 0; i < ewin->border->num_winparts; i++)
|
|
|
|
if (ewin->bits[i].w == -2)
|
2004-06-07 09:46:08 -07:00
|
|
|
BorderWinpartCalc(ewin, i);
|
2004-02-01 08:48:05 -08:00
|
|
|
|
|
|
|
min_w = 0;
|
|
|
|
min_h = 0;
|
|
|
|
for (i = 0; i < ewin->border->num_winparts; i++)
|
|
|
|
{
|
|
|
|
if (!ewin->border->part[i].keep_for_shade)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
w = ewin->bits[i].x + ewin->bits[i].w;
|
|
|
|
if (min_w < w)
|
|
|
|
min_w = w;
|
|
|
|
|
|
|
|
h = ewin->bits[i].y + ewin->bits[i].h;
|
|
|
|
if (min_h < h)
|
|
|
|
min_h = h;
|
|
|
|
}
|
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
EoSetW(ewin, pw);
|
|
|
|
EoSetH(ewin, ph);
|
2004-02-01 08:48:05 -08:00
|
|
|
|
2004-03-20 07:49:05 -08:00
|
|
|
done:
|
2004-02-01 08:48:05 -08:00
|
|
|
*mw = min_w;
|
|
|
|
*mh = min_h;
|
1999-12-21 00:09:27 -08:00
|
|
|
}
|
1999-08-17 15:56:46 -07:00
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
int
|
|
|
|
BorderWinpartIndex(EWin * ewin, Window win)
|
1999-12-21 00:09:27 -08:00
|
|
|
{
|
2004-12-28 15:46:49 -08:00
|
|
|
int i;
|
2003-12-27 11:20:15 -08:00
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
for (i = 0; i < ewin->border->num_winparts; i++)
|
2000-07-26 11:00:47 -07:00
|
|
|
{
|
2004-12-28 15:46:49 -08:00
|
|
|
if (win == ewin->bits[i].win)
|
|
|
|
return i;
|
2000-07-26 11:00:47 -07:00
|
|
|
}
|
2004-12-28 15:46:49 -08:00
|
|
|
|
|
|
|
return -1; /* Not found */
|
1999-12-21 00:09:27 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2004-12-28 15:46:49 -08:00
|
|
|
EwinBorderEventsConfigure(EWin * ewin, int mode)
|
1999-12-21 00:09:27 -08:00
|
|
|
{
|
2004-12-28 15:46:49 -08:00
|
|
|
int i;
|
|
|
|
long emask;
|
1999-12-21 00:09:27 -08:00
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
emask = (mode) ? ~((long)0) : ~(EnterWindowMask | LeaveWindowMask);
|
|
|
|
|
|
|
|
for (i = 0; i < ewin->border->num_winparts; i++)
|
2000-07-26 11:00:47 -07:00
|
|
|
{
|
2004-12-28 15:46:49 -08:00
|
|
|
if (ewin->border->part[i].flags & FLAG_TITLE)
|
2005-02-02 09:12:07 -08:00
|
|
|
ESelectInput(ewin->bits[i].win,
|
2004-12-28 15:46:49 -08:00
|
|
|
EWIN_BORDER_TITLE_EVENT_MASK & emask);
|
|
|
|
else
|
2005-02-02 09:12:07 -08:00
|
|
|
ESelectInput(ewin->bits[i].win, EWIN_BORDER_PART_EVENT_MASK & emask);
|
2000-07-26 11:00:47 -07:00
|
|
|
}
|
1999-12-21 00:09:27 -08:00
|
|
|
}
|
1999-08-17 15:56:46 -07:00
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
/*
|
|
|
|
* Border event handlers
|
|
|
|
*/
|
|
|
|
#define DEBUG_BORDER_EVENTS 0
|
|
|
|
|
|
|
|
static void
|
|
|
|
BorderWinpartEventMouseDown(EWinBit * wbit, XEvent * ev)
|
|
|
|
{
|
|
|
|
EWin *ewin = wbit->ewin;
|
|
|
|
int part = wbit - ewin->bits;
|
2004-07-04 14:33:06 -07:00
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
GrabPointerSet(wbit->win, 0, 0);
|
2004-07-04 14:33:06 -07:00
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
wbit->state = STATE_CLICKED;
|
|
|
|
#if DEBUG_BORDER_EVENTS
|
|
|
|
Eprintf("BorderWinpartEventMouseDown %#lx %d\n", wbit->win, wbit->state);
|
|
|
|
#endif
|
|
|
|
BorderWinpartChange(ewin, part, 0);
|
2004-07-04 14:33:06 -07:00
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
if (ewin->border->part[part].aclass)
|
|
|
|
EventAclass(ev, ewin, ewin->border->part[part].aclass);
|
2004-07-04 14:33:06 -07:00
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
FocusHandleClick(ewin, wbit->win);
|
1999-12-21 00:09:27 -08:00
|
|
|
}
|
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
static void
|
|
|
|
BorderWinpartEventMouseUp(EWinBit * wbit, XEvent * ev)
|
1999-12-21 00:09:27 -08:00
|
|
|
{
|
2004-12-28 15:46:49 -08:00
|
|
|
EWin *ewin = wbit->ewin;
|
|
|
|
int part = wbit - ewin->bits;
|
2004-07-04 14:33:06 -07:00
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
GrabPointerRelease();
|
2004-07-04 14:33:06 -07:00
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
if ((wbit->state == STATE_CLICKED) && (!wbit->left))
|
|
|
|
wbit->state = STATE_HILITED;
|
|
|
|
else
|
|
|
|
wbit->state = STATE_NORMAL;
|
|
|
|
#if DEBUG_BORDER_EVENTS
|
|
|
|
Eprintf("BorderWinpartEventMouseUp %#lx %d\n", wbit->win, wbit->state);
|
|
|
|
#endif
|
|
|
|
BorderWinpartChange(ewin, part, 0);
|
2004-07-04 14:33:06 -07:00
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
if (wbit->win == Mode.last_bpress && !wbit->left &&
|
|
|
|
ewin->border->part[part].aclass)
|
|
|
|
EventAclass(ev, ewin, ewin->border->part[part].aclass);
|
2004-07-04 14:33:06 -07:00
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
wbit->left = 0;
|
1999-12-21 00:09:27 -08:00
|
|
|
}
|
2004-01-11 05:20:17 -08:00
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
static void
|
|
|
|
BorderWinpartEventEnter(EWinBit * wbit, XEvent * ev)
|
2004-05-31 13:30:12 -07:00
|
|
|
{
|
2004-12-28 15:46:49 -08:00
|
|
|
EWin *ewin = wbit->ewin;
|
|
|
|
int part = wbit - ewin->bits;
|
2004-05-31 13:30:12 -07:00
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
#if DEBUG_BORDER_EVENTS
|
|
|
|
Eprintf("BorderWinpartEventEnter %#lx %d\n", wbit->win, wbit->state);
|
|
|
|
#endif
|
|
|
|
if (wbit->state == STATE_CLICKED)
|
|
|
|
wbit->left = 0;
|
2005-01-04 15:22:11 -08:00
|
|
|
#if 0 /* Hmmm.. */
|
2004-05-31 13:30:12 -07:00
|
|
|
else
|
2005-01-04 15:22:11 -08:00
|
|
|
#endif
|
2004-05-31 13:30:12 -07:00
|
|
|
{
|
2004-12-28 15:46:49 -08:00
|
|
|
wbit->state = STATE_HILITED;
|
|
|
|
BorderWinpartChange(ewin, part, 0);
|
|
|
|
if (ewin->border->part[part].aclass)
|
|
|
|
EventAclass(ev, ewin, ewin->border->part[part].aclass);
|
2004-05-31 13:30:12 -07:00
|
|
|
}
|
2004-02-28 17:30:18 -08:00
|
|
|
}
|
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
static void
|
|
|
|
BorderWinpartEventLeave(EWinBit * wbit, XEvent * ev)
|
2004-02-28 17:30:18 -08:00
|
|
|
{
|
2004-12-28 15:46:49 -08:00
|
|
|
EWin *ewin = wbit->ewin;
|
|
|
|
int part = wbit - ewin->bits;
|
2004-02-28 17:30:18 -08:00
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
#if DEBUG_BORDER_EVENTS
|
|
|
|
Eprintf("BorderWinpartEventLeave %#lx %d\n", wbit->win, wbit->state);
|
2004-02-28 17:30:18 -08:00
|
|
|
#endif
|
2004-12-28 15:46:49 -08:00
|
|
|
if (wbit->state == STATE_CLICKED)
|
|
|
|
wbit->left = 1;
|
|
|
|
else
|
2004-01-18 05:43:53 -08:00
|
|
|
{
|
2004-12-28 15:46:49 -08:00
|
|
|
wbit->state = STATE_NORMAL;
|
|
|
|
BorderWinpartChange(ewin, part, 0);
|
|
|
|
if (ewin->border->part[part].aclass)
|
|
|
|
EventAclass(ev, ewin, ewin->border->part[part].aclass);
|
2004-01-18 05:43:53 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
#if 0 /* FIXME */
|
|
|
|
/* This was in HandleMouseUp() */
|
2004-09-19 02:27:38 -07:00
|
|
|
|
|
|
|
{
|
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
#if 0
|
|
|
|
if ((Mode.last_bpress) && (Mode.last_bpress != win))
|
2004-09-19 02:27:38 -07:00
|
|
|
{
|
2004-12-28 15:46:49 -08:00
|
|
|
ev->xbutton.window = Mode.last_bpress;
|
|
|
|
BordersEventMouseOut2(ev);
|
|
|
|
ev->xbutton.window = win;
|
2004-09-19 02:27:38 -07:00
|
|
|
}
|
2004-12-28 15:46:49 -08:00
|
|
|
#endif
|
2004-08-31 10:24:40 -07:00
|
|
|
}
|
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
static void
|
|
|
|
BorderWinpartEventLeave2(EWinBit * wbit, XEvent * ev, EWin * ewin, int j)
|
2004-02-28 17:30:18 -08:00
|
|
|
{
|
2004-12-28 15:46:49 -08:00
|
|
|
ewin->bits[j].left = 0;
|
|
|
|
ewin->bits[j].state = STATE_NORMAL;
|
|
|
|
BorderWinpartChange(ewin, j, 0);
|
2004-03-18 09:03:50 -08:00
|
|
|
return;
|
2004-12-28 15:46:49 -08:00
|
|
|
ev = NULL;
|
2004-02-28 17:30:18 -08:00
|
|
|
}
|
2004-12-28 15:46:49 -08:00
|
|
|
#endif
|
2004-02-28 17:30:18 -08:00
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
static void
|
|
|
|
BorderFrameHandleEvents(XEvent * ev, void *prm)
|
2004-02-28 17:30:18 -08:00
|
|
|
{
|
2004-12-28 15:46:49 -08:00
|
|
|
EWin *ewin = (EWin *) prm;
|
2004-02-28 17:30:18 -08:00
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
switch (ev->type)
|
2004-02-28 17:30:18 -08:00
|
|
|
{
|
2004-12-28 15:46:49 -08:00
|
|
|
case EnterNotify:
|
|
|
|
case LeaveNotify:
|
|
|
|
if (ewin->border->aclass)
|
|
|
|
EventAclass(ev, ewin, ewin->border->aclass);
|
|
|
|
break;
|
2004-02-28 17:30:18 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-04-12 06:57:43 -07:00
|
|
|
static void
|
2004-12-28 15:46:49 -08:00
|
|
|
BorderWinpartHandleEvents(XEvent * ev, void *prm)
|
2004-04-12 06:57:43 -07:00
|
|
|
{
|
2004-12-28 15:46:49 -08:00
|
|
|
EWinBit *wbit = (EWinBit *) prm;
|
2004-04-12 06:57:43 -07:00
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
switch (ev->type)
|
2004-04-12 06:57:43 -07:00
|
|
|
{
|
2004-12-28 15:46:49 -08:00
|
|
|
#if 0
|
|
|
|
case KeyPress:
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
case ButtonPress:
|
|
|
|
BorderWinpartEventMouseDown(wbit, ev);
|
|
|
|
break;
|
|
|
|
case ButtonRelease:
|
|
|
|
BorderWinpartEventMouseUp(wbit, ev);
|
|
|
|
break;
|
|
|
|
case EnterNotify:
|
|
|
|
BorderWinpartEventEnter(wbit, ev);
|
|
|
|
break;
|
|
|
|
case LeaveNotify:
|
|
|
|
BorderWinpartEventLeave(wbit, ev);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2004-04-12 06:57:43 -07:00
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
/*
|
|
|
|
* Configuration load/save
|
|
|
|
*/
|
|
|
|
#include "conf.h"
|
2004-04-12 06:57:43 -07:00
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
static int
|
|
|
|
BorderPartLoad(FILE * fs, char type, Border * b)
|
|
|
|
{
|
|
|
|
int err = 0;
|
|
|
|
char s[FILEPATH_LEN_MAX];
|
|
|
|
char s2[FILEPATH_LEN_MAX];
|
|
|
|
int i1;
|
|
|
|
ImageClass *iclass = 0;
|
|
|
|
ActionClass *aclass = 0;
|
|
|
|
TextClass *tclass = 0;
|
|
|
|
ECursor *ec = NULL;
|
|
|
|
char ontop = 1;
|
|
|
|
int flags = FLAG_BUTTON;
|
|
|
|
char isregion = 0, keepshade = 1;
|
|
|
|
int wmin = 0, wmax = 0, hmin = 0, hmax = 0, torigin =
|
|
|
|
0, txp = 0, txa = 0, typ = 0, tya = 0, borigin = 0;
|
|
|
|
int bxp = 0, bxa = 0, byp = 0, bya = 0;
|
|
|
|
int fields;
|
|
|
|
|
|
|
|
type = 0;
|
|
|
|
while (GetLine(s, sizeof(s), fs))
|
|
|
|
{
|
|
|
|
s2[0] = 0;
|
|
|
|
i1 = CONFIG_INVALID;
|
|
|
|
fields = sscanf(s, "%i %4000s", &i1, s2);
|
|
|
|
|
|
|
|
if (fields < 1)
|
2004-04-12 06:57:43 -07:00
|
|
|
{
|
2004-12-28 15:46:49 -08:00
|
|
|
i1 = CONFIG_INVALID;
|
2004-04-12 06:57:43 -07:00
|
|
|
}
|
2004-12-28 15:46:49 -08:00
|
|
|
else if (i1 == CONFIG_CLOSE)
|
2004-04-12 06:57:43 -07:00
|
|
|
{
|
2004-12-28 15:46:49 -08:00
|
|
|
if (fields != 1)
|
|
|
|
Alert(_("CONFIG: ignoring extra data in \"%s\"\n"), s);
|
2004-04-12 06:57:43 -07:00
|
|
|
}
|
2004-12-28 15:46:49 -08:00
|
|
|
else if (i1 != CONFIG_INVALID)
|
2004-09-19 02:27:38 -07:00
|
|
|
{
|
2004-12-28 15:46:49 -08:00
|
|
|
if (fields != 2)
|
|
|
|
{
|
|
|
|
Alert(_("CONFIG: missing required data in \"%s\"\n"), s);
|
|
|
|
i1 = CONFIG_INVALID;
|
|
|
|
}
|
2004-09-19 02:27:38 -07:00
|
|
|
}
|
2004-12-28 15:46:49 -08:00
|
|
|
switch (i1)
|
2004-09-19 02:27:38 -07:00
|
|
|
{
|
2004-12-28 15:46:49 -08:00
|
|
|
case CONFIG_CLOSE:
|
|
|
|
BorderWinpartAdd(b, iclass, aclass, tclass, ec, ontop, flags,
|
|
|
|
isregion, wmin, wmax, hmin, hmax, torigin, txp,
|
|
|
|
txa, typ, tya, borigin, bxp, bxa, byp, bya,
|
|
|
|
keepshade);
|
|
|
|
goto done;
|
|
|
|
case CONFIG_IMAGECLASS:
|
|
|
|
case BORDERPART_ICLASS:
|
|
|
|
iclass = ImageclassFind(s2, 1);
|
|
|
|
break;
|
|
|
|
case CONFIG_ACTIONCLASS:
|
|
|
|
case BORDERPART_ACLASS:
|
|
|
|
aclass = FindItem(s2, 0, LIST_FINDBY_NAME, LIST_TYPE_ACLASS);
|
|
|
|
break;
|
|
|
|
case CONFIG_TEXT:
|
|
|
|
case BORDERPART_TEXTCLASS:
|
|
|
|
tclass = TextclassFind(s2, 1);
|
|
|
|
break;
|
|
|
|
case CONFIG_CURSOR:
|
|
|
|
ec = FindItem(s2, 0, LIST_FINDBY_NAME, LIST_TYPE_ECURSOR);
|
|
|
|
break;
|
|
|
|
case BORDERPART_ONTOP:
|
|
|
|
ontop = atoi(s2);
|
|
|
|
break;
|
|
|
|
case BORDERPART_FLAGS:
|
|
|
|
flags = atoi(s2);
|
|
|
|
break;
|
|
|
|
case BORDERPART_ISREGION:
|
|
|
|
isregion = atoi(s2);
|
|
|
|
break;
|
|
|
|
case BORDERPART_WMIN:
|
|
|
|
wmin = atoi(s2);
|
|
|
|
if (!wmax)
|
|
|
|
wmax = wmin;
|
|
|
|
break;
|
|
|
|
case BORDERPART_WMAX:
|
|
|
|
wmax = atoi(s2);
|
|
|
|
break;
|
|
|
|
case BORDERPART_HMIN:
|
|
|
|
hmin = atoi(s2);
|
|
|
|
if (!hmax)
|
|
|
|
hmax = hmin;
|
|
|
|
break;
|
|
|
|
case BORDERPART_HMAX:
|
|
|
|
hmax = atoi(s2);
|
|
|
|
break;
|
|
|
|
case BORDERPART_TORIGIN:
|
|
|
|
torigin = atoi(s2);
|
|
|
|
break;
|
|
|
|
case BORDERPART_TXP:
|
|
|
|
txp = atoi(s2);
|
|
|
|
break;
|
|
|
|
case BORDERPART_TXA:
|
|
|
|
txa = atoi(s2);
|
|
|
|
break;
|
|
|
|
case BORDERPART_TYP:
|
|
|
|
typ = atoi(s2);
|
|
|
|
break;
|
|
|
|
case BORDERPART_TYA:
|
|
|
|
tya = atoi(s2);
|
|
|
|
break;
|
|
|
|
case BORDERPART_BORIGIN:
|
|
|
|
borigin = atoi(s2);
|
|
|
|
break;
|
|
|
|
case BORDERPART_BXP:
|
|
|
|
bxp = atoi(s2);
|
|
|
|
break;
|
|
|
|
case BORDERPART_BXA:
|
|
|
|
bxa = atoi(s2);
|
|
|
|
break;
|
|
|
|
case BORDERPART_BYP:
|
|
|
|
byp = atoi(s2);
|
|
|
|
break;
|
|
|
|
case BORDERPART_BYA:
|
|
|
|
bya = atoi(s2);
|
|
|
|
break;
|
|
|
|
case BORDERPART_KEEPSHADE:
|
|
|
|
keepshade = atoi(s2);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
2004-09-19 02:27:38 -07:00
|
|
|
}
|
|
|
|
}
|
2004-12-28 15:46:49 -08:00
|
|
|
err = -1;
|
|
|
|
done:
|
|
|
|
return err;
|
2004-01-11 05:20:17 -08:00
|
|
|
}
|
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
int
|
|
|
|
BorderConfigLoad(FILE * fs)
|
2004-01-11 05:20:17 -08:00
|
|
|
{
|
2004-12-28 15:46:49 -08:00
|
|
|
int err = 0;
|
|
|
|
Border *b = 0;
|
|
|
|
char s[FILEPATH_LEN_MAX];
|
|
|
|
char s2[FILEPATH_LEN_MAX];
|
|
|
|
int i1;
|
|
|
|
char added = 0;
|
|
|
|
int fields;
|
2004-01-11 05:20:17 -08:00
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
while (GetLine(s, sizeof(s), fs))
|
2004-01-11 05:20:17 -08:00
|
|
|
{
|
2004-12-28 15:46:49 -08:00
|
|
|
s2[0] = 0;
|
|
|
|
i1 = CONFIG_INVALID;
|
|
|
|
fields = sscanf(s, "%i %4000s", &i1, s2);
|
2004-01-11 05:20:17 -08:00
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
if (fields < 1)
|
2004-01-11 05:20:17 -08:00
|
|
|
{
|
2004-12-28 15:46:49 -08:00
|
|
|
i1 = CONFIG_INVALID;
|
2004-12-04 04:38:18 -08:00
|
|
|
}
|
2004-12-28 15:46:49 -08:00
|
|
|
else if (i1 == CONFIG_CLOSE)
|
2004-12-04 04:38:18 -08:00
|
|
|
{
|
2004-12-28 15:46:49 -08:00
|
|
|
if (fields != 1)
|
|
|
|
Alert(_("CONFIG: ignoring extra data in \"%s\"\n"), s);
|
|
|
|
}
|
|
|
|
else if (i1 != CONFIG_INVALID)
|
|
|
|
{
|
|
|
|
if (fields != 2)
|
|
|
|
{
|
|
|
|
Alert(_("CONFIG: missing required data in \"%s\"\n"), s);
|
|
|
|
i1 = CONFIG_INVALID;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (atoi(s2) == CONFIG_OPEN)
|
|
|
|
{
|
|
|
|
err = BorderPartLoad(fs, i1, b);
|
|
|
|
if (err)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
switch (i1)
|
2004-01-11 05:20:17 -08:00
|
|
|
{
|
2004-12-28 15:46:49 -08:00
|
|
|
case CONFIG_CLOSE:
|
|
|
|
if (!added)
|
|
|
|
AddItem(b, b->name, 0, LIST_TYPE_BORDER);
|
2004-03-20 07:49:05 -08:00
|
|
|
goto done;
|
2004-12-28 15:46:49 -08:00
|
|
|
case BORDER_INIT:
|
|
|
|
AddItem(b, b->name, 0, LIST_TYPE_BORDER);
|
|
|
|
added = 1;
|
|
|
|
break;
|
|
|
|
case CONFIG_CLASSNAME:
|
|
|
|
case BORDER_NAME:
|
|
|
|
if (ConfigSkipIfExists(fs, s2, LIST_TYPE_BORDER))
|
|
|
|
goto done;
|
|
|
|
b = BorderCreate(s2);
|
|
|
|
break;
|
|
|
|
case BORDER_GROUP_NAME:
|
|
|
|
b->group_border_name = Estrdup(s2);
|
|
|
|
break;
|
|
|
|
case BORDER_LEFT:
|
|
|
|
b->border.left = atoi(s2);
|
|
|
|
break;
|
|
|
|
case BORDER_RIGHT:
|
|
|
|
b->border.right = atoi(s2);
|
|
|
|
break;
|
|
|
|
case BORDER_TOP:
|
|
|
|
b->border.top = atoi(s2);
|
|
|
|
break;
|
|
|
|
case BORDER_BOTTOM:
|
|
|
|
b->border.bottom = atoi(s2);
|
|
|
|
break;
|
|
|
|
case SHADEDIR:
|
|
|
|
b->shadedir = atoi(s2);
|
|
|
|
break;
|
|
|
|
case BORDER_CHANGES_SHAPE:
|
|
|
|
b->changes_shape = atoi(s2);
|
|
|
|
break;
|
|
|
|
case CONFIG_ACTIONCLASS:
|
|
|
|
b->aclass =
|
|
|
|
FindItem(s2, 0, LIST_FINDBY_NAME, LIST_TYPE_ACLASS);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
2004-01-11 05:20:17 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2004-12-28 15:46:49 -08:00
|
|
|
err = -1;
|
2004-01-11 05:20:17 -08:00
|
|
|
|
2004-03-20 07:49:05 -08:00
|
|
|
done:
|
2004-12-28 15:46:49 -08:00
|
|
|
return err;
|
2004-01-11 05:20:17 -08:00
|
|
|
}
|
|
|
|
|
2005-01-30 03:02:43 -08:00
|
|
|
Border *
|
|
|
|
BorderCreateFiller(int left, int right, int top, int bottom)
|
|
|
|
{
|
|
|
|
Border *b;
|
|
|
|
ImageClass *ic;
|
|
|
|
|
|
|
|
ic = FindItem("__BLACK", 0, LIST_FINDBY_NAME, LIST_TYPE_ICLASS);
|
|
|
|
|
|
|
|
b = BorderCreate("__FILLER");
|
|
|
|
b->throwaway = 1;
|
|
|
|
|
|
|
|
b->border.left = left;
|
|
|
|
b->border.right = right;
|
|
|
|
b->border.top = top;
|
|
|
|
b->border.bottom = bottom;
|
|
|
|
|
|
|
|
if (top)
|
|
|
|
BorderWinpartAdd(b, ic, NULL, NULL, NULL, 1, FLAG_BUTTON, 0,
|
|
|
|
1, 99999, 1, 99999,
|
|
|
|
-1, 0, 0, 0, 0, -1, 1024, -1, 0, top - 1, 1);
|
|
|
|
if (bottom)
|
|
|
|
BorderWinpartAdd(b, ic, NULL, NULL, NULL, 1, FLAG_BUTTON, 0,
|
|
|
|
1, 99999, 1, 99999,
|
|
|
|
-1, 0, 0, 1024, -bottom, -1, 1024, -1, 1024, -1, 1);
|
|
|
|
if (left)
|
|
|
|
BorderWinpartAdd(b, ic, NULL, NULL, NULL, 1, FLAG_BUTTON, 0,
|
|
|
|
1, 99999, 1, 99999,
|
|
|
|
-1, 0, 0, 0, top,
|
|
|
|
-1, 0, left - 1, 1024, -(bottom + 1), 1);
|
|
|
|
if (right)
|
|
|
|
BorderWinpartAdd(b, ic, NULL, NULL, NULL, 1, FLAG_BUTTON, 0,
|
|
|
|
1, 99999, 1, 99999,
|
|
|
|
-1, 1024, -right, 0, top,
|
|
|
|
-1, 1024, -1, 1024, -(bottom + 1), 1);
|
|
|
|
|
|
|
|
return b;
|
|
|
|
}
|
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
void
|
|
|
|
BordersSetupFallback(void)
|
2004-01-16 07:34:57 -08:00
|
|
|
{
|
2004-12-28 15:46:49 -08:00
|
|
|
/*
|
|
|
|
* This function creates simple internal data members to be used in
|
|
|
|
* emergencies - ie when all else fails - ie a button is told to use an
|
|
|
|
* imageclass that doesn't exist, or no DEFAULT border is defined... at
|
|
|
|
* least E won't barf on us then.
|
|
|
|
*/
|
|
|
|
Border *b;
|
|
|
|
ImageClass *ic;
|
|
|
|
ActionClass *ac;
|
|
|
|
|
|
|
|
ac = FindItem("__FALLBACK_ACTION", 0, LIST_FINDBY_NAME, LIST_TYPE_ACLASS);
|
|
|
|
ic = FindItem("__FALLBACK_ICLASS", 0, LIST_FINDBY_NAME, LIST_TYPE_ICLASS);
|
|
|
|
|
|
|
|
/* create a fallback border in case no border is found */
|
|
|
|
b = BorderCreate("__FALLBACK_BORDER");
|
|
|
|
AddItem(b, b->name, 0, LIST_TYPE_BORDER);
|
|
|
|
|
|
|
|
b->border.left = 8;
|
|
|
|
b->border.right = 8;
|
|
|
|
b->border.top = 8;
|
|
|
|
b->border.bottom = 8;
|
|
|
|
BorderWinpartAdd(b, ic, ac, NULL, NULL, 1, FLAG_BUTTON, 0, 8, 99999, 8,
|
|
|
|
99999, -1, 0, 0, 0, 0, -1, 1024, -1, 0, 7, 1);
|
|
|
|
BorderWinpartAdd(b, ic, ac, NULL, NULL, 1, FLAG_BUTTON, 0, 8, 99999, 8,
|
|
|
|
99999, -1, 0, 0, 1024, -8, -1, 1024, -1, 1024, -1, 1);
|
|
|
|
BorderWinpartAdd(b, ic, ac, NULL, NULL, 1, FLAG_BUTTON, 0, 8, 99999, 8,
|
|
|
|
99999, -1, 0, 0, 0, 8, -1, 0, 7, 1024, -9, 1);
|
|
|
|
BorderWinpartAdd(b, ic, ac, NULL, NULL, 1, FLAG_BUTTON, 0, 8, 99999, 8,
|
|
|
|
99999, -1, 1024, -8, 0, 8, -1, 1024, -1, 1024, -9, 1);
|
2004-01-16 07:34:57 -08:00
|
|
|
}
|