1999-10-04 15:06:00 -07:00
|
|
|
/*
|
2007-01-13 11:14:29 -08:00
|
|
|
* Copyright (C) 2000-2007 Carsten Haitzler, Geoff Harrison and various contributors
|
2008-03-24 02:47:50 -07:00
|
|
|
* Copyright (C) 2004-2008 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-09-04 00:27:20 -07:00
|
|
|
#include "desktops.h"
|
2006-02-18 01:50:17 -08:00
|
|
|
#include "e16-ecore_hints.h"
|
2005-07-16 09:57:45 -07:00
|
|
|
#include "ewins.h"
|
2005-10-27 16:18:35 -07:00
|
|
|
#include "hints.h"
|
2006-04-19 12:13:46 -07:00
|
|
|
#include "session.h"
|
2005-07-16 09:57:45 -07:00
|
|
|
#include "xwin.h"
|
2008-06-05 01:55:21 -07:00
|
|
|
#include <X11/Xutil.h>
|
2006-02-12 11:14:14 -08:00
|
|
|
#if USE_XSYNC
|
2006-08-23 12:06:21 -07:00
|
|
|
#include "timers.h"
|
2006-02-12 11:14:14 -08:00
|
|
|
#include <X11/extensions/sync.h>
|
|
|
|
#endif
|
1999-08-17 15:56:46 -07:00
|
|
|
|
2005-10-30 11:40:49 -08:00
|
|
|
static void ICCCM_SetIconSizes(void);
|
|
|
|
|
2003-06-14 05:03:09 -07:00
|
|
|
void
|
|
|
|
ICCCM_Init(void)
|
|
|
|
{
|
2004-12-28 15:46:49 -08:00
|
|
|
#ifndef USE_ECORE_X
|
|
|
|
ecore_x_icccm_init();
|
|
|
|
#endif
|
|
|
|
|
|
|
|
ICCCM_SetIconSizes();
|
|
|
|
|
2004-06-30 06:04:18 -07:00
|
|
|
if (Mode.wm.window)
|
|
|
|
{
|
2005-10-30 11:40:49 -08:00
|
|
|
Atom wm_props[1];
|
|
|
|
|
|
|
|
wm_props[0] = ECORE_X_ATOM_WM_DELETE_WINDOW;
|
2008-03-24 04:12:40 -07:00
|
|
|
XSetWMProtocols(disp, WinGetXwin(VROOT), wm_props, 1);
|
2004-06-30 06:04:18 -07:00
|
|
|
}
|
2003-06-14 05:03:09 -07:00
|
|
|
}
|
|
|
|
|
2007-04-15 07:54:11 -07:00
|
|
|
int
|
2007-04-15 07:34:46 -07:00
|
|
|
ICCCM_ProcessClientClientMessage(EWin * ewin, XClientMessageEvent * event)
|
2003-06-14 05:03:09 -07:00
|
|
|
{
|
2005-02-12 08:16:29 -08:00
|
|
|
if (event->message_type == ECORE_X_ATOM_WM_CHANGE_STATE)
|
2003-06-14 05:03:09 -07:00
|
|
|
{
|
|
|
|
if (event->data.l[0] == IconicState)
|
|
|
|
{
|
2004-12-28 15:46:49 -08:00
|
|
|
EwinIconify(ewin);
|
2003-06-14 05:03:09 -07:00
|
|
|
}
|
2007-04-15 07:54:11 -07:00
|
|
|
return 1;
|
2003-06-14 05:03:09 -07:00
|
|
|
}
|
2007-04-16 09:48:46 -07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
ICCCM_ProcessRootClientMessage(XClientMessageEvent * event)
|
|
|
|
{
|
|
|
|
Atom a;
|
|
|
|
|
2007-04-15 07:54:11 -07:00
|
|
|
if (event->message_type == ECORE_X_ATOM_WM_PROTOCOLS)
|
2004-06-30 06:04:18 -07:00
|
|
|
{
|
|
|
|
a = event->data.l[0];
|
2007-04-16 09:48:46 -07:00
|
|
|
if (a == ECORE_X_ATOM_WM_DELETE_WINDOW)
|
2005-01-28 23:11:59 -08:00
|
|
|
SessionExit(EEXIT_EXIT, NULL);
|
2007-04-15 07:54:11 -07:00
|
|
|
return 1;
|
2004-06-30 06:04:18 -07:00
|
|
|
}
|
2007-04-15 07:54:11 -07:00
|
|
|
|
|
|
|
return 0;
|
2003-06-14 05:03:09 -07:00
|
|
|
}
|
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
void
|
2007-04-16 09:36:10 -07:00
|
|
|
ICCCM_GetTitle(EWin * ewin)
|
2004-12-28 15:46:49 -08:00
|
|
|
{
|
2006-11-26 04:42:05 -08:00
|
|
|
_EFREE(EwinGetIcccmName(ewin));
|
2004-12-28 15:46:49 -08:00
|
|
|
|
2006-11-26 04:42:05 -08:00
|
|
|
EwinGetIcccmName(ewin) = ecore_x_icccm_title_get(EwinGetClientXwin(ewin));
|
2004-12-28 15:46:49 -08:00
|
|
|
|
2004-02-28 17:30:18 -08:00
|
|
|
EwinChange(ewin, EWIN_CHANGE_NAME);
|
1999-08-17 15:56:46 -07:00
|
|
|
}
|
|
|
|
|
2006-05-21 11:44:18 -07:00
|
|
|
static void
|
1999-08-17 15:56:46 -07:00
|
|
|
ICCCM_GetColormap(EWin * ewin)
|
|
|
|
{
|
|
|
|
XWindowAttributes xwa;
|
|
|
|
|
2005-10-24 10:35:09 -07:00
|
|
|
ewin->client.cmap = None;
|
2006-08-07 13:20:16 -07:00
|
|
|
if (XGetWindowAttributes(disp, EwinGetClientXwin(ewin), &xwa)
|
2005-08-04 09:02:02 -07:00
|
|
|
&& xwa.colormap)
|
2003-12-18 15:43:26 -08:00
|
|
|
ewin->client.cmap = xwa.colormap;
|
1999-08-17 15:56:46 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2005-01-22 03:32:58 -08:00
|
|
|
ICCCM_Delete(const EWin * ewin)
|
1999-08-17 15:56:46 -07:00
|
|
|
{
|
2004-12-28 15:46:49 -08:00
|
|
|
if (EwinIsInternal(ewin))
|
2000-07-26 11:00:47 -07:00
|
|
|
{
|
2006-05-03 13:52:15 -07:00
|
|
|
EwinHide((EWin *) ewin);
|
2004-12-28 15:46:49 -08:00
|
|
|
return;
|
2000-07-26 11:00:47 -07:00
|
|
|
}
|
2003-12-18 15:43:26 -08:00
|
|
|
|
2005-08-01 10:34:53 -07:00
|
|
|
if (ewin->icccm.delete_window)
|
2006-08-07 13:20:16 -07:00
|
|
|
ecore_x_icccm_delete_window_send(EwinGetClientXwin(ewin), CurrentTime);
|
1999-08-17 15:56:46 -07:00
|
|
|
else
|
2006-08-07 13:20:16 -07:00
|
|
|
XKillClient(disp, EwinGetClientXwin(ewin));
|
1999-08-17 15:56:46 -07:00
|
|
|
}
|
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
#if 0 /* Deprecated */
|
1999-08-17 15:56:46 -07:00
|
|
|
void
|
2005-01-22 03:32:58 -08:00
|
|
|
ICCCM_Save(const EWin * ewin)
|
1999-08-17 15:56:46 -07:00
|
|
|
{
|
2004-12-28 15:46:49 -08:00
|
|
|
if (EwinIsInternal(ewin))
|
|
|
|
return;
|
2003-12-18 15:43:26 -08:00
|
|
|
|
2006-08-07 13:20:16 -07:00
|
|
|
ecore_x_icccm_send_save_yourself(EwinGetClientXwin(ewin));
|
1999-08-17 15:56:46 -07:00
|
|
|
}
|
2004-12-28 15:46:49 -08:00
|
|
|
#endif
|
1999-08-17 15:56:46 -07:00
|
|
|
|
|
|
|
void
|
2005-01-22 03:32:58 -08:00
|
|
|
ICCCM_Iconify(const EWin * ewin)
|
1999-08-17 15:56:46 -07:00
|
|
|
{
|
2006-08-07 13:20:16 -07:00
|
|
|
EUnmapWindow(EwinGetClientWin(ewin));
|
|
|
|
ecore_x_icccm_state_set_iconic(EwinGetClientXwin(ewin));
|
1999-08-17 15:56:46 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2005-01-22 03:32:58 -08:00
|
|
|
ICCCM_DeIconify(const EWin * ewin)
|
1999-08-17 15:56:46 -07:00
|
|
|
{
|
2006-08-07 13:20:16 -07:00
|
|
|
EMapWindow(EwinGetClientWin(ewin));
|
|
|
|
ecore_x_icccm_state_set_normal(EwinGetClientXwin(ewin));
|
2004-12-28 15:46:49 -08:00
|
|
|
}
|
2003-12-18 15:43:26 -08:00
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
void
|
2005-01-22 03:32:58 -08:00
|
|
|
ICCCM_Withdraw(const EWin * ewin)
|
2004-12-28 15:46:49 -08:00
|
|
|
{
|
|
|
|
/* We have a choice of deleting the WM_STATE property
|
|
|
|
* or changing the value to Withdrawn. Since twm/fvwm does
|
|
|
|
* it that way, we change it to Withdrawn.
|
|
|
|
*/
|
2006-08-07 13:20:16 -07:00
|
|
|
ecore_x_icccm_state_set_withdrawn(EwinGetClientXwin(ewin));
|
2004-12-28 15:46:49 -08:00
|
|
|
|
2006-08-07 13:20:16 -07:00
|
|
|
XRemoveFromSaveSet(disp, EwinGetClientXwin(ewin));
|
1999-08-17 15:56:46 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2005-01-30 03:02:43 -08:00
|
|
|
ICCCM_SizeMatch(const EWin * ewin, int wi, int hi, int *pwo, int *pho)
|
1999-08-17 15:56:46 -07:00
|
|
|
{
|
|
|
|
int w, h;
|
|
|
|
int i, j;
|
2009-05-28 14:56:48 -07:00
|
|
|
double aspect, dw, dh;
|
1999-08-17 15:56:46 -07:00
|
|
|
|
2005-01-30 03:02:43 -08:00
|
|
|
w = wi;
|
|
|
|
h = hi;
|
1999-08-17 15:56:46 -07:00
|
|
|
|
2008-03-24 02:47:50 -07:00
|
|
|
if (w < ewin->icccm.width_min)
|
|
|
|
w = ewin->icccm.width_min;
|
|
|
|
if (w > ewin->icccm.width_max)
|
|
|
|
w = ewin->icccm.width_max;
|
|
|
|
if (h < ewin->icccm.height_min)
|
|
|
|
h = ewin->icccm.height_min;
|
|
|
|
if (h > ewin->icccm.height_max)
|
|
|
|
h = ewin->icccm.height_max;
|
1999-08-17 15:56:46 -07:00
|
|
|
if ((w > 0) && (h > 0))
|
2000-07-26 11:00:47 -07:00
|
|
|
{
|
2005-10-12 10:20:42 -07:00
|
|
|
w -= ewin->icccm.base_w;
|
|
|
|
h -= ewin->icccm.base_h;
|
2003-05-22 12:15:03 -07:00
|
|
|
if ((w > 0) && (h > 0))
|
|
|
|
{
|
|
|
|
aspect = ((double)w) / ((double)h);
|
2009-05-30 01:07:30 -07:00
|
|
|
dw = ewin->icccm.w_inc / 4.;
|
|
|
|
dh = ewin->icccm.h_inc / 4.;
|
2004-03-20 07:49:05 -08:00
|
|
|
if (Mode.mode == MODE_RESIZE_H)
|
2003-05-22 12:15:03 -07:00
|
|
|
{
|
2005-10-12 10:20:42 -07:00
|
|
|
if (aspect < ewin->icccm.aspect_min)
|
2009-05-28 14:56:48 -07:00
|
|
|
w = (int)((double)h * ewin->icccm.aspect_min + dw);
|
2009-05-12 14:21:26 -07:00
|
|
|
else if (aspect > ewin->icccm.aspect_max)
|
2009-05-28 14:56:48 -07:00
|
|
|
w = (int)((double)h * ewin->icccm.aspect_max + dw);
|
2003-05-22 12:15:03 -07:00
|
|
|
}
|
2004-03-20 07:49:05 -08:00
|
|
|
else if (Mode.mode == MODE_RESIZE_V)
|
2003-05-22 12:15:03 -07:00
|
|
|
{
|
2005-10-12 10:20:42 -07:00
|
|
|
if (aspect < ewin->icccm.aspect_min)
|
2009-05-28 14:56:48 -07:00
|
|
|
h = (int)((double)w / ewin->icccm.aspect_min + dh);
|
2009-05-12 14:21:26 -07:00
|
|
|
else if (aspect > ewin->icccm.aspect_max)
|
2009-05-28 14:56:48 -07:00
|
|
|
h = (int)((double)w / ewin->icccm.aspect_max + dh);
|
2003-05-22 12:15:03 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2005-10-12 10:20:42 -07:00
|
|
|
if (aspect < ewin->icccm.aspect_min)
|
2009-05-12 14:21:26 -07:00
|
|
|
{
|
|
|
|
if (ewin->icccm.aspect_min >= 1.)
|
2009-05-28 14:56:48 -07:00
|
|
|
h = (int)((double)w / ewin->icccm.aspect_min + dh);
|
2009-05-12 14:21:26 -07:00
|
|
|
else
|
2009-05-28 14:56:48 -07:00
|
|
|
w = (int)((double)h * ewin->icccm.aspect_min + dw);
|
2009-05-12 14:21:26 -07:00
|
|
|
}
|
|
|
|
else if (aspect > ewin->icccm.aspect_max)
|
|
|
|
{
|
|
|
|
if (ewin->icccm.aspect_max >= 1.)
|
2009-05-28 14:56:48 -07:00
|
|
|
h = (int)((double)w / ewin->icccm.aspect_max + dh);
|
2009-05-12 14:21:26 -07:00
|
|
|
else
|
2009-05-28 14:56:48 -07:00
|
|
|
w = (int)((double)h * ewin->icccm.aspect_max + dw);
|
2009-05-12 14:21:26 -07:00
|
|
|
}
|
2003-05-22 12:15:03 -07:00
|
|
|
}
|
2006-04-20 10:03:27 -07:00
|
|
|
i = w / ewin->icccm.w_inc;
|
|
|
|
j = h / ewin->icccm.h_inc;
|
2005-10-12 10:20:42 -07:00
|
|
|
w = i * ewin->icccm.w_inc;
|
|
|
|
h = j * ewin->icccm.h_inc;
|
2003-05-22 12:15:03 -07:00
|
|
|
}
|
2005-10-12 10:20:42 -07:00
|
|
|
w += ewin->icccm.base_w;
|
|
|
|
h += ewin->icccm.base_h;
|
2000-07-26 11:00:47 -07:00
|
|
|
}
|
2005-01-30 03:02:43 -08:00
|
|
|
|
|
|
|
*pwo = w;
|
|
|
|
*pho = h;
|
|
|
|
}
|
|
|
|
|
2007-09-05 12:12:56 -07:00
|
|
|
#if 0 /* Unused */
|
2005-01-30 03:02:43 -08:00
|
|
|
void
|
|
|
|
ICCCM_MatchSize(EWin * ewin)
|
|
|
|
{
|
|
|
|
ICCCM_SizeMatch(ewin, ewin->client.w, ewin->client.h, &ewin->client.w,
|
|
|
|
&ewin->client.h);
|
1999-08-17 15:56:46 -07:00
|
|
|
}
|
2007-09-05 12:12:56 -07:00
|
|
|
#endif
|
1999-08-17 15:56:46 -07:00
|
|
|
|
2005-10-12 10:20:42 -07:00
|
|
|
void
|
|
|
|
ICCCM_GetIncrementalSize(EWin * ewin, unsigned int w, unsigned int h,
|
|
|
|
unsigned int *wi, unsigned int *hi)
|
|
|
|
{
|
|
|
|
*wi = (w - ewin->icccm.base_w) / ewin->icccm.w_inc;
|
|
|
|
*hi = (h - ewin->icccm.base_h) / ewin->icccm.h_inc;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ICCCM_SetSizeConstraints(EWin * ewin, unsigned int wmin, unsigned int hmin,
|
|
|
|
unsigned int wmax, unsigned int hmax,
|
|
|
|
unsigned int wbase, unsigned int hbase,
|
|
|
|
unsigned int winc, unsigned int hinc,
|
|
|
|
double amin, double amax)
|
|
|
|
{
|
2008-03-24 02:47:50 -07:00
|
|
|
ewin->icccm.width_min = wmin;
|
|
|
|
ewin->icccm.height_min = hmin;
|
|
|
|
ewin->icccm.width_max = wmax;
|
|
|
|
ewin->icccm.height_max = hmax;
|
2005-10-12 10:20:42 -07:00
|
|
|
|
|
|
|
ewin->icccm.base_w = wbase;
|
|
|
|
ewin->icccm.base_h = hbase;
|
|
|
|
ewin->icccm.w_inc = winc;
|
|
|
|
ewin->icccm.h_inc = hinc;
|
|
|
|
|
|
|
|
ewin->icccm.aspect_min = amin;
|
|
|
|
ewin->icccm.aspect_max = amax;
|
|
|
|
|
|
|
|
ewin->props.no_resize_h = (wmin == wmax);
|
|
|
|
ewin->props.no_resize_v = (hmin == hmax);
|
|
|
|
}
|
|
|
|
|
1999-08-17 15:56:46 -07:00
|
|
|
void
|
2006-02-12 11:14:14 -08:00
|
|
|
ICCCM_Configure(EWin * ewin)
|
1999-08-17 15:56:46 -07:00
|
|
|
{
|
|
|
|
XEvent ev;
|
2004-06-30 06:04:18 -07:00
|
|
|
Window child;
|
1999-08-17 15:56:46 -07:00
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
if (EwinIsInternal(ewin))
|
2005-01-22 03:32:58 -08:00
|
|
|
return;
|
2003-12-18 15:43:26 -08:00
|
|
|
|
1999-08-17 15:56:46 -07:00
|
|
|
ev.type = ConfigureNotify;
|
|
|
|
ev.xconfigure.display = disp;
|
2006-08-07 13:20:16 -07:00
|
|
|
ev.xconfigure.event = EwinGetClientXwin(ewin);
|
|
|
|
ev.xconfigure.window = EwinGetClientXwin(ewin);
|
2005-10-18 11:00:53 -07:00
|
|
|
#if 0 /* FIXME - Remove? */
|
|
|
|
Desk *dsk;
|
|
|
|
|
2005-09-04 00:27:20 -07:00
|
|
|
dsk = EoGetDesk(ewin);
|
|
|
|
ev.xconfigure.x = EoGetX(dsk) + ewin->client.x;
|
|
|
|
ev.xconfigure.y = EoGetY(dsk) + ewin->client.y;
|
2005-10-18 11:00:53 -07:00
|
|
|
#else
|
|
|
|
ev.xconfigure.x = ewin->client.x;
|
|
|
|
ev.xconfigure.y = ewin->client.y;
|
|
|
|
#endif
|
2004-06-30 06:04:18 -07:00
|
|
|
if (Mode.wm.window)
|
2008-03-24 04:12:40 -07:00
|
|
|
ETranslateCoordinates(VROOT, RROOT,
|
2004-06-30 06:04:18 -07:00
|
|
|
ev.xconfigure.x, ev.xconfigure.y,
|
|
|
|
&ev.xconfigure.x, &ev.xconfigure.y, &child);
|
1999-08-17 15:56:46 -07:00
|
|
|
ev.xconfigure.width = ewin->client.w;
|
|
|
|
ev.xconfigure.height = ewin->client.h;
|
|
|
|
ev.xconfigure.border_width = 0;
|
2006-04-18 09:26:51 -07:00
|
|
|
ev.xconfigure.above = EoGetXwin(ewin);
|
1999-08-17 15:56:46 -07:00
|
|
|
ev.xconfigure.override_redirect = False;
|
2008-03-30 05:13:16 -07:00
|
|
|
EXSendEvent(EwinGetClientXwin(ewin), StructureNotifyMask, &ev);
|
1999-08-17 15:56:46 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2005-01-22 03:32:58 -08:00
|
|
|
ICCCM_AdoptStart(const EWin * ewin)
|
1999-08-17 15:56:46 -07:00
|
|
|
{
|
2006-08-07 13:20:16 -07:00
|
|
|
Window win = EwinGetClientXwin(ewin);
|
2003-07-12 01:22:58 -07:00
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
if (!EwinIsInternal(ewin))
|
2003-07-12 01:22:58 -07:00
|
|
|
XAddToSaveSet(disp, win);
|
1999-08-17 15:56:46 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2005-01-22 03:32:58 -08:00
|
|
|
ICCCM_Adopt(const EWin * ewin)
|
1999-08-17 15:56:46 -07:00
|
|
|
{
|
2006-08-07 13:20:16 -07:00
|
|
|
Window win = EwinGetClientXwin(ewin);
|
2003-12-18 15:43:26 -08:00
|
|
|
|
2005-08-01 10:34:53 -07:00
|
|
|
if (ewin->icccm.start_iconified)
|
2004-12-28 15:46:49 -08:00
|
|
|
ecore_x_icccm_state_set_iconic(win);
|
|
|
|
else
|
|
|
|
ecore_x_icccm_state_set_normal(win);
|
1999-08-17 15:56:46 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ICCCM_Cmap(EWin * ewin)
|
|
|
|
{
|
|
|
|
if (!ewin)
|
2000-07-26 11:00:47 -07:00
|
|
|
{
|
2004-03-20 07:49:05 -08:00
|
|
|
if (Mode.current_cmap)
|
2003-05-22 12:15:03 -07:00
|
|
|
{
|
2004-03-20 07:49:05 -08:00
|
|
|
XUninstallColormap(disp, Mode.current_cmap);
|
|
|
|
Mode.current_cmap = 0;
|
2003-05-22 12:15:03 -07:00
|
|
|
}
|
2005-01-22 03:32:58 -08:00
|
|
|
return;
|
2000-07-26 11:00:47 -07:00
|
|
|
}
|
2003-12-18 15:43:26 -08:00
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
if (EwinIsInternal(ewin))
|
2005-01-22 03:32:58 -08:00
|
|
|
return;
|
1999-10-20 08:55:01 -07:00
|
|
|
|
2005-10-24 10:35:09 -07:00
|
|
|
ICCCM_GetColormap(ewin);
|
|
|
|
|
2004-03-20 07:49:05 -08:00
|
|
|
if ((ewin->client.cmap) && (Mode.current_cmap != ewin->client.cmap))
|
2000-07-26 11:00:47 -07:00
|
|
|
{
|
2005-02-12 08:16:29 -08:00
|
|
|
XWindowAttributes xwa;
|
|
|
|
int i, num;
|
|
|
|
Ecore_X_Window *wlist;
|
|
|
|
|
2006-08-07 13:20:16 -07:00
|
|
|
num = ecore_x_window_prop_window_list_get(EwinGetClientXwin(ewin),
|
2005-02-12 08:16:29 -08:00
|
|
|
ECORE_X_ATOM_WM_COLORMAP_WINDOWS,
|
|
|
|
&wlist);
|
|
|
|
if (num > 0)
|
2003-05-22 12:15:03 -07:00
|
|
|
{
|
|
|
|
for (i = 0; i < num; i++)
|
|
|
|
{
|
|
|
|
if (XGetWindowAttributes(disp, wlist[i], &xwa))
|
|
|
|
{
|
2008-03-29 10:18:58 -07:00
|
|
|
if (xwa.colormap != WinGetCmap(VROOT))
|
2003-05-22 12:15:03 -07:00
|
|
|
{
|
|
|
|
XInstallColormap(disp, xwa.colormap);
|
2004-03-20 07:49:05 -08:00
|
|
|
Mode.current_cmap = xwa.colormap;
|
2003-05-22 12:15:03 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Efree(wlist);
|
2005-01-22 03:32:58 -08:00
|
|
|
return;
|
2003-05-22 12:15:03 -07:00
|
|
|
}
|
|
|
|
XInstallColormap(disp, ewin->client.cmap);
|
2004-03-20 07:49:05 -08:00
|
|
|
Mode.current_cmap = ewin->client.cmap;
|
2000-07-26 11:00:47 -07:00
|
|
|
}
|
1999-08-17 15:56:46 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2005-01-22 03:32:58 -08:00
|
|
|
ICCCM_Focus(const EWin * ewin)
|
1999-08-17 15:56:46 -07:00
|
|
|
{
|
2006-11-19 13:55:52 -08:00
|
|
|
if (EDebug(EDBUG_TYPE_FOCUS))
|
2004-07-15 16:31:02 -07:00
|
|
|
{
|
|
|
|
if (ewin)
|
2005-08-15 10:15:19 -07:00
|
|
|
Eprintf("ICCCM_Focus T=%#lx %#lx %s\n", Mode.events.time,
|
2006-11-26 03:30:59 -08:00
|
|
|
EwinGetClientXwin(ewin), EwinGetTitle(ewin));
|
2004-07-15 16:31:02 -07:00
|
|
|
else
|
2005-08-15 10:15:19 -07:00
|
|
|
Eprintf("ICCCM_Focus None T=%#lx\n", Mode.events.time);
|
2004-07-15 16:31:02 -07:00
|
|
|
}
|
|
|
|
|
1999-08-17 15:56:46 -07:00
|
|
|
if (!ewin)
|
2000-07-26 11:00:47 -07:00
|
|
|
{
|
2008-03-24 04:12:40 -07:00
|
|
|
XSetInputFocus(disp, WinGetXwin(VROOT), RevertToPointerRoot,
|
|
|
|
Mode.events.time);
|
2004-05-22 12:31:13 -07:00
|
|
|
HintsSetActiveWindow(None);
|
2005-01-22 03:32:58 -08:00
|
|
|
return;
|
2000-07-26 11:00:47 -07:00
|
|
|
}
|
2003-12-18 15:43:26 -08:00
|
|
|
|
2005-08-01 10:34:53 -07:00
|
|
|
if (ewin->icccm.take_focus)
|
2004-07-15 16:31:02 -07:00
|
|
|
{
|
2006-08-07 13:20:16 -07:00
|
|
|
ecore_x_icccm_take_focus_send(EwinGetClientXwin(ewin),
|
2005-08-15 10:15:19 -07:00
|
|
|
Mode.events.time);
|
2004-07-15 16:31:02 -07:00
|
|
|
}
|
|
|
|
|
2006-08-07 13:20:16 -07:00
|
|
|
XSetInputFocus(disp, EwinGetClientXwin(ewin), RevertToPointerRoot,
|
2005-08-15 10:15:19 -07:00
|
|
|
Mode.events.time);
|
2004-07-15 16:31:02 -07:00
|
|
|
|
2006-08-07 13:20:16 -07:00
|
|
|
HintsSetActiveWindow(EwinGetClientXwin(ewin));
|
1999-08-17 15:56:46 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2007-04-16 09:36:10 -07:00
|
|
|
ICCCM_GetGeoms(EWin * ewin)
|
1999-08-17 15:56:46 -07:00
|
|
|
{
|
|
|
|
XSizeHints hint;
|
|
|
|
long mask;
|
|
|
|
|
2006-08-07 13:20:16 -07:00
|
|
|
if (XGetWMNormalHints(disp, EwinGetClientXwin(ewin), &hint, &mask))
|
2000-07-26 11:00:47 -07:00
|
|
|
{
|
2005-07-08 09:48:19 -07:00
|
|
|
if (!(ewin->state.placed))
|
2003-05-22 12:15:03 -07:00
|
|
|
{
|
|
|
|
if ((hint.flags & USPosition) || ((hint.flags & PPosition)))
|
|
|
|
{
|
2004-12-28 15:46:49 -08:00
|
|
|
if ((hint.flags & PPosition) && (!EoIsSticky(ewin)))
|
2003-05-22 12:15:03 -07:00
|
|
|
{
|
2005-09-04 00:27:20 -07:00
|
|
|
Desk *dsk;
|
2003-05-22 12:15:03 -07:00
|
|
|
|
2004-12-28 15:46:49 -08:00
|
|
|
dsk = EoGetDesk(ewin);
|
2005-09-04 00:27:20 -07:00
|
|
|
if (!dsk)
|
2004-12-28 15:46:49 -08:00
|
|
|
dsk = DesksGetCurrent();
|
2005-09-04 00:27:20 -07:00
|
|
|
ewin->client.x -= EoGetX(dsk);
|
|
|
|
ewin->client.y -= EoGetY(dsk);
|
2008-03-24 04:12:40 -07:00
|
|
|
if (ewin->client.x + ewin->client.w >= WinGetW(VROOT))
|
2003-05-22 12:15:03 -07:00
|
|
|
{
|
2005-09-04 00:27:20 -07:00
|
|
|
ewin->client.x += EoGetX(dsk);
|
2003-05-22 12:15:03 -07:00
|
|
|
}
|
|
|
|
else if (ewin->client.x < 0)
|
|
|
|
{
|
2005-09-04 00:27:20 -07:00
|
|
|
ewin->client.x += EoGetX(dsk);
|
2003-05-22 12:15:03 -07:00
|
|
|
}
|
2008-03-24 04:12:40 -07:00
|
|
|
if (ewin->client.y + ewin->client.h >= WinGetH(VROOT))
|
2003-05-22 12:15:03 -07:00
|
|
|
{
|
2005-09-04 00:27:20 -07:00
|
|
|
ewin->client.y += EoGetY(dsk);
|
2003-05-22 12:15:03 -07:00
|
|
|
}
|
|
|
|
else if (ewin->client.y < 0)
|
|
|
|
{
|
2005-09-04 00:27:20 -07:00
|
|
|
ewin->client.y += EoGetY(dsk);
|
2003-05-22 12:15:03 -07:00
|
|
|
}
|
|
|
|
}
|
2005-07-08 09:48:19 -07:00
|
|
|
ewin->state.placed = 1;
|
2003-05-22 12:15:03 -07:00
|
|
|
}
|
|
|
|
}
|
2004-06-18 13:12:10 -07:00
|
|
|
|
2003-05-22 12:15:03 -07:00
|
|
|
if (hint.flags & PMinSize)
|
|
|
|
{
|
2008-03-24 02:47:50 -07:00
|
|
|
ewin->icccm.width_min = MAX(0, hint.min_width);
|
|
|
|
ewin->icccm.height_min = MAX(0, hint.min_height);
|
2003-05-22 12:15:03 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2008-03-24 02:47:50 -07:00
|
|
|
ewin->icccm.width_min = 0;
|
|
|
|
ewin->icccm.height_min = 0;
|
2003-05-22 12:15:03 -07:00
|
|
|
}
|
2004-06-18 13:12:10 -07:00
|
|
|
|
2003-05-22 12:15:03 -07:00
|
|
|
if (hint.flags & PMaxSize)
|
|
|
|
{
|
2008-03-24 02:47:50 -07:00
|
|
|
ewin->icccm.width_max = MIN(hint.max_width, 65535);
|
|
|
|
ewin->icccm.height_max = MIN(hint.max_height, 65535);
|
2003-05-22 12:15:03 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2008-03-24 02:47:50 -07:00
|
|
|
ewin->icccm.width_max = 65535;
|
|
|
|
ewin->icccm.height_max = 65535;
|
2003-05-22 12:15:03 -07:00
|
|
|
}
|
2004-06-18 13:12:10 -07:00
|
|
|
|
2003-05-22 12:15:03 -07:00
|
|
|
if (hint.flags & PResizeInc)
|
|
|
|
{
|
2005-10-12 10:20:42 -07:00
|
|
|
ewin->icccm.w_inc = MAX(1, hint.width_inc);
|
|
|
|
ewin->icccm.h_inc = MAX(1, hint.height_inc);
|
2003-05-22 12:15:03 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2005-10-12 10:20:42 -07:00
|
|
|
ewin->icccm.w_inc = 1;
|
|
|
|
ewin->icccm.h_inc = 1;
|
2003-05-22 12:15:03 -07:00
|
|
|
}
|
2004-06-18 13:12:10 -07:00
|
|
|
|
2003-05-22 12:15:03 -07:00
|
|
|
if (hint.flags & PAspect)
|
|
|
|
{
|
|
|
|
if ((hint.min_aspect.y > 0.0) && (hint.min_aspect.x > 0.0))
|
|
|
|
{
|
2005-10-12 10:20:42 -07:00
|
|
|
ewin->icccm.aspect_min =
|
2003-05-22 12:15:03 -07:00
|
|
|
((double)hint.min_aspect.x) / ((double)hint.min_aspect.y);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2005-10-12 10:20:42 -07:00
|
|
|
ewin->icccm.aspect_min = 0.0;
|
2003-05-22 12:15:03 -07:00
|
|
|
}
|
|
|
|
if ((hint.max_aspect.y > 0.0) && (hint.max_aspect.x > 0.0))
|
|
|
|
{
|
2005-10-12 10:20:42 -07:00
|
|
|
ewin->icccm.aspect_max =
|
2003-05-22 12:15:03 -07:00
|
|
|
((double)hint.max_aspect.x) / ((double)hint.max_aspect.y);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2005-10-12 10:20:42 -07:00
|
|
|
ewin->icccm.aspect_max = 65535.0;
|
2003-05-22 12:15:03 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2005-10-12 10:20:42 -07:00
|
|
|
ewin->icccm.aspect_min = 0.0;
|
|
|
|
ewin->icccm.aspect_max = 65535.0;
|
2003-05-22 12:15:03 -07:00
|
|
|
}
|
2004-06-18 13:12:10 -07:00
|
|
|
|
2003-05-22 12:15:03 -07:00
|
|
|
if (hint.flags & PBaseSize)
|
|
|
|
{
|
2005-10-12 10:20:42 -07:00
|
|
|
ewin->icccm.base_w = hint.base_width;
|
|
|
|
ewin->icccm.base_h = hint.base_height;
|
2003-05-22 12:15:03 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2008-03-24 02:47:50 -07:00
|
|
|
ewin->icccm.base_w = ewin->icccm.width_min;
|
|
|
|
ewin->icccm.base_h = ewin->icccm.height_min;
|
2003-05-22 12:15:03 -07:00
|
|
|
}
|
2004-06-18 13:12:10 -07:00
|
|
|
|
2008-03-24 02:47:50 -07:00
|
|
|
if (ewin->icccm.width_min < ewin->icccm.base_w)
|
|
|
|
ewin->icccm.width_min = ewin->icccm.base_w;
|
|
|
|
if (ewin->icccm.height_min < ewin->icccm.base_h)
|
|
|
|
ewin->icccm.height_min = ewin->icccm.base_h;
|
2006-08-08 19:45:02 -07:00
|
|
|
|
2008-03-24 02:47:50 -07:00
|
|
|
if (ewin->icccm.width_max < ewin->icccm.base_w)
|
|
|
|
ewin->icccm.width_max = ewin->icccm.base_w;
|
|
|
|
if (ewin->icccm.height_max < ewin->icccm.base_h)
|
|
|
|
ewin->icccm.height_max = ewin->icccm.base_h;
|
2008-07-11 12:38:18 -07:00
|
|
|
|
|
|
|
if (hint.flags & PWinGravity)
|
|
|
|
ewin->icccm.grav = hint.win_gravity;
|
|
|
|
else
|
|
|
|
ewin->icccm.grav = NorthWestGravity;
|
2000-07-26 11:00:47 -07:00
|
|
|
}
|
2004-06-18 13:12:10 -07:00
|
|
|
|
2008-03-24 02:47:50 -07:00
|
|
|
ewin->props.no_resize_h = (ewin->icccm.width_min == ewin->icccm.width_max);
|
|
|
|
ewin->props.no_resize_v = (ewin->icccm.height_min == ewin->icccm.height_max);
|
2003-12-18 15:43:26 -08:00
|
|
|
|
2006-11-19 13:55:52 -08:00
|
|
|
if (EDebug(EDBUG_TYPE_SNAPS))
|
2004-06-18 13:12:10 -07:00
|
|
|
Eprintf("Snap get icccm %#lx: %4d+%4d %4dx%4d: %s\n",
|
2006-08-07 13:20:16 -07:00
|
|
|
EwinGetClientXwin(ewin), ewin->client.x, ewin->client.y,
|
2006-11-26 03:30:59 -08:00
|
|
|
ewin->client.w, ewin->client.h, EwinGetTitle(ewin));
|
1999-08-17 15:56:46 -07:00
|
|
|
}
|
|
|
|
|
2006-08-07 13:20:16 -07:00
|
|
|
#define TryGroup(e) (((e)->icccm.group != None) && ((e)->icccm.group != EwinGetClientXwin(e)))
|
2005-03-06 03:40:56 -08:00
|
|
|
|
2007-04-16 09:36:10 -07:00
|
|
|
static void
|
|
|
|
ICCCM_GetWmClass(EWin * ewin)
|
1999-08-17 15:56:46 -07:00
|
|
|
{
|
2007-04-16 09:36:10 -07:00
|
|
|
_EFREE(EwinGetIcccmCName(ewin));
|
|
|
|
_EFREE(EwinGetIcccmClass(ewin));
|
|
|
|
|
|
|
|
ecore_x_icccm_name_class_get(EwinGetClientXwin(ewin),
|
|
|
|
&EwinGetIcccmCName(ewin),
|
|
|
|
&EwinGetIcccmClass(ewin));
|
|
|
|
if (!EwinGetIcccmCName(ewin) && TryGroup(ewin))
|
|
|
|
ecore_x_icccm_name_class_get(ewin->icccm.group,
|
|
|
|
&EwinGetIcccmCName(ewin),
|
|
|
|
&EwinGetIcccmClass(ewin));
|
|
|
|
}
|
2005-03-12 07:22:08 -08:00
|
|
|
|
2007-04-16 09:36:10 -07:00
|
|
|
static void
|
|
|
|
ICCCM_GetWmCommand(EWin * ewin)
|
|
|
|
{
|
|
|
|
int argc;
|
|
|
|
char **argv, s[4096], *ss;
|
2005-03-12 03:09:33 -08:00
|
|
|
|
2007-04-16 09:36:10 -07:00
|
|
|
_EFREE(ewin->icccm.wm_command);
|
2000-07-26 11:00:47 -07:00
|
|
|
|
2007-04-16 09:36:10 -07:00
|
|
|
argc = ecore_x_window_prop_string_list_get(EwinGetClientXwin(ewin),
|
|
|
|
ECORE_X_ATOM_WM_COMMAND, &argv);
|
|
|
|
if ((argc < 0) && TryGroup(ewin))
|
|
|
|
argc = ecore_x_window_prop_string_list_get(ewin->icccm.group,
|
|
|
|
ECORE_X_ATOM_WM_COMMAND,
|
|
|
|
&argv);
|
2004-02-28 17:30:18 -08:00
|
|
|
|
2007-04-16 09:36:10 -07:00
|
|
|
ss = StrlistEncodeEscaped(s, sizeof(s), argv, argc);
|
|
|
|
ewin->icccm.wm_command = Estrdup(ss);
|
|
|
|
StrlistFree(argv, argc);
|
|
|
|
}
|
2000-07-26 11:00:47 -07:00
|
|
|
|
2007-04-16 09:36:10 -07:00
|
|
|
static void
|
|
|
|
ICCCM_GetWmClientMachine(EWin * ewin)
|
|
|
|
{
|
|
|
|
_EFREE(ewin->icccm.wm_machine);
|
|
|
|
|
|
|
|
ewin->icccm.wm_machine =
|
|
|
|
ecore_x_window_prop_string_get(EwinGetClientXwin(ewin),
|
|
|
|
ECORE_X_ATOM_WM_CLIENT_MACHINE);
|
|
|
|
if (!ewin->icccm.wm_machine && TryGroup(ewin))
|
|
|
|
ewin->icccm.wm_machine =
|
|
|
|
ecore_x_window_prop_string_get(ewin->icccm.group,
|
|
|
|
ECORE_X_ATOM_WM_CLIENT_MACHINE);
|
|
|
|
}
|
2003-05-22 12:15:03 -07:00
|
|
|
|
2007-04-16 09:36:10 -07:00
|
|
|
static void
|
|
|
|
ICCCM_GetWmIconName(EWin * ewin)
|
|
|
|
{
|
|
|
|
_EFREE(ewin->icccm.wm_icon_name);
|
|
|
|
|
|
|
|
ewin->icccm.wm_icon_name =
|
|
|
|
ecore_x_window_prop_string_get(EwinGetClientXwin(ewin),
|
|
|
|
ECORE_X_ATOM_WM_ICON_NAME);
|
|
|
|
if (!ewin->icccm.wm_icon_name && TryGroup(ewin))
|
|
|
|
ewin->icccm.wm_icon_name =
|
|
|
|
ecore_x_window_prop_string_get(ewin->icccm.group,
|
|
|
|
ECORE_X_ATOM_WM_ICON_NAME);
|
|
|
|
}
|
2000-07-26 11:00:47 -07:00
|
|
|
|
2007-04-16 09:36:10 -07:00
|
|
|
static void
|
|
|
|
ICCCM_GetWmWindowRole(EWin * ewin)
|
|
|
|
{
|
|
|
|
_EFREE(ewin->icccm.wm_role);
|
|
|
|
ewin->icccm.wm_role =
|
|
|
|
ecore_x_window_prop_string_get(EwinGetClientXwin(ewin),
|
|
|
|
ECORE_X_ATOM_WM_WINDOW_ROLE);
|
1999-08-17 15:56:46 -07:00
|
|
|
}
|
2000-02-28 10:08:25 -08:00
|
|
|
|
1999-08-17 15:56:46 -07:00
|
|
|
void
|
2007-04-16 09:36:10 -07:00
|
|
|
ICCCM_GetInfo(EWin * ewin)
|
|
|
|
{
|
|
|
|
ICCCM_GetWmClass(ewin);
|
|
|
|
ICCCM_GetWmCommand(ewin);
|
|
|
|
ICCCM_GetWmClientMachine(ewin);
|
|
|
|
ICCCM_GetWmIconName(ewin);
|
|
|
|
ICCCM_GetWmWindowRole(ewin);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
ICCCM_GetWmHints(EWin * ewin)
|
1999-08-17 15:56:46 -07:00
|
|
|
{
|
2003-12-18 15:43:26 -08:00
|
|
|
XWMHints *hint;
|
1999-08-17 15:56:46 -07:00
|
|
|
|
2007-04-16 09:36:10 -07:00
|
|
|
hint = XGetWMHints(disp, EwinGetClientXwin(ewin));
|
|
|
|
if (!hint)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* I have to make sure the thing i'm docking is a dock app */
|
|
|
|
if ((hint->flags & StateHint) && (hint->initial_state == WithdrawnState))
|
2000-07-26 11:00:47 -07:00
|
|
|
{
|
2007-04-16 09:36:10 -07:00
|
|
|
if (hint->flags & (StateHint | IconWindowHint | IconPositionHint |
|
|
|
|
WindowGroupHint))
|
2003-05-22 12:15:03 -07:00
|
|
|
{
|
2007-04-16 09:36:10 -07:00
|
|
|
if ((hint->icon_x == 0) && (hint->icon_y == 0)
|
|
|
|
&& hint->window_group == EwinGetClientXwin(ewin))
|
|
|
|
ewin->state.docked = 1;
|
2003-05-22 12:15:03 -07:00
|
|
|
}
|
2007-04-16 09:36:10 -07:00
|
|
|
}
|
2003-12-18 15:43:26 -08:00
|
|
|
|
2007-04-16 09:36:10 -07:00
|
|
|
ewin->icccm.need_input =
|
|
|
|
((hint->flags & InputHint) && (!hint->input)) ? 0 : 1;
|
2005-06-02 15:11:09 -07:00
|
|
|
|
2007-04-16 09:36:10 -07:00
|
|
|
ewin->icccm.start_iconified =
|
|
|
|
((hint->flags & StateHint) &&
|
|
|
|
(hint->initial_state == IconicState)) ? 1 : 0;
|
2003-12-18 15:43:26 -08:00
|
|
|
|
2007-04-16 09:36:10 -07:00
|
|
|
if (hint->flags & IconPixmapHint)
|
|
|
|
{
|
|
|
|
if (ewin->icccm.icon_pmap != hint->icon_pixmap)
|
2003-05-22 12:15:03 -07:00
|
|
|
{
|
2007-04-16 09:36:10 -07:00
|
|
|
ewin->icccm.icon_pmap = hint->icon_pixmap;
|
|
|
|
EwinChange(ewin, EWIN_CHANGE_ICON_PMAP);
|
2003-05-22 12:15:03 -07:00
|
|
|
}
|
2007-04-16 09:36:10 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ewin->icccm.icon_pmap = None;
|
|
|
|
}
|
2003-12-18 15:43:26 -08:00
|
|
|
|
2007-04-16 09:36:10 -07:00
|
|
|
ewin->icccm.icon_mask =
|
|
|
|
(hint->flags & IconMaskHint) ? hint->icon_mask : None;
|
2003-12-18 15:43:26 -08:00
|
|
|
|
2007-04-16 09:36:10 -07:00
|
|
|
ewin->icccm.icon_win =
|
|
|
|
(hint->flags & IconWindowHint) ? hint->icon_window : None;
|
2003-12-18 15:43:26 -08:00
|
|
|
|
2007-04-16 09:36:10 -07:00
|
|
|
ewin->icccm.group =
|
|
|
|
(hint->flags & WindowGroupHint) ? hint->window_group : None;
|
2000-07-26 11:00:47 -07:00
|
|
|
|
2007-04-16 09:36:10 -07:00
|
|
|
if (hint->flags & XUrgencyHint)
|
2000-07-26 11:00:47 -07:00
|
|
|
{
|
2007-04-16 09:36:10 -07:00
|
|
|
if (!ewin->state.attention)
|
|
|
|
EwinChange(ewin, EWIN_CHANGE_ATTENTION);
|
|
|
|
ewin->icccm.urgency = 1;
|
|
|
|
ewin->state.attention = 1;
|
2000-07-26 11:00:47 -07:00
|
|
|
}
|
2007-04-16 09:36:10 -07:00
|
|
|
else
|
2000-07-26 11:00:47 -07:00
|
|
|
{
|
2007-04-16 09:36:10 -07:00
|
|
|
ewin->icccm.urgency = 0;
|
2000-07-26 11:00:47 -07:00
|
|
|
}
|
2003-12-18 15:43:26 -08:00
|
|
|
|
2006-08-07 13:20:16 -07:00
|
|
|
if (ewin->icccm.group == EwinGetClientXwin(ewin))
|
2000-07-26 11:00:47 -07:00
|
|
|
{
|
2005-08-01 10:34:53 -07:00
|
|
|
ewin->icccm.is_group_leader = 1;
|
2000-07-26 11:00:47 -07:00
|
|
|
}
|
1999-08-17 15:56:46 -07:00
|
|
|
else
|
2000-07-26 11:00:47 -07:00
|
|
|
{
|
2005-08-01 10:34:53 -07:00
|
|
|
ewin->icccm.is_group_leader = 0;
|
2000-07-26 11:00:47 -07:00
|
|
|
}
|
|
|
|
|
2007-04-16 09:36:10 -07:00
|
|
|
XFree(hint);
|
|
|
|
}
|
2005-02-12 08:16:29 -08:00
|
|
|
|
2007-04-16 09:36:10 -07:00
|
|
|
static void
|
|
|
|
ICCCM_GetWmProtocols(EWin * ewin)
|
|
|
|
{
|
|
|
|
Atom *prop;
|
|
|
|
int i, num;
|
|
|
|
|
|
|
|
if (XGetWMProtocols(disp, EwinGetClientXwin(ewin), &prop, &num))
|
|
|
|
{
|
|
|
|
ewin->icccm.take_focus = 0;
|
|
|
|
ewin->icccm.delete_window = 0;
|
|
|
|
for (i = 0; i < num; i++)
|
2003-05-22 12:15:03 -07:00
|
|
|
{
|
2007-04-16 09:36:10 -07:00
|
|
|
if (prop[i] == ECORE_X_ATOM_WM_TAKE_FOCUS)
|
|
|
|
ewin->icccm.take_focus = ewin->icccm.need_input = 1;
|
|
|
|
else if (prop[i] == ECORE_X_ATOM_WM_DELETE_WINDOW)
|
|
|
|
ewin->icccm.delete_window = 1;
|
|
|
|
#if USE_XSYNC
|
|
|
|
else if (prop[i] == ECORE_X_ATOM_NET_WM_SYNC_REQUEST)
|
|
|
|
{
|
|
|
|
unsigned int c;
|
|
|
|
|
|
|
|
ewin->ewmh.sync_request_enable = 1;
|
|
|
|
ecore_x_window_prop_card32_get(EwinGetClientXwin(ewin),
|
|
|
|
ECORE_X_ATOM_NET_WM_SYNC_REQUEST_COUNTER,
|
|
|
|
&c, 1);
|
|
|
|
ewin->ewmh.sync_request_counter = c;
|
|
|
|
}
|
|
|
|
#endif
|
2003-05-22 12:15:03 -07:00
|
|
|
}
|
2007-04-16 09:36:10 -07:00
|
|
|
XFree(prop);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
ICCCM_GetWmTransientFor(EWin * ewin)
|
|
|
|
{
|
|
|
|
Window win;
|
|
|
|
|
|
|
|
ewin->icccm.transient = 0;
|
|
|
|
ewin->icccm.transient_for = None;
|
|
|
|
if (XGetTransientForHint(disp, EwinGetClientXwin(ewin), &win))
|
|
|
|
{
|
|
|
|
ewin->icccm.transient = 1;
|
|
|
|
ewin->icccm.transient_for = win;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
ICCCM_GetWmClientLeader(EWin * ewin)
|
|
|
|
{
|
|
|
|
int num;
|
|
|
|
Ecore_X_Window cleader;
|
|
|
|
|
|
|
|
num = ecore_x_window_prop_window_get(EwinGetClientXwin(ewin),
|
|
|
|
ECORE_X_ATOM_WM_CLIENT_LEADER,
|
|
|
|
&cleader, 1);
|
|
|
|
if (num > 0)
|
|
|
|
{
|
|
|
|
ewin->icccm.client_leader = cleader;
|
|
|
|
if (!ewin->icccm.group)
|
|
|
|
ewin->icccm.group = cleader;
|
2000-07-26 11:00:47 -07:00
|
|
|
}
|
1999-08-17 15:56:46 -07:00
|
|
|
}
|
|
|
|
|
2007-04-16 09:36:10 -07:00
|
|
|
void
|
|
|
|
ICCCM_GetHints(EWin * ewin)
|
|
|
|
{
|
|
|
|
ICCCM_GetWmHints(ewin);
|
|
|
|
ICCCM_GetWmProtocols(ewin);
|
|
|
|
ICCCM_GetWmTransientFor(ewin);
|
|
|
|
ICCCM_GetWmClientLeader(ewin);
|
|
|
|
}
|
|
|
|
|
1999-08-17 15:56:46 -07:00
|
|
|
void
|
2005-01-22 03:32:58 -08:00
|
|
|
ICCCM_SetIconSizes(void)
|
1999-08-17 15:56:46 -07:00
|
|
|
{
|
|
|
|
XIconSize *is;
|
|
|
|
|
|
|
|
is = XAllocIconSize();
|
|
|
|
is->min_width = 8;
|
|
|
|
is->min_height = 8;
|
|
|
|
is->max_width = 48;
|
|
|
|
is->max_height = 48;
|
|
|
|
is->width_inc = 1;
|
|
|
|
is->height_inc = 1;
|
2008-03-24 04:12:40 -07:00
|
|
|
XSetIconSizes(disp, WinGetXwin(VROOT), is, 1);
|
1999-08-17 15:56:46 -07:00
|
|
|
XFree(is);
|
|
|
|
}
|
|
|
|
|
2004-07-04 01:47:28 -07:00
|
|
|
/*
|
|
|
|
* Process received window property change
|
|
|
|
*/
|
2007-04-16 09:36:10 -07:00
|
|
|
int
|
2004-07-04 01:47:28 -07:00
|
|
|
ICCCM_ProcessPropertyChange(EWin * ewin, Atom atom_change)
|
|
|
|
{
|
2007-04-16 09:36:10 -07:00
|
|
|
if (atom_change == ECORE_X_ATOM_WM_NAME)
|
|
|
|
{
|
|
|
|
ICCCM_GetTitle(ewin);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ICCCM_GetHints */
|
|
|
|
if (atom_change == ECORE_X_ATOM_WM_HINTS)
|
|
|
|
{
|
|
|
|
ICCCM_GetWmHints(ewin);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
if (atom_change == ECORE_X_ATOM_WM_PROTOCOLS)
|
|
|
|
{
|
|
|
|
ICCCM_GetWmProtocols(ewin);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
if (atom_change == ECORE_X_ATOM_WM_TRANSIENT_FOR)
|
|
|
|
{
|
|
|
|
ICCCM_GetWmTransientFor(ewin);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
if (atom_change == ECORE_X_ATOM_WM_CLIENT_LEADER)
|
|
|
|
{
|
|
|
|
ICCCM_GetWmClientLeader(ewin);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ICCCM_GetInfo */
|
|
|
|
if (atom_change == ECORE_X_ATOM_WM_ICON_NAME)
|
|
|
|
{
|
|
|
|
ICCCM_GetWmIconName(ewin);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
#if 1 /* FIXME - Any reason to process these? */
|
|
|
|
if (atom_change == ECORE_X_ATOM_WM_CLASS)
|
|
|
|
{
|
|
|
|
ICCCM_GetWmClass(ewin);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
if (atom_change == ECORE_X_ATOM_WM_COMMAND)
|
|
|
|
{
|
|
|
|
ICCCM_GetWmCommand(ewin);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
if (atom_change == ECORE_X_ATOM_WM_CLIENT_MACHINE)
|
|
|
|
{
|
|
|
|
ICCCM_GetWmClientMachine(ewin);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
if (atom_change == ECORE_X_ATOM_WM_WINDOW_ROLE)
|
|
|
|
{
|
|
|
|
ICCCM_GetWmWindowRole(ewin);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (atom_change == ECORE_X_ATOM_WM_COLORMAP_WINDOWS)
|
|
|
|
{
|
|
|
|
ICCCM_Cmap(ewin);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (atom_change == ECORE_X_ATOM_WM_NORMAL_HINTS)
|
|
|
|
{
|
|
|
|
ICCCM_GetGeoms(ewin);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
2004-06-02 15:44:33 -07:00
|
|
|
}
|
2006-08-23 12:06:21 -07:00
|
|
|
|
|
|
|
#if USE_XSYNC
|
|
|
|
int
|
|
|
|
EwinSyncRequestSend(EWin * ewin)
|
|
|
|
{
|
|
|
|
long long count;
|
|
|
|
|
2006-10-28 07:53:16 -07:00
|
|
|
if (!ewin->ewmh.sync_request_enable || EServerIsGrabbed())
|
2006-08-23 12:06:21 -07:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
count = ++ewin->ewmh.sync_request_count;
|
|
|
|
|
|
|
|
if (count == 0)
|
|
|
|
ewin->ewmh.sync_request_count = ++count;
|
|
|
|
ecore_x_client_message32_send(EwinGetClientXwin(ewin),
|
|
|
|
ECORE_X_ATOM_WM_PROTOCOLS,
|
|
|
|
StructureNotifyMask,
|
|
|
|
ECORE_X_ATOM_NET_WM_SYNC_REQUEST,
|
|
|
|
Mode.events.time,
|
2006-11-19 14:55:32 -08:00
|
|
|
(long)(count & 0xffffffff),
|
|
|
|
(long)(count >> 32), 0);
|
2006-08-23 12:06:21 -07:00
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
EwinSyncRequestWait(EWin * ewin)
|
|
|
|
{
|
|
|
|
XSyncWaitCondition xswc[2];
|
|
|
|
double t;
|
|
|
|
|
2006-10-28 07:53:16 -07:00
|
|
|
if (!ewin->ewmh.sync_request_enable || EServerIsGrabbed())
|
2006-08-23 12:06:21 -07:00
|
|
|
return;
|
|
|
|
|
|
|
|
xswc[0].trigger.counter = ewin->ewmh.sync_request_counter;
|
|
|
|
xswc[0].trigger.value_type = XSyncAbsolute;
|
|
|
|
XSyncIntsToValue(&xswc[0].trigger.wait_value,
|
|
|
|
ewin->ewmh.sync_request_count & 0xffffffff,
|
|
|
|
ewin->ewmh.sync_request_count >> 32);
|
|
|
|
xswc[0].trigger.test_type = XSyncPositiveComparison;
|
|
|
|
XSyncIntsToValue(&xswc[0].event_threshold, 0, 0);
|
|
|
|
|
|
|
|
xswc[1].trigger.counter = Mode.display.server_time;
|
|
|
|
xswc[1].trigger.value_type = XSyncRelative;
|
2006-10-28 07:53:16 -07:00
|
|
|
XSyncIntsToValue(&xswc[1].trigger.wait_value, 200, 0); /* 200 ms */
|
2006-08-23 12:06:21 -07:00
|
|
|
xswc[1].trigger.test_type = XSyncPositiveComparison;
|
|
|
|
XSyncIntsToValue(&xswc[1].event_threshold, 0, 0);
|
|
|
|
|
|
|
|
t = GetTime();
|
|
|
|
XSyncAwait(disp, xswc, 2);
|
2006-11-19 13:55:52 -08:00
|
|
|
if (EDebug(EDBUG_TYPE_SYNC))
|
2006-08-23 12:06:21 -07:00
|
|
|
Eprintf("Sync t=%#lx c=%llx: Delay=%8.6lf us\n",
|
|
|
|
xswc[0].trigger.counter, ewin->ewmh.sync_request_count,
|
|
|
|
GetTime() - t);
|
|
|
|
}
|
|
|
|
#endif /* USE_XSYNC */
|