2004-12-30 00:06:46 -08:00
|
|
|
/*
|
|
|
|
* vim:ts=8:sw=3:sts=8:noexpandtab:cino=>5n-3f0^-2{2
|
|
|
|
*/
|
|
|
|
#include "e.h"
|
2005-09-14 13:19:44 -07:00
|
|
|
#include "config.h"
|
2004-12-30 00:06:46 -08:00
|
|
|
|
|
|
|
void
|
|
|
|
e_hints_init(void)
|
|
|
|
{
|
|
|
|
Ecore_X_Window *roots = NULL;
|
|
|
|
int num;
|
|
|
|
|
|
|
|
roots = ecore_x_window_root_list(&num);
|
|
|
|
if (roots)
|
|
|
|
{
|
2005-09-20 10:09:56 -07:00
|
|
|
Ecore_X_Atom supported[41];
|
|
|
|
int supported_num, i;
|
|
|
|
|
|
|
|
supported_num = 0;
|
|
|
|
/* Set what hints we support */
|
|
|
|
/* Root Window Properties (and Related Messages) */
|
|
|
|
supported[supported_num++] = ECORE_X_ATOM_NET_CLIENT_LIST;
|
|
|
|
supported[supported_num++] = ECORE_X_ATOM_NET_CLIENT_LIST_STACKING;
|
|
|
|
/*ecore_x_netwm_supported(roots[supported_num], ECORE_X_ATOM_NET_NUMBER_OF_DESKTOPS, 1);*/
|
|
|
|
/*ecore_x_netwm_supported(roots[supported_num], ECORE_X_ATOM_NET_DESKTOP_GEOMETRY, 1);*/
|
|
|
|
/*ecore_x_netwm_supported(roots[supported_num], ECORE_X_ATOM_NET_DESKTOP_VIEWPORT, 1);*/
|
|
|
|
/*ecore_x_netwm_supported(roots[supported_num], ECORE_X_ATOM_NET_CURRENT_DESKTOP, 1);*/
|
|
|
|
/*ecore_x_netwm_supported(roots[supported_num], ECORE_X_ATOM_NET_DESKTOP_NAMES, 1);*/
|
|
|
|
supported[supported_num++] = ECORE_X_ATOM_NET_ACTIVE_WINDOW;
|
|
|
|
/*ecore_x_netwm_supported(roots[supported_num], ECORE_X_ATOM_NET_WORKAREA, 1);*/
|
|
|
|
supported[supported_num++] = ECORE_X_ATOM_NET_SUPPORTING_WM_CHECK;
|
|
|
|
supported[supported_num++] = ECORE_X_ATOM_NET_VIRTUAL_ROOTS;
|
|
|
|
/*ecore_x_netwm_supported(roots[supported_num], ECORE_X_ATOM_NET_DESKTOP_LAYOUT, 1);*/
|
|
|
|
/*ecore_x_netwm_supported(roots[supported_num], ECORE_X_ATOM_NET_SHOWING_DESKTOP, 1);*/
|
|
|
|
|
|
|
|
/* Other Root Wsupported_numndow Messages */
|
|
|
|
/*ecore_x_netwm_supported(roots[supported_num], ECORE_X_ATOM_NET_CLOSE_WINDOW, 1);*/
|
|
|
|
/*ecore_x_netwm_supported(roots[supported_num], ECORE_X_ATOM_NET_MOVERESIZE_WINDOW, 1);*/
|
|
|
|
supported[supported_num++] = ECORE_X_ATOM_NET_WM_MOVERESIZE;
|
|
|
|
/*ecore_x_netwm_supported(roots[supported_num], ECORE_X_ATOM_NET_RESTACK_WINDOW, 1);*/
|
|
|
|
supported[supported_num++] = ECORE_X_ATOM_NET_REQUEST_FRAME_EXTENTS;
|
|
|
|
|
|
|
|
/* Applsupported_numcatsupported_numon Wsupported_numndow Propertsupported_numes */
|
|
|
|
supported[supported_num++] = ECORE_X_ATOM_NET_WM_NAME;
|
|
|
|
supported[supported_num++] = ECORE_X_ATOM_NET_WM_VISIBLE_NAME;
|
|
|
|
supported[supported_num++] = ECORE_X_ATOM_NET_WM_ICON_NAME;
|
|
|
|
supported[supported_num++] = ECORE_X_ATOM_NET_WM_VISIBLE_ICON_NAME;
|
|
|
|
/*ecore_x_netwm_supported(roots[supported_num], ECORE_X_ATOM_NET_WM_DESKTOP, 1);*/
|
|
|
|
supported[supported_num++] = ECORE_X_ATOM_NET_WM_WINDOW_TYPE;
|
|
|
|
supported[supported_num++] = ECORE_X_ATOM_NET_WM_WINDOW_TYPE_DESKTOP;
|
|
|
|
supported[supported_num++] = ECORE_X_ATOM_NET_WM_WINDOW_TYPE_DOCK;
|
|
|
|
supported[supported_num++] = ECORE_X_ATOM_NET_WM_WINDOW_TYPE_TOOLBAR;
|
|
|
|
supported[supported_num++] = ECORE_X_ATOM_NET_WM_WINDOW_TYPE_MENU;
|
|
|
|
supported[supported_num++] = ECORE_X_ATOM_NET_WM_WINDOW_TYPE_UTILITY;
|
|
|
|
supported[supported_num++] = ECORE_X_ATOM_NET_WM_WINDOW_TYPE_SPLASH;
|
|
|
|
supported[supported_num++] = ECORE_X_ATOM_NET_WM_WINDOW_TYPE_DIALOG;
|
|
|
|
supported[supported_num++] = ECORE_X_ATOM_NET_WM_WINDOW_TYPE_NORMAL;
|
|
|
|
supported[supported_num++] = ECORE_X_ATOM_NET_WM_STATE;
|
|
|
|
supported[supported_num++] = ECORE_X_ATOM_NET_WM_STATE_MODAL;
|
|
|
|
supported[supported_num++] = ECORE_X_ATOM_NET_WM_STATE_STICKY;
|
|
|
|
supported[supported_num++] = ECORE_X_ATOM_NET_WM_STATE_MAXIMIZED_VERT;
|
|
|
|
supported[supported_num++] = ECORE_X_ATOM_NET_WM_STATE_MAXIMIZED_HORZ;
|
|
|
|
supported[supported_num++] = ECORE_X_ATOM_NET_WM_STATE_SHADED;
|
|
|
|
supported[supported_num++] = ECORE_X_ATOM_NET_WM_STATE_SKIP_TASKBAR;
|
|
|
|
supported[supported_num++] = ECORE_X_ATOM_NET_WM_STATE_SKIP_PAGER;
|
|
|
|
supported[supported_num++] = ECORE_X_ATOM_NET_WM_STATE_HIDDEN;
|
|
|
|
supported[supported_num++] = ECORE_X_ATOM_NET_WM_STATE_FULLSCREEN;
|
|
|
|
supported[supported_num++] = ECORE_X_ATOM_NET_WM_STATE_ABOVE;
|
|
|
|
supported[supported_num++] = ECORE_X_ATOM_NET_WM_STATE_BELOW;
|
|
|
|
/*ecore_x_netwm_supported(roots[supported_num], ECORE_X_ATOM_NET_WM_STATE_DEMANDS_ATTENTION, 1);*/
|
|
|
|
/*ecore_x_netwm_supported(roots[supported_num], ECORE_X_ATOM_NET_WM_ALLOWED_ACTIONS, 1);*/
|
|
|
|
/*ecore_x_netwm_supported(roots[supported_num], ECORE_X_ATOM_NET_WM_ACTION_MOVE, 1);*/
|
|
|
|
/*ecore_x_netwm_supported(roots[supported_num], ECORE_X_ATOM_NET_WM_ACTION_RESIZE, 1);*/
|
|
|
|
/*ecore_x_netwm_supported(roots[supported_num], ECORE_X_ATOM_NET_WM_ACTION_MINIMIZE, 1);*/
|
|
|
|
/*ecore_x_netwm_supported(roots[supported_num], ECORE_X_ATOM_NET_WM_ACTION_SHADE, 1);*/
|
|
|
|
/*ecore_x_netwm_supported(roots[supported_num], ECORE_X_ATOM_NET_WM_ACTION_STICK, 1);*/
|
|
|
|
/*ecore_x_netwm_supported(roots[supported_num], ECORE_X_ATOM_NET_WM_ACTION_MAXIMIZE_HORZ, 1);*/
|
|
|
|
/*ecore_x_netwm_supported(roots[supported_num], ECORE_X_ATOM_NET_WM_ACTION_MAXIMIZE_VERT, 1);*/
|
|
|
|
/*ecore_x_netwm_supported(roots[supported_num], ECORE_X_ATOM_NET_WM_ACTION_FULLSCREEN, 1);*/
|
|
|
|
/*ecore_x_netwm_supported(roots[supported_num], ECORE_X_ATOM_NET_WM_ACTION_CHANGE_DESKTOP, 1);*/
|
|
|
|
/*ecore_x_netwm_supported(roots[supported_num], ECORE_X_ATOM_NET_WM_ACTION_CLOSE, 1);*/
|
|
|
|
supported[supported_num++] = ECORE_X_ATOM_NET_WM_STRUT;
|
|
|
|
supported[supported_num++] = ECORE_X_ATOM_NET_WM_STRUT_PARTIAL;
|
|
|
|
/*ecore_x_netwm_supported(roots[supported_num], ECORE_X_ATOM_NET_WM_ICON_GEOMETRY, 1);*/
|
|
|
|
supported[supported_num++] = ECORE_X_ATOM_NET_WM_ICON;
|
|
|
|
supported[supported_num++] = ECORE_X_ATOM_NET_WM_PID;
|
|
|
|
/*ecore_x_netwm_supported(roots[supported_num], ECORE_X_ATOM_NET_WM_HANDLED_ICONS, 1);*/
|
|
|
|
supported[supported_num++] = ECORE_X_ATOM_NET_WM_USER_TIME;
|
|
|
|
supported[supported_num++] = ECORE_X_ATOM_NET_FRAME_EXTENTS;
|
|
|
|
supported[supported_num++] = ECORE_X_ATOM_NET_WM_PING;
|
|
|
|
supported[supported_num++] = ECORE_X_ATOM_NET_WM_SYNC_REQUEST;
|
|
|
|
supported[supported_num++] = ECORE_X_ATOM_NET_WM_SYNC_REQUEST_COUNTER;
|
|
|
|
|
2005-01-02 19:14:45 -08:00
|
|
|
for (i = 0; i < num; i++)
|
2004-12-30 00:06:46 -08:00
|
|
|
{
|
2005-01-02 19:14:45 -08:00
|
|
|
Ecore_X_Window win;
|
2005-09-20 10:09:56 -07:00
|
|
|
|
2005-01-02 19:14:45 -08:00
|
|
|
win = ecore_x_window_new(roots[i], -200, -200, 5, 5);
|
2005-05-19 22:13:45 -07:00
|
|
|
/*
|
|
|
|
* I don't FUCKING believe it. if we PRETENT we are Kwin - java is happy.
|
|
|
|
* why? it expects a double reparenting wm then. java insists on finding this
|
|
|
|
* out when it should be irrelevant! stupid code! I can't believe the time we
|
|
|
|
* just wasted hunting a bug that wasn't and that is due to sheer stupid
|
|
|
|
* coding.
|
|
|
|
*/
|
|
|
|
/* Now for more stupidity... Openoffice.org will change its look and feel
|
|
|
|
* depending on what wm it thinks there is... so if we pretend to be Kwin...
|
|
|
|
* it tries to use kde preferences, if found.
|
|
|
|
*/
|
2005-07-22 03:28:11 -07:00
|
|
|
/* I have disabled this now by pretending to be E16 with e16 comms. this
|
|
|
|
* means java plays nice and uses our FRAME property.. but we had to do other
|
2005-05-19 22:13:45 -07:00
|
|
|
* evil stuff as java EXPECTS all this at REPARENT time... i've deferred
|
|
|
|
* reparenting... i hate java!
|
|
|
|
*/
|
|
|
|
/* ecore_x_netwm_wm_identify(roots[i], win, "KWin");*/
|
|
|
|
ecore_x_netwm_wm_identify(roots[i], win, "Enlightenment");
|
2005-10-06 21:27:51 -07:00
|
|
|
/* this makes openoffice.org read gtk settings so it doesnt look like shit */
|
|
|
|
e_hints_openoffice_gnome_fake(roots[i]);
|
2005-05-16 08:43:15 -07:00
|
|
|
|
2005-09-20 10:09:56 -07:00
|
|
|
ecore_x_netwm_supported_set(roots[i], supported, supported_num);
|
2004-12-30 00:06:46 -08:00
|
|
|
}
|
|
|
|
free(roots);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-05-19 22:13:45 -07:00
|
|
|
/*
|
|
|
|
* This is here so we don't have to pretend to be Kwin anymore - we pretend
|
|
|
|
* to do old e16 style ipc. in fact we just ignore it... but set up the
|
|
|
|
* window port anyway
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
e_hints_e16_comms_pretend(E_Manager *man)
|
|
|
|
{
|
|
|
|
Ecore_X_Window win;
|
2005-06-21 22:34:50 -07:00
|
|
|
Ecore_X_Atom enlightenment_comms, enlightenment_version, string;
|
2005-05-19 22:13:45 -07:00
|
|
|
char buf[256];
|
|
|
|
|
|
|
|
enlightenment_comms = ecore_x_atom_get("ENLIGHTENMENT_COMMS");
|
2005-06-21 22:34:50 -07:00
|
|
|
enlightenment_version = ecore_x_atom_get("ENLIGHTENMENT_VERSION");
|
2005-05-19 22:13:45 -07:00
|
|
|
string = ecore_x_atom_get("STRING");
|
2005-06-21 22:34:50 -07:00
|
|
|
|
2005-05-19 22:13:45 -07:00
|
|
|
win = ecore_x_window_input_new(man->root, -100, -100, 1, 1);
|
2005-06-21 22:34:50 -07:00
|
|
|
|
|
|
|
/* to help detect this is NOT e16 */
|
|
|
|
snprintf(buf, sizeof(buf), "Enlightenment %s", VERSION);
|
|
|
|
ecore_x_window_prop_property_set(win, enlightenment_version, string, 8, buf, strlen(buf));
|
|
|
|
ecore_x_window_prop_property_set(man->root, enlightenment_version, string, 8, buf, strlen(buf));
|
|
|
|
|
2005-05-19 22:13:45 -07:00
|
|
|
snprintf(buf, sizeof(buf), "WINID %8x", (int)win);
|
|
|
|
ecore_x_window_prop_property_set(win, enlightenment_comms, string, 8, buf, 14);
|
2005-06-21 22:34:50 -07:00
|
|
|
|
2005-05-19 22:13:45 -07:00
|
|
|
ecore_x_window_prop_property_set(man->root, enlightenment_comms, string, 8, buf, 14);
|
|
|
|
}
|
|
|
|
|
2005-05-17 10:41:27 -07:00
|
|
|
void
|
|
|
|
e_hints_manager_init(E_Manager *man)
|
|
|
|
{
|
2005-06-03 09:35:29 -07:00
|
|
|
/* Set desktop count, desktop names and workarea */
|
|
|
|
int i = 0, num = 0;
|
|
|
|
unsigned int *areas = NULL;
|
2005-06-03 12:10:25 -07:00
|
|
|
Evas_List *cl;
|
2005-06-03 09:35:29 -07:00
|
|
|
Ecore_X_Window *vroots = NULL;
|
|
|
|
/* FIXME: Desktop names not yet implemented */
|
|
|
|
/* char **names; */
|
|
|
|
|
2005-05-19 22:13:45 -07:00
|
|
|
e_hints_e16_comms_pretend(man);
|
2005-06-03 09:35:29 -07:00
|
|
|
|
|
|
|
num = evas_list_count(man->containers);
|
|
|
|
|
|
|
|
vroots = calloc(num, sizeof(Ecore_X_Window));
|
|
|
|
if (!vroots) return;
|
|
|
|
|
|
|
|
/* names = calloc(num, sizeof(char *));*/
|
|
|
|
|
|
|
|
areas = calloc(4 * num, sizeof(unsigned int));
|
|
|
|
if (!areas)
|
|
|
|
{
|
|
|
|
free(vroots);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (cl = man->containers; cl; cl = cl->next)
|
|
|
|
{
|
|
|
|
E_Container *c;
|
|
|
|
|
|
|
|
c = cl->data;
|
|
|
|
areas[4 * i] = c->x;
|
|
|
|
areas[4 * i + 1] = c->y;
|
|
|
|
areas[4 * i + 2] = c->w;
|
|
|
|
areas[4 * i + 3] = c->h;
|
|
|
|
vroots[i++] = c->win;
|
|
|
|
}
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
ecore_x_netwm_desk_count_set(man->root, num);
|
|
|
|
#endif
|
|
|
|
if (e_config->use_virtual_roots)
|
|
|
|
{
|
2005-06-07 08:35:18 -07:00
|
|
|
ecore_x_netwm_desk_roots_set(man->root, vroots, num);
|
2005-06-03 09:35:29 -07:00
|
|
|
}
|
2005-06-03 12:10:25 -07:00
|
|
|
#if 0
|
|
|
|
/* No need for workarea without desktops */
|
2005-06-03 09:35:29 -07:00
|
|
|
ecore_x_netwm_desk_workareas_set(man->root, num, areas);
|
2005-06-03 12:10:25 -07:00
|
|
|
#endif
|
2005-06-03 09:35:29 -07:00
|
|
|
|
|
|
|
free(vroots);
|
|
|
|
free(areas);
|
2005-05-17 10:41:27 -07:00
|
|
|
}
|
|
|
|
|
2005-05-16 08:43:15 -07:00
|
|
|
/* FIXME, this should set the list in map order, not stack order */
|
2004-12-30 00:06:46 -08:00
|
|
|
void
|
|
|
|
e_hints_client_list_set(void)
|
|
|
|
{
|
2005-05-13 06:34:21 -07:00
|
|
|
Evas_List *ml = NULL, *cl = NULL;
|
2004-12-30 00:06:46 -08:00
|
|
|
unsigned int i = 0, num = 0;
|
|
|
|
E_Manager *m;
|
|
|
|
E_Container *c;
|
2005-05-13 06:34:21 -07:00
|
|
|
E_Border_List *bl;
|
2004-12-30 00:06:46 -08:00
|
|
|
E_Border *b;
|
|
|
|
Ecore_X_Window *clients = NULL;
|
|
|
|
|
|
|
|
/* Get client count by adding client lists on all containers */
|
2005-01-02 19:14:45 -08:00
|
|
|
for (ml = e_manager_list(); ml; ml = ml->next)
|
2004-12-30 00:06:46 -08:00
|
|
|
{
|
2005-01-02 19:14:45 -08:00
|
|
|
m = ml->data;
|
|
|
|
for (cl = m->containers; cl; cl = cl->next)
|
2004-12-30 00:06:46 -08:00
|
|
|
{
|
2005-01-02 19:14:45 -08:00
|
|
|
c = cl->data;
|
2005-05-13 06:34:21 -07:00
|
|
|
num += e_container_borders_count(c);
|
2004-12-30 00:06:46 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
clients = calloc(num, sizeof(Ecore_X_Window));
|
|
|
|
if (!clients)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* Fetch window IDs and add to array */
|
|
|
|
if (num > 0)
|
|
|
|
{
|
2005-01-02 19:14:45 -08:00
|
|
|
for (ml = e_manager_list(); ml; ml = ml->next)
|
2004-12-30 00:06:46 -08:00
|
|
|
{
|
2005-01-02 19:14:45 -08:00
|
|
|
m = ml->data;
|
|
|
|
for (cl = m->containers; cl; cl = cl->next)
|
2004-12-30 00:06:46 -08:00
|
|
|
{
|
2005-01-02 19:14:45 -08:00
|
|
|
c = cl->data;
|
2005-05-13 06:34:21 -07:00
|
|
|
bl = e_container_border_list_first(c);
|
|
|
|
while ((b = e_container_border_list_next(bl)))
|
|
|
|
clients[i++] = b->win;
|
|
|
|
e_container_border_list_free(bl);
|
2004-12-30 00:06:46 -08:00
|
|
|
}
|
|
|
|
}
|
2005-01-02 19:14:45 -08:00
|
|
|
for (ml = e_manager_list(); ml; ml = ml->next)
|
|
|
|
{
|
|
|
|
m = ml->data;
|
2005-06-07 08:35:18 -07:00
|
|
|
ecore_x_netwm_client_list_set(m->root, clients, num);
|
|
|
|
ecore_x_netwm_client_list_stacking_set(m->root, clients, num);
|
2005-01-02 19:14:45 -08:00
|
|
|
}
|
2004-12-30 00:06:46 -08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2005-01-02 19:14:45 -08:00
|
|
|
for (ml = e_manager_list(); ml; ml = ml->next)
|
|
|
|
{
|
|
|
|
m = ml->data;
|
2005-06-07 08:35:18 -07:00
|
|
|
ecore_x_netwm_client_list_set(m->root, NULL, 0);
|
|
|
|
ecore_x_netwm_client_list_stacking_set(m->root, NULL, 0);
|
2005-01-02 19:14:45 -08:00
|
|
|
}
|
2004-12-30 00:06:46 -08:00
|
|
|
}
|
2005-09-05 08:24:07 -07:00
|
|
|
E_FREE(clients);
|
2004-12-30 00:06:46 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Client list is already in stacking order, so this function is nearly
|
|
|
|
* identical to the previous one */
|
|
|
|
void
|
|
|
|
e_hints_client_stacking_set(void)
|
|
|
|
{
|
2005-05-13 06:34:21 -07:00
|
|
|
Evas_List *ml = NULL, *cl = NULL;
|
2004-12-30 00:06:46 -08:00
|
|
|
unsigned int i = 0, num = 0;
|
|
|
|
E_Manager *m;
|
|
|
|
E_Container *c;
|
2005-05-13 06:34:21 -07:00
|
|
|
E_Border_List *bl;
|
2004-12-30 00:06:46 -08:00
|
|
|
E_Border *b;
|
2005-01-02 09:23:49 -08:00
|
|
|
Ecore_X_Window *clients = NULL;
|
2004-12-30 00:06:46 -08:00
|
|
|
|
|
|
|
/* Get client count */
|
2005-01-02 19:14:45 -08:00
|
|
|
for (ml = e_manager_list(); ml; ml = ml->next)
|
2004-12-30 00:06:46 -08:00
|
|
|
{
|
2005-01-02 19:14:45 -08:00
|
|
|
m = ml->data;
|
|
|
|
for (cl = m->containers; cl; cl = cl->next)
|
2004-12-30 00:06:46 -08:00
|
|
|
{
|
2005-01-02 19:14:45 -08:00
|
|
|
c = cl->data;
|
2005-05-13 06:34:21 -07:00
|
|
|
num += e_container_borders_count(c);
|
2004-12-30 00:06:46 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
clients = calloc(num, sizeof(Ecore_X_Window));
|
|
|
|
if (!clients)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (num > 0)
|
|
|
|
{
|
2005-01-02 19:14:45 -08:00
|
|
|
for (ml = e_manager_list(); ml; ml = ml->next)
|
2004-12-30 00:06:46 -08:00
|
|
|
{
|
2005-01-02 19:14:45 -08:00
|
|
|
m = ml->data;
|
|
|
|
for (cl = m->containers; cl; cl = cl->next)
|
2004-12-30 00:06:46 -08:00
|
|
|
{
|
2005-01-02 19:14:45 -08:00
|
|
|
c = cl->data;
|
2005-05-13 06:34:21 -07:00
|
|
|
bl = e_container_border_list_first(c);
|
|
|
|
while ((b = e_container_border_list_next(bl)))
|
|
|
|
clients[i++] = b->win;
|
|
|
|
e_container_border_list_free(bl);
|
2004-12-30 00:06:46 -08:00
|
|
|
}
|
|
|
|
}
|
2005-01-02 19:14:45 -08:00
|
|
|
for (ml = e_manager_list(); ml; ml = ml->next)
|
|
|
|
{
|
|
|
|
m = ml->data;
|
2005-06-07 08:35:18 -07:00
|
|
|
ecore_x_netwm_client_list_stacking_set(m->root, clients, num);
|
2005-01-02 19:14:45 -08:00
|
|
|
}
|
2004-12-30 00:06:46 -08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2005-01-02 19:14:45 -08:00
|
|
|
for (ml = e_manager_list(); ml; ml = ml->next)
|
|
|
|
{
|
|
|
|
m = ml->data;
|
2005-06-07 08:35:18 -07:00
|
|
|
ecore_x_netwm_client_list_stacking_set(m->root, NULL, 0);
|
2005-01-02 19:14:45 -08:00
|
|
|
}
|
2004-12-30 00:06:46 -08:00
|
|
|
}
|
2005-09-05 08:24:07 -07:00
|
|
|
E_FREE(clients);
|
2004-12-30 00:06:46 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2005-04-29 01:37:09 -07:00
|
|
|
e_hints_active_window_set(E_Manager *man, E_Border *bd)
|
2004-12-30 00:06:46 -08:00
|
|
|
{
|
2005-01-03 01:34:24 -08:00
|
|
|
E_OBJECT_CHECK(man);
|
2005-04-29 01:37:09 -07:00
|
|
|
if (bd)
|
|
|
|
ecore_x_netwm_client_active_set(man->root, bd->client.win);
|
|
|
|
else
|
|
|
|
ecore_x_netwm_client_active_set(man->root, 0);
|
2004-12-30 00:06:46 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2005-04-29 01:02:29 -07:00
|
|
|
e_hints_window_init(E_Border *bd)
|
2004-12-30 00:06:46 -08:00
|
|
|
{
|
2005-12-18 06:21:25 -08:00
|
|
|
E_Remember *rem = NULL;
|
|
|
|
|
|
|
|
if (bd->remember)
|
|
|
|
rem = bd->remember;
|
|
|
|
|
2005-04-29 01:02:29 -07:00
|
|
|
if (bd->client.icccm.state == ECORE_X_WINDOW_STATE_HINT_NONE)
|
|
|
|
{
|
|
|
|
if (bd->client.netwm.state.hidden)
|
2005-05-18 21:07:41 -07:00
|
|
|
bd->client.icccm.state = ECORE_X_WINDOW_STATE_HINT_ICONIC;
|
2005-04-29 01:02:29 -07:00
|
|
|
else
|
|
|
|
bd->client.icccm.state = ECORE_X_WINDOW_STATE_HINT_NORMAL;
|
|
|
|
}
|
|
|
|
|
2005-12-18 06:21:25 -08:00
|
|
|
if ((rem) && (rem->prop.layer))
|
2005-08-21 16:36:07 -07:00
|
|
|
{
|
2005-12-18 06:21:25 -08:00
|
|
|
bd->layer = rem->prop.layer;
|
|
|
|
e_border_layer_set(bd, bd->layer);
|
2005-08-21 16:36:07 -07:00
|
|
|
}
|
2005-09-02 00:38:40 -07:00
|
|
|
else
|
2005-12-18 06:21:25 -08:00
|
|
|
{
|
|
|
|
if (!bd->lock_client_stacking)
|
|
|
|
{
|
|
|
|
if (bd->client.netwm.type == ECORE_X_WINDOW_TYPE_DESKTOP)
|
|
|
|
e_border_layer_set(bd, 0);
|
|
|
|
else if (bd->client.netwm.state.stacking == E_STACKING_BELOW)
|
|
|
|
e_border_layer_set(bd, 50);
|
|
|
|
else if (bd->client.netwm.state.stacking == E_STACKING_ABOVE)
|
|
|
|
e_border_layer_set(bd, 150);
|
|
|
|
else if (bd->client.netwm.type == ECORE_X_WINDOW_TYPE_DOCK)
|
|
|
|
e_border_layer_set(bd, 150);
|
|
|
|
else
|
|
|
|
e_border_layer_set(bd, 100);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
e_border_raise(bd);
|
|
|
|
}
|
2005-09-02 00:38:40 -07:00
|
|
|
|
|
|
|
if ((bd->parent) && (e_config->transient.layer))
|
|
|
|
e_border_layer_set(bd, bd->parent->layer);
|
2005-05-16 08:43:15 -07:00
|
|
|
|
2005-05-29 04:06:11 -07:00
|
|
|
#if 0
|
|
|
|
/* Ignore this, E has incompatible desktop setup */
|
2005-05-18 11:22:33 -07:00
|
|
|
if (ecore_x_netwm_desktop_get(bd->client.win, &bd->client.netwm.desktop))
|
2005-05-17 01:30:26 -07:00
|
|
|
{
|
2005-05-17 05:33:12 -07:00
|
|
|
if (bd->client.netwm.desktop == 0xffffffff)
|
2005-05-25 03:09:34 -07:00
|
|
|
{
|
2005-05-26 05:38:53 -07:00
|
|
|
// printf("CLIENT asks for all desks!\n");
|
2005-05-25 03:09:34 -07:00
|
|
|
e_border_stick(bd);
|
|
|
|
}
|
2005-05-17 05:33:12 -07:00
|
|
|
else if (bd->client.netwm.desktop < (bd->zone->desk_x_count * bd->zone->desk_y_count))
|
|
|
|
{
|
|
|
|
E_Desk *desk;
|
|
|
|
|
|
|
|
desk = e_desk_at_pos_get(bd->zone, bd->client.netwm.desktop);
|
|
|
|
if (desk)
|
|
|
|
e_border_desk_set(bd, desk);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Update netwm desktop with current desktop */
|
|
|
|
e_hints_window_desktop_set(bd);
|
|
|
|
}
|
2005-05-17 01:30:26 -07:00
|
|
|
}
|
|
|
|
else
|
2005-05-16 08:43:15 -07:00
|
|
|
{
|
2005-05-17 05:33:12 -07:00
|
|
|
/* Update netwm desktop with current desktop */
|
|
|
|
e_hints_window_desktop_set(bd);
|
2005-05-16 08:43:15 -07:00
|
|
|
}
|
2005-05-29 04:06:11 -07:00
|
|
|
#endif
|
2005-04-29 01:02:29 -07:00
|
|
|
|
2005-09-13 23:39:59 -07:00
|
|
|
{
|
|
|
|
char *str = NULL;
|
|
|
|
|
|
|
|
if (
|
|
|
|
(ecore_x_netwm_startup_id_get(bd->client.win, &str) && (str)) ||
|
|
|
|
((bd->client.icccm.client_leader > 0) && ecore_x_netwm_startup_id_get(bd->client.icccm.client_leader, &str) && (str))
|
|
|
|
)
|
|
|
|
{
|
|
|
|
if (!strncmp(str, "E_START|", 8))
|
|
|
|
{
|
|
|
|
int id;
|
2005-10-28 01:32:01 -07:00
|
|
|
|
2005-09-13 23:39:59 -07:00
|
|
|
id = atoi(str + 8);
|
2005-09-29 08:01:04 -07:00
|
|
|
if (id > 0) bd->client.netwm.startup_id = id;
|
2005-09-13 23:39:59 -07:00
|
|
|
}
|
|
|
|
free(str);
|
|
|
|
}
|
|
|
|
}
|
2005-05-29 04:06:11 -07:00
|
|
|
/* It's ok not to have fetch flag, should only be set on startup
|
|
|
|
* and not changed. */
|
2005-05-17 05:33:12 -07:00
|
|
|
if (!ecore_x_netwm_pid_get(bd->client.win, &bd->client.netwm.pid))
|
|
|
|
bd->client.netwm.pid = -1;
|
|
|
|
|
2005-04-29 01:02:29 -07:00
|
|
|
if (bd->client.netwm.state.sticky)
|
2005-08-21 16:36:07 -07:00
|
|
|
{
|
|
|
|
if (!bd->lock_client_sticky)
|
|
|
|
e_border_stick(bd);
|
|
|
|
else
|
|
|
|
e_hints_window_sticky_set(bd, 0);
|
|
|
|
}
|
2005-04-29 01:02:29 -07:00
|
|
|
if (bd->client.netwm.state.shaded)
|
2005-08-21 16:36:07 -07:00
|
|
|
{
|
|
|
|
if (!bd->lock_client_shade)
|
|
|
|
e_border_shade(bd, e_hints_window_shade_direction_get(bd));
|
|
|
|
else
|
|
|
|
e_hints_window_shaded_set(bd, 0);
|
|
|
|
}
|
2005-06-15 19:12:15 -07:00
|
|
|
if ((bd->client.netwm.state.maximized_v) && (bd->client.netwm.state.maximized_h))
|
2005-07-10 10:12:01 -07:00
|
|
|
{
|
2005-08-21 16:36:07 -07:00
|
|
|
if (!bd->lock_client_maximize)
|
|
|
|
{
|
|
|
|
e_hints_window_size_get(bd);
|
|
|
|
e_border_maximize(bd, e_config->maximize_policy);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
e_hints_window_maximized_set(bd, 0);
|
2005-07-10 10:12:01 -07:00
|
|
|
}
|
2005-05-02 02:19:55 -07:00
|
|
|
if (bd->client.netwm.state.fullscreen)
|
2005-08-10 21:10:59 -07:00
|
|
|
{
|
2005-08-21 16:36:07 -07:00
|
|
|
if (!bd->lock_client_fullscreen)
|
|
|
|
{
|
|
|
|
e_hints_window_size_get(bd);
|
2005-11-04 15:30:18 -08:00
|
|
|
e_border_fullscreen(bd, e_config->fullscreen_policy);
|
2005-08-21 16:36:07 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
e_hints_window_fullscreen_set(bd, 0);
|
|
|
|
}
|
|
|
|
if ((bd->client.icccm.state == ECORE_X_WINDOW_STATE_HINT_ICONIC) &&
|
|
|
|
(bd->client.netwm.state.hidden))
|
|
|
|
{
|
|
|
|
if (!bd->lock_client_iconify)
|
|
|
|
e_border_iconify(bd);
|
|
|
|
else
|
|
|
|
e_hints_window_visible_set(bd);
|
2005-08-10 21:10:59 -07:00
|
|
|
}
|
2005-09-02 00:38:40 -07:00
|
|
|
else if ((bd->parent) && (e_config->transient.iconify) && (bd->parent->iconic))
|
|
|
|
e_border_iconify(bd);
|
2005-04-29 01:02:29 -07:00
|
|
|
/* If a window isn't iconic, and is one the current desk,
|
|
|
|
* show it! */
|
2005-04-29 04:08:04 -07:00
|
|
|
else if (bd->desk == e_desk_current_get(bd->zone))
|
2005-04-29 01:02:29 -07:00
|
|
|
e_border_show(bd);
|
2005-08-29 18:15:25 -07:00
|
|
|
/* e hints */
|
2005-09-20 21:53:12 -07:00
|
|
|
/*
|
2005-08-29 18:15:25 -07:00
|
|
|
if (bd->client.e.state.centered)
|
|
|
|
{
|
|
|
|
e_border_move(bd,
|
|
|
|
bd->zone->x + (bd->zone->w - bd->w) / 2,
|
|
|
|
bd->zone->y + (bd->zone->h - bd->h) / 2);
|
|
|
|
|
|
|
|
}
|
2005-09-20 21:53:12 -07:00
|
|
|
*/
|
2005-05-16 08:43:15 -07:00
|
|
|
/* Update stacking */
|
|
|
|
e_hints_client_list_set();
|
|
|
|
e_hints_client_stacking_set();
|
2005-04-29 01:02:29 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
e_hints_window_state_set(E_Border *bd)
|
|
|
|
{
|
2005-05-30 23:52:05 -07:00
|
|
|
Ecore_X_Window_State state[10];
|
2005-08-29 18:15:25 -07:00
|
|
|
int num = 0;
|
2005-05-30 23:52:05 -07:00
|
|
|
|
|
|
|
if (bd->client.netwm.state.modal)
|
|
|
|
state[num++] = ECORE_X_WINDOW_STATE_MODAL;
|
|
|
|
if (bd->client.netwm.state.sticky)
|
|
|
|
state[num++] = ECORE_X_WINDOW_STATE_STICKY;
|
|
|
|
if (bd->client.netwm.state.maximized_v)
|
|
|
|
state[num++] = ECORE_X_WINDOW_STATE_MAXIMIZED_VERT;
|
|
|
|
if (bd->client.netwm.state.maximized_h)
|
|
|
|
state[num++] = ECORE_X_WINDOW_STATE_MAXIMIZED_HORZ;
|
|
|
|
if (bd->client.netwm.state.shaded)
|
|
|
|
state[num++] = ECORE_X_WINDOW_STATE_SHADED;
|
|
|
|
if (bd->client.netwm.state.skip_taskbar)
|
|
|
|
state[num++] = ECORE_X_WINDOW_STATE_SKIP_TASKBAR;
|
|
|
|
if (bd->client.netwm.state.skip_pager)
|
|
|
|
state[num++] = ECORE_X_WINDOW_STATE_SKIP_PAGER;
|
|
|
|
if (bd->client.netwm.state.hidden)
|
|
|
|
state[num++] = ECORE_X_WINDOW_STATE_HIDDEN;
|
|
|
|
if (bd->client.netwm.state.fullscreen)
|
|
|
|
state[num++] = ECORE_X_WINDOW_STATE_FULLSCREEN;
|
|
|
|
|
2004-12-30 00:06:46 -08:00
|
|
|
switch (bd->client.netwm.state.stacking)
|
|
|
|
{
|
2005-05-10 03:11:34 -07:00
|
|
|
case E_STACKING_ABOVE:
|
2005-05-30 23:52:05 -07:00
|
|
|
state[num++] = ECORE_X_WINDOW_STATE_ABOVE;
|
2005-05-10 03:11:34 -07:00
|
|
|
break;
|
|
|
|
case E_STACKING_BELOW:
|
2005-05-30 23:52:05 -07:00
|
|
|
state[num++] = ECORE_X_WINDOW_STATE_BELOW;
|
2005-05-10 03:11:34 -07:00
|
|
|
break;
|
|
|
|
case E_STACKING_NONE:
|
2004-12-30 00:06:46 -08:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2005-06-07 08:35:18 -07:00
|
|
|
ecore_x_netwm_window_state_set(bd->client.win, state, num);
|
2004-12-30 00:06:46 -08:00
|
|
|
}
|
|
|
|
|
2005-04-29 01:02:29 -07:00
|
|
|
void e_hints_window_type_set(E_Border *bd)
|
|
|
|
{
|
|
|
|
ecore_x_netwm_window_type_set(bd->client.win, bd->client.netwm.type);
|
|
|
|
}
|
|
|
|
|
|
|
|
void e_hints_window_type_get(E_Border *bd)
|
|
|
|
{
|
2005-06-07 08:35:18 -07:00
|
|
|
ecore_x_netwm_window_type_get(bd->client.win, &bd->client.netwm.type);
|
2005-04-29 01:02:29 -07:00
|
|
|
}
|
2005-05-02 02:19:55 -07:00
|
|
|
|
|
|
|
void
|
|
|
|
e_hints_window_state_update(E_Border *bd, Ecore_X_Window_State state,
|
2005-07-21 05:07:11 -07:00
|
|
|
Ecore_X_Window_State_Action action)
|
2005-05-02 02:19:55 -07:00
|
|
|
{
|
|
|
|
int changed;
|
2005-07-21 05:06:29 -07:00
|
|
|
|
2005-05-02 02:19:55 -07:00
|
|
|
switch (state)
|
|
|
|
{
|
|
|
|
case ECORE_X_WINDOW_STATE_ICONIFIED:
|
2005-07-21 05:06:29 -07:00
|
|
|
if (action != ECORE_X_WINDOW_STATE_ACTION_ADD) return;
|
|
|
|
if (bd->client.icccm.state == ECORE_X_WINDOW_STATE_HINT_ICONIC) return;
|
2005-08-21 16:36:07 -07:00
|
|
|
if (bd->lock_client_iconify) return;
|
|
|
|
e_border_iconify(bd);
|
2005-07-21 05:06:29 -07:00
|
|
|
break;
|
2005-05-02 02:19:55 -07:00
|
|
|
case ECORE_X_WINDOW_STATE_MODAL:
|
2005-07-21 05:06:29 -07:00
|
|
|
switch (action)
|
|
|
|
{
|
|
|
|
case ECORE_X_WINDOW_STATE_ACTION_REMOVE:
|
|
|
|
if (bd->client.netwm.state.modal)
|
|
|
|
{
|
|
|
|
bd->client.netwm.state.modal = 0;
|
2005-08-29 16:04:21 -07:00
|
|
|
bd->client.netwm.update.state = 1;
|
|
|
|
bd->changed = 1;
|
2005-07-21 05:06:29 -07:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ECORE_X_WINDOW_STATE_ACTION_ADD:
|
|
|
|
if (!bd->client.netwm.state.modal)
|
|
|
|
{
|
|
|
|
bd->client.netwm.state.modal = 1;
|
2005-08-29 16:04:21 -07:00
|
|
|
bd->client.netwm.update.state = 1;
|
|
|
|
bd->changed = 1;
|
2005-07-21 05:06:29 -07:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ECORE_X_WINDOW_STATE_ACTION_TOGGLE:
|
|
|
|
bd->client.netwm.state.modal = !bd->client.netwm.state.modal;
|
2005-08-29 16:04:21 -07:00
|
|
|
bd->client.netwm.update.state = 1;
|
|
|
|
bd->changed = 1;
|
2005-07-21 05:06:29 -07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
2005-05-02 02:19:55 -07:00
|
|
|
case ECORE_X_WINDOW_STATE_STICKY:
|
2005-08-21 16:36:07 -07:00
|
|
|
if (bd->lock_client_sticky) return;
|
2005-07-21 05:06:29 -07:00
|
|
|
switch (action)
|
|
|
|
{
|
|
|
|
case ECORE_X_WINDOW_STATE_ACTION_REMOVE:
|
2005-07-04 03:24:22 -07:00
|
|
|
e_border_unstick(bd);
|
2005-07-21 05:06:29 -07:00
|
|
|
break;
|
|
|
|
case ECORE_X_WINDOW_STATE_ACTION_ADD:
|
|
|
|
e_border_stick(bd);
|
|
|
|
break;
|
|
|
|
case ECORE_X_WINDOW_STATE_ACTION_TOGGLE:
|
|
|
|
if (bd->sticky)
|
|
|
|
e_border_unstick(bd);
|
|
|
|
else
|
|
|
|
e_border_stick(bd);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
2005-05-02 02:19:55 -07:00
|
|
|
case ECORE_X_WINDOW_STATE_MAXIMIZED_VERT:
|
2005-08-21 16:36:07 -07:00
|
|
|
if (bd->lock_client_maximize) return;
|
2005-08-29 16:04:21 -07:00
|
|
|
/* We might end up in a state where maximized_h or maximized_v is
|
|
|
|
* set. This doesn't matter, because E only checks if both are
|
|
|
|
* set for maximization.
|
|
|
|
*/
|
2005-07-21 05:06:29 -07:00
|
|
|
changed = 0;
|
|
|
|
switch (action)
|
|
|
|
{
|
|
|
|
case ECORE_X_WINDOW_STATE_ACTION_REMOVE:
|
|
|
|
if (bd->client.netwm.state.maximized_v)
|
|
|
|
{
|
|
|
|
bd->client.netwm.state.maximized_v = 0;
|
|
|
|
changed = 1;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ECORE_X_WINDOW_STATE_ACTION_ADD:
|
|
|
|
if (!bd->client.netwm.state.maximized_v)
|
|
|
|
{
|
|
|
|
bd->client.netwm.state.maximized_v = 1;
|
|
|
|
changed = 1;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ECORE_X_WINDOW_STATE_ACTION_TOGGLE:
|
|
|
|
bd->client.netwm.state.maximized_v = !bd->client.netwm.state.maximized_v;
|
|
|
|
changed = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (changed)
|
|
|
|
{
|
|
|
|
bd->client.netwm.update.state = 1;
|
|
|
|
bd->changed = 1;
|
2005-08-21 16:36:07 -07:00
|
|
|
if ((bd->client.netwm.state.maximized_v) &&
|
|
|
|
(bd->client.netwm.state.maximized_h))
|
2005-07-21 05:06:29 -07:00
|
|
|
e_border_maximize(bd, e_config->maximize_policy);
|
2005-08-21 16:36:07 -07:00
|
|
|
else if ((!bd->client.netwm.state.maximized_v) &&
|
|
|
|
(!bd->client.netwm.state.maximized_h))
|
2005-07-21 05:06:29 -07:00
|
|
|
e_border_unmaximize(bd);
|
|
|
|
}
|
|
|
|
break;
|
2005-05-02 02:19:55 -07:00
|
|
|
case ECORE_X_WINDOW_STATE_MAXIMIZED_HORZ:
|
2005-08-21 16:36:07 -07:00
|
|
|
if (bd->lock_client_maximize) return;
|
2005-08-29 16:04:21 -07:00
|
|
|
/* We might end up in a state where maximized_h or maximized_v is
|
|
|
|
* set. This doesn't matter, because E only checks if both are
|
|
|
|
* set for maximization.
|
|
|
|
*/
|
2005-07-21 05:06:29 -07:00
|
|
|
changed = 0;
|
|
|
|
switch (action)
|
|
|
|
{
|
|
|
|
case ECORE_X_WINDOW_STATE_ACTION_REMOVE:
|
|
|
|
if (bd->client.netwm.state.maximized_h)
|
|
|
|
{
|
|
|
|
bd->client.netwm.state.maximized_h = 0;
|
|
|
|
changed = 1;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ECORE_X_WINDOW_STATE_ACTION_ADD:
|
|
|
|
if (!bd->client.netwm.state.maximized_h)
|
|
|
|
{
|
|
|
|
bd->client.netwm.state.maximized_h = 1;
|
|
|
|
changed = 1;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ECORE_X_WINDOW_STATE_ACTION_TOGGLE:
|
|
|
|
bd->client.netwm.state.maximized_h = !bd->client.netwm.state.maximized_h;
|
|
|
|
changed = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (changed)
|
|
|
|
{
|
|
|
|
bd->client.netwm.update.state = 1;
|
|
|
|
bd->changed = 1;
|
2005-08-21 16:36:07 -07:00
|
|
|
if ((bd->client.netwm.state.maximized_v) &&
|
|
|
|
(bd->client.netwm.state.maximized_h))
|
2005-07-21 05:06:29 -07:00
|
|
|
e_border_maximize(bd, e_config->maximize_policy);
|
2005-08-21 16:36:07 -07:00
|
|
|
else if ((!bd->client.netwm.state.maximized_v) &&
|
|
|
|
(!bd->client.netwm.state.maximized_h))
|
2005-07-21 05:06:29 -07:00
|
|
|
e_border_unmaximize(bd);
|
|
|
|
}
|
|
|
|
break;
|
2005-05-02 02:19:55 -07:00
|
|
|
case ECORE_X_WINDOW_STATE_SHADED:
|
2005-08-21 16:36:07 -07:00
|
|
|
if (bd->lock_client_shade) return;
|
2005-07-21 05:06:29 -07:00
|
|
|
switch (action)
|
|
|
|
{
|
|
|
|
case ECORE_X_WINDOW_STATE_ACTION_REMOVE:
|
2005-07-04 03:24:22 -07:00
|
|
|
e_border_unshade(bd, e_hints_window_shade_direction_get(bd));
|
2005-07-21 05:06:29 -07:00
|
|
|
break;
|
|
|
|
case ECORE_X_WINDOW_STATE_ACTION_ADD:
|
|
|
|
e_border_shade(bd, e_hints_window_shade_direction_get(bd));
|
|
|
|
break;
|
|
|
|
case ECORE_X_WINDOW_STATE_ACTION_TOGGLE:
|
|
|
|
if (bd->shaded)
|
|
|
|
e_border_unshade(bd, e_hints_window_shade_direction_get(bd));
|
|
|
|
else
|
|
|
|
e_border_shade(bd, e_hints_window_shade_direction_get(bd));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
2005-05-02 02:19:55 -07:00
|
|
|
case ECORE_X_WINDOW_STATE_SKIP_TASKBAR:
|
2005-07-21 05:06:29 -07:00
|
|
|
switch (action)
|
|
|
|
{
|
|
|
|
case ECORE_X_WINDOW_STATE_ACTION_REMOVE:
|
|
|
|
if (bd->client.netwm.state.skip_taskbar)
|
|
|
|
{
|
|
|
|
bd->client.netwm.state.skip_taskbar = 0;
|
2005-08-29 16:04:21 -07:00
|
|
|
bd->client.netwm.update.state = 1;
|
|
|
|
bd->changed = 1;
|
2005-07-21 05:06:29 -07:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ECORE_X_WINDOW_STATE_ACTION_ADD:
|
|
|
|
if (!bd->client.netwm.state.skip_taskbar)
|
|
|
|
{
|
|
|
|
bd->client.netwm.state.skip_taskbar = 1;
|
2005-08-29 16:04:21 -07:00
|
|
|
bd->client.netwm.update.state = 1;
|
|
|
|
bd->changed = 1;
|
2005-07-21 05:06:29 -07:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ECORE_X_WINDOW_STATE_ACTION_TOGGLE:
|
|
|
|
bd->client.netwm.state.skip_taskbar = !bd->client.netwm.state.skip_taskbar;
|
2005-08-29 16:04:21 -07:00
|
|
|
bd->client.netwm.update.state = 1;
|
|
|
|
bd->changed = 1;
|
2005-07-21 05:06:29 -07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
2005-05-02 02:19:55 -07:00
|
|
|
case ECORE_X_WINDOW_STATE_SKIP_PAGER:
|
2005-07-21 05:06:29 -07:00
|
|
|
switch (action)
|
|
|
|
{
|
|
|
|
case ECORE_X_WINDOW_STATE_ACTION_REMOVE:
|
|
|
|
if (bd->client.netwm.state.skip_pager)
|
|
|
|
{
|
|
|
|
bd->client.netwm.state.skip_pager = 0;
|
2005-08-29 16:04:21 -07:00
|
|
|
bd->client.netwm.update.state = 1;
|
|
|
|
bd->changed = 1;
|
2005-07-21 05:06:29 -07:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ECORE_X_WINDOW_STATE_ACTION_ADD:
|
|
|
|
if (!bd->client.netwm.state.skip_pager)
|
|
|
|
{
|
|
|
|
bd->client.netwm.state.skip_pager = 1;
|
2005-08-29 16:04:21 -07:00
|
|
|
bd->client.netwm.update.state = 1;
|
|
|
|
bd->changed = 1;
|
2005-07-21 05:06:29 -07:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ECORE_X_WINDOW_STATE_ACTION_TOGGLE:
|
|
|
|
bd->client.netwm.state.skip_pager = !bd->client.netwm.state.skip_pager;
|
2005-08-29 16:04:21 -07:00
|
|
|
bd->client.netwm.update.state = 1;
|
|
|
|
bd->changed = 1;
|
2005-07-21 05:06:29 -07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
2005-05-02 02:19:55 -07:00
|
|
|
case ECORE_X_WINDOW_STATE_HIDDEN:
|
2005-07-21 05:06:29 -07:00
|
|
|
/* Ignore */
|
|
|
|
break;
|
2005-05-02 02:19:55 -07:00
|
|
|
case ECORE_X_WINDOW_STATE_FULLSCREEN:
|
2005-08-21 16:36:07 -07:00
|
|
|
if (bd->lock_client_fullscreen) return;
|
2005-07-21 05:06:29 -07:00
|
|
|
switch (action)
|
|
|
|
{
|
|
|
|
case ECORE_X_WINDOW_STATE_ACTION_REMOVE:
|
2005-07-04 03:24:22 -07:00
|
|
|
e_border_unfullscreen(bd);
|
2005-07-21 05:06:29 -07:00
|
|
|
break;
|
|
|
|
case ECORE_X_WINDOW_STATE_ACTION_ADD:
|
2005-11-04 15:30:18 -08:00
|
|
|
e_border_fullscreen(bd, e_config->fullscreen_policy);
|
2005-07-21 05:06:29 -07:00
|
|
|
break;
|
|
|
|
case ECORE_X_WINDOW_STATE_ACTION_TOGGLE:
|
|
|
|
if (bd->fullscreen)
|
|
|
|
e_border_unfullscreen(bd);
|
|
|
|
else
|
2005-11-04 15:30:18 -08:00
|
|
|
e_border_fullscreen(bd, e_config->fullscreen_policy);
|
2005-07-21 05:06:29 -07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
2005-05-02 02:19:55 -07:00
|
|
|
case ECORE_X_WINDOW_STATE_ABOVE:
|
2005-08-21 16:36:07 -07:00
|
|
|
if (bd->lock_client_stacking) return;
|
2005-07-21 05:06:29 -07:00
|
|
|
/* FIXME: Should this require that BELOW is set to 0 first, or just
|
|
|
|
* do it? */
|
|
|
|
switch (action)
|
|
|
|
{
|
|
|
|
case ECORE_X_WINDOW_STATE_ACTION_REMOVE:
|
2005-09-02 00:38:40 -07:00
|
|
|
e_border_layer_set(bd, 100);
|
2005-07-21 05:06:29 -07:00
|
|
|
break;
|
|
|
|
case ECORE_X_WINDOW_STATE_ACTION_ADD:
|
2005-09-02 00:38:40 -07:00
|
|
|
e_border_layer_set(bd, 150);
|
2005-07-21 05:06:29 -07:00
|
|
|
break;
|
|
|
|
case ECORE_X_WINDOW_STATE_ACTION_TOGGLE:
|
|
|
|
if (bd->layer == 150)
|
2005-09-02 00:38:40 -07:00
|
|
|
e_border_layer_set(bd, 100);
|
2005-07-21 05:06:29 -07:00
|
|
|
else
|
2005-09-02 00:38:40 -07:00
|
|
|
e_border_layer_set(bd, 150);
|
2005-07-21 05:06:29 -07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
2005-05-02 02:19:55 -07:00
|
|
|
case ECORE_X_WINDOW_STATE_BELOW:
|
2005-08-21 16:36:07 -07:00
|
|
|
if (bd->lock_client_stacking) return;
|
2005-07-21 05:06:29 -07:00
|
|
|
/* FIXME: Should this require that ABOVE is set to 0 first, or just
|
|
|
|
* do it? */
|
|
|
|
switch (action)
|
|
|
|
{
|
|
|
|
case ECORE_X_WINDOW_STATE_ACTION_REMOVE:
|
2005-09-02 00:38:40 -07:00
|
|
|
e_border_layer_set(bd, 100);
|
2005-07-21 05:06:29 -07:00
|
|
|
break;
|
|
|
|
case ECORE_X_WINDOW_STATE_ACTION_ADD:
|
2005-09-02 00:38:40 -07:00
|
|
|
e_border_layer_set(bd, 50);
|
2005-07-21 05:06:29 -07:00
|
|
|
break;
|
|
|
|
case ECORE_X_WINDOW_STATE_ACTION_TOGGLE:
|
|
|
|
if (bd->layer == 50)
|
2005-09-02 00:38:40 -07:00
|
|
|
e_border_layer_set(bd, 100);
|
2005-07-21 05:06:29 -07:00
|
|
|
else
|
2005-09-02 00:38:40 -07:00
|
|
|
e_border_layer_set(bd, 50);
|
2005-07-21 05:06:29 -07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
2005-05-02 02:19:55 -07:00
|
|
|
case ECORE_X_WINDOW_STATE_DEMANDS_ATTENTION:
|
2005-07-21 05:06:29 -07:00
|
|
|
/* FIXME */
|
|
|
|
break;
|
2005-05-02 02:19:55 -07:00
|
|
|
case ECORE_X_WINDOW_STATE_UNKNOWN:
|
2005-07-21 05:06:29 -07:00
|
|
|
/* Ignore */
|
|
|
|
break;
|
2005-05-02 02:19:55 -07:00
|
|
|
}
|
|
|
|
}
|
2005-04-29 01:02:29 -07:00
|
|
|
|
2005-02-07 05:51:09 -08:00
|
|
|
void
|
2005-04-29 01:02:29 -07:00
|
|
|
e_hints_window_state_get(E_Border *bd)
|
2005-02-15 04:11:31 -08:00
|
|
|
{
|
2005-06-07 08:35:18 -07:00
|
|
|
unsigned int i, num;
|
2005-05-29 03:08:25 -07:00
|
|
|
Ecore_X_Window_State *state;
|
2005-02-15 04:11:31 -08:00
|
|
|
|
2005-05-29 03:08:25 -07:00
|
|
|
bd->client.netwm.state.modal = 0;
|
|
|
|
bd->client.netwm.state.sticky = 0;
|
|
|
|
bd->client.netwm.state.maximized_v = 0;
|
|
|
|
bd->client.netwm.state.maximized_h = 0;
|
|
|
|
bd->client.netwm.state.shaded = 0;
|
|
|
|
bd->client.netwm.state.skip_taskbar = 0;
|
|
|
|
bd->client.netwm.state.skip_pager = 0;
|
|
|
|
bd->client.netwm.state.hidden = 0;
|
|
|
|
bd->client.netwm.state.fullscreen = 0;
|
|
|
|
bd->client.netwm.state.stacking = 0;
|
|
|
|
|
2005-06-07 08:35:18 -07:00
|
|
|
ecore_x_netwm_window_state_get(bd->client.win, &state, &num);
|
2005-05-29 03:08:25 -07:00
|
|
|
if (state)
|
|
|
|
{
|
|
|
|
for (i = 0; i < num; i++)
|
|
|
|
{
|
|
|
|
switch (state[i])
|
|
|
|
{
|
|
|
|
case ECORE_X_WINDOW_STATE_ICONIFIED:
|
2005-07-04 03:24:22 -07:00
|
|
|
/* Ignore */
|
|
|
|
break;
|
2005-05-29 03:08:25 -07:00
|
|
|
case ECORE_X_WINDOW_STATE_MODAL:
|
2005-07-04 03:24:22 -07:00
|
|
|
bd->client.netwm.state.modal = 1;
|
|
|
|
break;
|
2005-05-29 03:08:25 -07:00
|
|
|
case ECORE_X_WINDOW_STATE_STICKY:
|
2005-07-04 03:24:22 -07:00
|
|
|
bd->client.netwm.state.sticky = 1;
|
|
|
|
break;
|
2005-05-29 03:08:25 -07:00
|
|
|
case ECORE_X_WINDOW_STATE_MAXIMIZED_VERT:
|
2005-07-04 03:24:22 -07:00
|
|
|
bd->client.netwm.state.maximized_v = 1;
|
|
|
|
break;
|
2005-05-29 03:08:25 -07:00
|
|
|
case ECORE_X_WINDOW_STATE_MAXIMIZED_HORZ:
|
2005-07-04 03:24:22 -07:00
|
|
|
bd->client.netwm.state.maximized_h = 1;
|
|
|
|
break;
|
2005-05-29 03:08:25 -07:00
|
|
|
case ECORE_X_WINDOW_STATE_SHADED:
|
2005-07-04 03:24:22 -07:00
|
|
|
bd->client.netwm.state.shaded = 1;
|
|
|
|
break;
|
2005-05-29 03:08:25 -07:00
|
|
|
case ECORE_X_WINDOW_STATE_SKIP_TASKBAR:
|
2005-07-04 03:24:22 -07:00
|
|
|
bd->client.netwm.state.skip_taskbar = 1;
|
|
|
|
break;
|
2005-05-29 03:08:25 -07:00
|
|
|
case ECORE_X_WINDOW_STATE_SKIP_PAGER:
|
2005-07-04 03:24:22 -07:00
|
|
|
bd->client.netwm.state.skip_pager = 1;
|
|
|
|
break;
|
2005-05-29 03:08:25 -07:00
|
|
|
case ECORE_X_WINDOW_STATE_HIDDEN:
|
2005-07-04 03:24:22 -07:00
|
|
|
bd->client.netwm.state.hidden = 1;
|
|
|
|
break;
|
2005-05-29 03:08:25 -07:00
|
|
|
case ECORE_X_WINDOW_STATE_FULLSCREEN:
|
2005-07-04 03:24:22 -07:00
|
|
|
bd->client.netwm.state.fullscreen = 1;
|
|
|
|
break;
|
2005-05-29 03:08:25 -07:00
|
|
|
case ECORE_X_WINDOW_STATE_ABOVE:
|
2005-07-04 03:24:22 -07:00
|
|
|
bd->client.netwm.state.stacking = E_STACKING_ABOVE;
|
|
|
|
break;
|
2005-05-29 03:08:25 -07:00
|
|
|
case ECORE_X_WINDOW_STATE_BELOW:
|
2005-07-04 03:24:22 -07:00
|
|
|
bd->client.netwm.state.stacking = E_STACKING_BELOW;
|
|
|
|
break;
|
2005-05-29 03:08:25 -07:00
|
|
|
case ECORE_X_WINDOW_STATE_DEMANDS_ATTENTION:
|
2005-07-04 03:24:22 -07:00
|
|
|
/* FIXME */
|
|
|
|
break;
|
2005-05-29 03:08:25 -07:00
|
|
|
case ECORE_X_WINDOW_STATE_UNKNOWN:
|
2005-07-04 03:24:22 -07:00
|
|
|
/* Ignore */
|
|
|
|
break;
|
2005-05-29 03:08:25 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
free(state);
|
|
|
|
}
|
2005-02-15 04:11:31 -08:00
|
|
|
}
|
|
|
|
|
2005-05-29 04:37:18 -07:00
|
|
|
void
|
2005-04-29 01:37:09 -07:00
|
|
|
e_hints_window_visible_set(E_Border *bd)
|
2005-02-15 04:11:31 -08:00
|
|
|
{
|
2005-04-29 01:37:09 -07:00
|
|
|
if (bd->client.icccm.state != ECORE_X_WINDOW_STATE_HINT_NORMAL)
|
|
|
|
{
|
|
|
|
ecore_x_icccm_state_set(bd->client.win, ECORE_X_WINDOW_STATE_HINT_NORMAL);
|
|
|
|
bd->client.icccm.state = ECORE_X_WINDOW_STATE_HINT_NORMAL;
|
|
|
|
}
|
|
|
|
if (bd->client.netwm.state.hidden)
|
|
|
|
{
|
2005-05-30 23:52:05 -07:00
|
|
|
bd->client.netwm.update.state = 1;
|
2005-04-29 01:37:09 -07:00
|
|
|
bd->client.netwm.state.hidden = 0;
|
2005-06-05 08:30:46 -07:00
|
|
|
bd->changed = 1;
|
2005-04-29 01:37:09 -07:00
|
|
|
}
|
2005-02-15 04:11:31 -08:00
|
|
|
}
|
|
|
|
|
2005-05-29 04:37:18 -07:00
|
|
|
void
|
2005-04-29 01:37:09 -07:00
|
|
|
e_hints_window_iconic_set(E_Border *bd)
|
2005-02-15 04:11:31 -08:00
|
|
|
{
|
2005-04-29 01:37:09 -07:00
|
|
|
if (bd->client.icccm.state != ECORE_X_WINDOW_STATE_HINT_ICONIC)
|
|
|
|
{
|
|
|
|
ecore_x_icccm_state_set(bd->client.win, ECORE_X_WINDOW_STATE_HINT_ICONIC);
|
|
|
|
bd->client.icccm.state = ECORE_X_WINDOW_STATE_HINT_ICONIC;
|
|
|
|
}
|
|
|
|
if (!bd->client.netwm.state.hidden)
|
|
|
|
{
|
2005-05-30 23:52:05 -07:00
|
|
|
bd->client.netwm.update.state = 1;
|
2005-04-29 01:37:09 -07:00
|
|
|
bd->client.netwm.state.hidden = 1;
|
2005-06-05 08:30:46 -07:00
|
|
|
bd->changed = 1;
|
2005-04-29 01:37:09 -07:00
|
|
|
}
|
2005-02-15 04:11:31 -08:00
|
|
|
}
|
|
|
|
|
2005-05-29 04:37:18 -07:00
|
|
|
void
|
2005-04-29 01:37:09 -07:00
|
|
|
e_hints_window_hidden_set(E_Border *bd)
|
2005-02-07 05:51:09 -08:00
|
|
|
{
|
2005-05-17 06:13:30 -07:00
|
|
|
if (bd->client.icccm.state != ECORE_X_WINDOW_STATE_HINT_ICONIC)
|
2005-04-29 01:37:09 -07:00
|
|
|
{
|
2005-05-17 06:13:30 -07:00
|
|
|
ecore_x_icccm_state_set(bd->client.win, ECORE_X_WINDOW_STATE_HINT_ICONIC);
|
|
|
|
bd->client.icccm.state = ECORE_X_WINDOW_STATE_HINT_ICONIC;
|
2005-04-29 01:37:09 -07:00
|
|
|
}
|
2005-05-17 06:13:30 -07:00
|
|
|
if (bd->client.netwm.state.hidden)
|
2005-04-29 01:37:09 -07:00
|
|
|
{
|
2005-05-30 23:52:05 -07:00
|
|
|
bd->client.netwm.update.state = 1;
|
2005-05-17 06:13:30 -07:00
|
|
|
bd->client.netwm.state.hidden = 0;
|
2005-06-05 08:30:46 -07:00
|
|
|
bd->changed = 1;
|
2005-04-29 01:37:09 -07:00
|
|
|
}
|
2005-02-15 04:11:31 -08:00
|
|
|
}
|
2005-02-07 05:51:09 -08:00
|
|
|
|
2005-05-29 04:37:18 -07:00
|
|
|
void
|
2005-04-29 01:37:09 -07:00
|
|
|
e_hints_window_shaded_set(E_Border *bd, int on)
|
2005-02-07 05:51:09 -08:00
|
|
|
{
|
2005-04-29 01:37:09 -07:00
|
|
|
if ((!bd->client.netwm.state.shaded) && (on))
|
|
|
|
{
|
2005-05-30 23:52:05 -07:00
|
|
|
bd->client.netwm.update.state = 1;
|
2005-04-29 01:37:09 -07:00
|
|
|
bd->client.netwm.state.shaded = 1;
|
2005-06-05 08:30:46 -07:00
|
|
|
bd->changed = 1;
|
2005-04-29 01:37:09 -07:00
|
|
|
}
|
|
|
|
else if ((bd->client.netwm.state.shaded) && (!on))
|
|
|
|
{
|
2005-05-30 23:52:05 -07:00
|
|
|
bd->client.netwm.update.state = 1;
|
2005-04-29 01:37:09 -07:00
|
|
|
bd->client.netwm.state.shaded = 0;
|
2005-06-05 08:30:46 -07:00
|
|
|
bd->changed = 1;
|
2005-04-29 01:37:09 -07:00
|
|
|
}
|
2005-02-07 05:51:09 -08:00
|
|
|
}
|
|
|
|
|
2005-05-29 04:37:18 -07:00
|
|
|
void
|
2005-04-29 01:37:09 -07:00
|
|
|
e_hints_window_shade_direction_set(E_Border *bd, E_Direction dir)
|
2005-02-15 04:11:31 -08:00
|
|
|
{
|
2005-04-29 01:37:09 -07:00
|
|
|
ecore_x_window_prop_card32_set(bd->client.win, E_ATOM_SHADE_DIRECTION, &dir, 1);
|
2005-02-15 04:11:31 -08:00
|
|
|
}
|
|
|
|
|
2005-05-29 04:37:18 -07:00
|
|
|
E_Direction
|
2005-04-29 01:37:09 -07:00
|
|
|
e_hints_window_shade_direction_get(E_Border *bd)
|
2005-02-15 04:11:31 -08:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
E_Direction dir;
|
|
|
|
|
2005-04-29 01:37:09 -07:00
|
|
|
ret = ecore_x_window_prop_card32_get(bd->client.win,
|
2005-05-29 03:08:25 -07:00
|
|
|
E_ATOM_SHADE_DIRECTION,
|
|
|
|
&dir, 1);
|
2005-02-15 04:11:31 -08:00
|
|
|
if (ret == 1)
|
|
|
|
return dir;
|
|
|
|
|
|
|
|
return E_DIRECTION_UP;
|
|
|
|
}
|
|
|
|
|
2005-07-10 10:12:01 -07:00
|
|
|
void
|
2005-08-10 21:44:08 -07:00
|
|
|
e_hints_window_size_set(E_Border *bd)
|
2005-07-10 10:12:01 -07:00
|
|
|
{
|
|
|
|
unsigned int sizes[4];
|
|
|
|
|
2005-08-10 21:44:08 -07:00
|
|
|
sizes[0] = bd->x;
|
|
|
|
sizes[1] = bd->y;
|
|
|
|
sizes[2] = bd->w;
|
|
|
|
sizes[3] = bd->h;
|
|
|
|
ecore_x_window_prop_card32_set(bd->client.win, E_ATOM_BORDER_SIZE, sizes, 4);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
e_hints_window_size_unset(E_Border *bd)
|
|
|
|
{
|
|
|
|
ecore_x_window_prop_property_del(bd->client.win, E_ATOM_BORDER_SIZE);
|
2005-07-10 10:12:01 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2005-08-10 21:44:08 -07:00
|
|
|
e_hints_window_size_get(E_Border *bd)
|
2005-07-10 10:12:01 -07:00
|
|
|
{
|
|
|
|
int ret;
|
2005-07-30 00:46:05 -07:00
|
|
|
unsigned int sizes[4];
|
2005-07-10 10:12:01 -07:00
|
|
|
|
|
|
|
memset(sizes, 0, sizeof(sizes));
|
2005-08-10 21:44:08 -07:00
|
|
|
ret = ecore_x_window_prop_card32_get(bd->client.win, E_ATOM_BORDER_SIZE,
|
2005-07-10 10:12:01 -07:00
|
|
|
sizes, 4);
|
2005-08-10 21:44:08 -07:00
|
|
|
if (ret != 4)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
bd->x = sizes[0];
|
|
|
|
bd->y = sizes[1];
|
|
|
|
bd->w = sizes[2];
|
|
|
|
bd->h = sizes[3];
|
2005-07-10 10:12:01 -07:00
|
|
|
|
2005-08-10 21:44:08 -07:00
|
|
|
return 1;
|
2005-07-10 10:12:01 -07:00
|
|
|
}
|
|
|
|
|
2005-05-29 04:37:18 -07:00
|
|
|
void
|
2005-04-29 01:37:09 -07:00
|
|
|
e_hints_window_maximized_set(E_Border *bd, int on)
|
2005-02-07 05:51:09 -08:00
|
|
|
{
|
2005-11-30 23:10:32 -08:00
|
|
|
|
|
|
|
if( on )
|
|
|
|
{
|
|
|
|
if( bd->maximized == E_MAXIMIZE_VERTICAL )
|
|
|
|
{
|
|
|
|
if( !bd->client.netwm.state.maximized_v )
|
|
|
|
{
|
|
|
|
bd->client.netwm.update.state = 1;
|
|
|
|
bd->client.netwm.state.maximized_v = 1;
|
|
|
|
bd->changed = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if( bd->maximized == E_MAXIMIZE_HORIZONTAL )
|
|
|
|
{
|
|
|
|
if( !bd->client.netwm.state.maximized_h )
|
|
|
|
{
|
|
|
|
bd->client.netwm.update.state = 1;
|
|
|
|
bd->client.netwm.state.maximized_h = 1;
|
|
|
|
bd->changed = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if( !bd->client.netwm.state.maximized_v )
|
|
|
|
{
|
|
|
|
bd->client.netwm.update.state = 1;
|
|
|
|
bd->client.netwm.state.maximized_v = 1;
|
|
|
|
bd->changed = 1;
|
|
|
|
}
|
|
|
|
if( !bd->client.netwm.state.maximized_h )
|
|
|
|
{
|
|
|
|
bd->client.netwm.update.state = 1;
|
|
|
|
bd->client.netwm.state.maximized_h = 1;
|
|
|
|
bd->changed = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if( bd->client.netwm.state.maximized_v )
|
|
|
|
{
|
|
|
|
bd->client.netwm.update.state = 1;
|
|
|
|
bd->client.netwm.state.maximized_v = 0;
|
|
|
|
bd->changed = 1;
|
|
|
|
}
|
|
|
|
if( bd->client.netwm.state.maximized_h )
|
|
|
|
{
|
|
|
|
bd->client.netwm.update.state = 1;
|
|
|
|
bd->client.netwm.state.maximized_h = 0;
|
|
|
|
bd->changed = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*if ((!bd->client.netwm.state.maximized_v) && (on))
|
2005-04-29 01:37:09 -07:00
|
|
|
{
|
2005-05-30 23:52:05 -07:00
|
|
|
bd->client.netwm.update.state = 1;
|
2005-04-29 01:37:09 -07:00
|
|
|
bd->client.netwm.state.maximized_v = 1;
|
2005-06-05 08:30:46 -07:00
|
|
|
bd->changed = 1;
|
2005-04-29 01:37:09 -07:00
|
|
|
}
|
|
|
|
else if ((bd->client.netwm.state.maximized_v) && (!on))
|
|
|
|
{
|
2005-05-30 23:52:05 -07:00
|
|
|
bd->client.netwm.update.state = 1;
|
2005-04-29 01:37:09 -07:00
|
|
|
bd->client.netwm.state.maximized_v = 0;
|
2005-06-05 08:30:46 -07:00
|
|
|
bd->changed = 1;
|
2005-04-29 01:37:09 -07:00
|
|
|
}
|
|
|
|
if ((!bd->client.netwm.state.maximized_h) && (on))
|
|
|
|
{
|
2005-05-30 23:52:05 -07:00
|
|
|
bd->client.netwm.update.state = 1;
|
2005-04-29 01:37:09 -07:00
|
|
|
bd->client.netwm.state.maximized_h = 1;
|
2005-06-05 08:30:46 -07:00
|
|
|
bd->changed = 1;
|
2005-04-29 01:37:09 -07:00
|
|
|
}
|
|
|
|
else if ((bd->client.netwm.state.maximized_h) && (!on))
|
|
|
|
{
|
2005-05-30 23:52:05 -07:00
|
|
|
bd->client.netwm.update.state = 1;
|
2005-04-29 01:37:09 -07:00
|
|
|
bd->client.netwm.state.maximized_h = 0;
|
2005-06-05 08:30:46 -07:00
|
|
|
bd->changed = 1;
|
2005-11-30 23:10:32 -08:00
|
|
|
}*/
|
2005-02-07 05:51:09 -08:00
|
|
|
}
|
|
|
|
|
2005-05-29 04:37:18 -07:00
|
|
|
void
|
2005-04-29 01:37:09 -07:00
|
|
|
e_hints_window_fullscreen_set(E_Border *bd, int on)
|
2005-04-28 05:26:58 -07:00
|
|
|
{
|
2005-04-29 01:37:09 -07:00
|
|
|
if ((!bd->client.netwm.state.fullscreen) && (on))
|
|
|
|
{
|
2005-05-30 23:52:05 -07:00
|
|
|
bd->client.netwm.update.state = 1;
|
2005-04-29 01:37:09 -07:00
|
|
|
bd->client.netwm.state.fullscreen = 1;
|
2005-06-05 08:30:46 -07:00
|
|
|
bd->changed = 1;
|
2005-04-29 01:37:09 -07:00
|
|
|
}
|
|
|
|
else if ((bd->client.netwm.state.fullscreen) && (!on))
|
|
|
|
{
|
2005-05-30 23:52:05 -07:00
|
|
|
bd->client.netwm.update.state = 1;
|
2005-04-29 01:37:09 -07:00
|
|
|
bd->client.netwm.state.fullscreen = 0;
|
2005-06-05 08:30:46 -07:00
|
|
|
bd->changed = 1;
|
2005-04-29 01:37:09 -07:00
|
|
|
}
|
2005-04-28 05:26:58 -07:00
|
|
|
}
|
|
|
|
|
2005-05-29 04:37:18 -07:00
|
|
|
void
|
2005-04-29 01:37:09 -07:00
|
|
|
e_hints_window_sticky_set(E_Border *bd, int on)
|
2005-02-07 05:51:09 -08:00
|
|
|
{
|
2005-04-29 01:37:09 -07:00
|
|
|
if ((!bd->client.netwm.state.sticky) && (on))
|
|
|
|
{
|
2005-05-30 23:52:05 -07:00
|
|
|
bd->client.netwm.update.state = 1;
|
2005-04-29 01:37:09 -07:00
|
|
|
bd->client.netwm.state.sticky = 1;
|
2005-06-05 08:30:46 -07:00
|
|
|
bd->changed = 1;
|
2005-04-29 01:37:09 -07:00
|
|
|
}
|
|
|
|
else if ((bd->client.netwm.state.sticky) && (!on))
|
|
|
|
{
|
2005-05-30 23:52:05 -07:00
|
|
|
bd->client.netwm.update.state = 1;
|
2005-04-29 01:37:09 -07:00
|
|
|
bd->client.netwm.state.sticky = 0;
|
2005-06-05 08:30:46 -07:00
|
|
|
bd->changed = 1;
|
2005-04-29 01:37:09 -07:00
|
|
|
}
|
2005-02-07 05:51:09 -08:00
|
|
|
}
|
|
|
|
|
2005-05-29 04:37:18 -07:00
|
|
|
void
|
2005-05-10 03:11:34 -07:00
|
|
|
e_hints_window_stacking_set(E_Border *bd, E_Stacking stacking)
|
|
|
|
{
|
|
|
|
if (bd->client.netwm.state.stacking == stacking) return;
|
2005-05-30 23:52:05 -07:00
|
|
|
bd->client.netwm.update.state = 1;
|
2005-05-10 03:11:34 -07:00
|
|
|
bd->client.netwm.state.stacking = stacking;
|
2005-06-05 08:30:46 -07:00
|
|
|
bd->changed = 1;
|
2005-05-10 03:11:34 -07:00
|
|
|
}
|
|
|
|
|
2005-05-29 04:37:18 -07:00
|
|
|
void
|
2005-05-16 08:43:15 -07:00
|
|
|
e_hints_window_desktop_set(E_Border *bd)
|
|
|
|
{
|
2005-06-17 02:29:27 -07:00
|
|
|
/* This function is only called when really changing desktop,
|
|
|
|
* so just set the property and don't care about the roundtrip.
|
|
|
|
*/
|
2005-05-16 08:43:15 -07:00
|
|
|
unsigned int deskpos[2];
|
2005-05-29 03:08:25 -07:00
|
|
|
|
2005-05-25 01:08:44 -07:00
|
|
|
/* if valgrind complains here it is complaining bd->client.netwm.desktop
|
|
|
|
* is an uninitialised variable - but it isn't. it can't be. its part of
|
|
|
|
* a calloc()'d struct and thus has to have been set to 0. hell even
|
|
|
|
* e_border.c explicitly sets it to 0 on creation of the border object.
|
|
|
|
*/
|
2005-06-17 02:29:27 -07:00
|
|
|
deskpos[0] = bd->desk->x;
|
|
|
|
deskpos[1] = bd->desk->y;
|
|
|
|
ecore_x_window_prop_card32_set(bd->client.win, E_ATOM_DESK, deskpos, 2);
|
2005-05-16 08:43:15 -07:00
|
|
|
|
2005-06-03 05:23:34 -07:00
|
|
|
#if 0
|
2005-06-17 02:29:27 -07:00
|
|
|
ecore_x_netwm_desktop_set(bd->client.win, current);
|
2005-06-03 05:23:34 -07:00
|
|
|
#endif
|
2005-06-17 02:29:27 -07:00
|
|
|
bd->client.netwm.desktop = (bd->desk->y * bd->zone->desk_x_count) + bd->desk->x;
|
2005-05-16 08:43:15 -07:00
|
|
|
}
|
2005-08-29 18:15:25 -07:00
|
|
|
|
|
|
|
void
|
|
|
|
e_hints_window_e_state_get(E_Border *bd)
|
|
|
|
{
|
|
|
|
/* Remember to update the count if we add more states! */
|
|
|
|
Ecore_X_Atom state[1];
|
|
|
|
int num;
|
|
|
|
|
|
|
|
memset(state, 0, sizeof(state));
|
|
|
|
num = ecore_x_window_prop_card32_get(bd->client.win, E_ATOM_WINDOW_STATE, state, 1);
|
|
|
|
if (num)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < num; i++)
|
|
|
|
{
|
|
|
|
if (state[i] == E_ATOM_WINDOW_STATE_CENTERED)
|
|
|
|
bd->client.e.state.centered = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
e_hints_window_e_state_set(E_Border *bd)
|
|
|
|
{
|
|
|
|
/* TODO */
|
|
|
|
}
|
2005-10-06 21:27:51 -07:00
|
|
|
|
|
|
|
void
|
|
|
|
e_hints_openoffice_gnome_fake(Ecore_X_Window root)
|
|
|
|
{
|
|
|
|
Ecore_X_Atom gnome_atom, string_atom;
|
|
|
|
const char *string = "GNOME_SM_PROXY";
|
|
|
|
|
|
|
|
gnome_atom = ecore_x_atom_get("GNOME_SM_PROXY");
|
|
|
|
string_atom = ecore_x_atom_get("STRING");
|
|
|
|
ecore_x_window_prop_property_set(root, gnome_atom, string_atom,
|
|
|
|
8, (void *)string, strlen(string));
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
e_hints_openoffice_kde_fake(Ecore_X_Window root)
|
|
|
|
{
|
|
|
|
Ecore_X_Window win2;
|
|
|
|
|
|
|
|
win2 = ecore_x_window_new(root, -20, -20, 1, 1);
|
|
|
|
ecore_x_netwm_wm_identify(root, win2, "KWin");
|
|
|
|
}
|