static X11Window activeWindow;
static X11Cursor systemCursors[SystemCursor];
+static enum NETWMStateAction { remove = 0, add = 1, toggle = 2 };
+
static enum AtomIdents
{
clipboard, multiple, targets, utf8_string, wm_delete_window, wm_hints, wm_name, wm_protocols, wm_state, wm_take_focus, wm_transient_for,
Visual * xSystemVisual;
bool xSharedMemory;
-static Time timeStamp;
+static void SetNETWMState(X11Window windowHandle, bool throughRoot, NETWMStateAction action, Atom atom1, Atom atom2)
+{
+ if(atomsSupported[_net_wm_state])
+ {
+ int format;
+ unsigned long count, fill;
+ Atom type;
+ char * data = null;
+ uint state = WithdrawnState;
+
+ /*if(XGetWindowProperty(xGlobalDisplay, windowHandle, atoms[wm_state], 0, 3, False,
+ atoms[wm_state], &type, &format, &count, &fill, &data) == Success && count)
+ {
+ state = *(uint *)data;
+ XFree(data);
+ } */
+ if(!throughRoot) //state == WithdrawnState)
+ {
+ // We need to handle modifying these ourselves for withdrawn windows...
+ if(action == add)
+ {
+ Atom values[2] = { atom1, atom2 };
+ XChangeProperty(xGlobalDisplay, windowHandle, atoms[_net_wm_state], XA_ATOM,
+ 32, PropModeAppend, (byte *)values, atom2 ? 2 : 1);
+ }
+ else if(XGetWindowProperty(xGlobalDisplay, windowHandle, atoms[_net_wm_state], 0, 32, False,
+ XA_ATOM, &type, &format, &count, &fill, &data) == Success)
+ {
+ Atom * values = (Atom *) data;
+ int i;
+ for (i = 0; i < count; i++)
+ {
+ if(values[i] == atom1 || (atom2 && values[i] == atom2))
+ {
+ if(i < count - 1)
+ memmove(values + i, values + i + 1, sizeof(Atom) * (count - i - 1));
+ count--;
+ i--;
+ }
+ }
+ XChangeProperty(xGlobalDisplay, windowHandle, atoms[_net_wm_state], XA_ATOM, 32, PropModeReplace, (byte *)values, (int)count);
+ XFree(data);
+ }
+ }
+ else
+ {
+ XClientMessageEvent event = { 0 };
+ event.type = ClientMessage;
+ event.message_type = atoms[_net_wm_state];
+ event.display = xGlobalDisplay;
+ event.serial = 0;
+ event.window = windowHandle;
+ event.send_event = 1;
+ event.format = 32;
+ event.data.l[0] = action;
+ event.data.l[1] = atom1;
+ event.data.l[2] = atom2;
+ XSendEvent(xGlobalDisplay, DefaultRootWindow(xGlobalDisplay), bool::false,
+ SubstructureRedirectMask | SubstructureNotifyMask, (union _XEvent *)&event);
+ }
+ }
+
+}
+
+static X11Time timeStamp;
class XWindowData : struct
{
}
}
+static bool RequestFrameExtents(X11Window windowHandle)
+{
+ if(frameExtentSupported != broken)
+ {
+ // Request decoration frame extents
+ XClientMessageEvent event = { 0 };
+ event.type = ClientMessage;
+ event.message_type = atoms[_net_request_frame_extents];
+ event.display = xGlobalDisplay;
+ event.serial = 0;
+ event.window = windowHandle;
+ event.send_event = 1;
+ event.format = 32;
+
+ if(frameExtentSupported == unknown && !frameExtentRequest)
+ {
+ frameExtentRequest = GetTime();
+ frameExtentWindow = windowHandle;
+ }
+
+ XSendEvent(xGlobalDisplay, DefaultRootWindow(xGlobalDisplay), bool::false,
+ SubstructureRedirectMask | SubstructureNotifyMask, (union _XEvent *)&event);
+ return true;
+ }
+ return false;
+}
+
static bool GetFrameExtents(Window window, bool update)
{
XWindowData windowData = window.windowData;
XInterface::UpdateRootWindow(window);
}
}
+ result = true;
}
XFree(data);
- result = true;
}
return result;
}
+static bool WaitForFrameExtents(Window window)
+{
+ int attempts = 0;
+ //XFlush(xGlobalDisplay);
+ while(attempts++ < 10)
+ {
+ if(GetFrameExtents(window, false)) return true;
+ Sleep(1.0 / RESOLUTION);
+ }
+ return false;
+}
+
/****************************************************************************
/// DRIVER IMPLEMENTATION /////////////
****************************************************************************/
}
/*
struct shmid_ds info;
- int maxid = shmctl (0, SHM_INFO, &info);
+ int maxid = shmctl (0, SHM_INFO, &info);
int pid = getpgrp();
int thisPid = getpid();
//if(thisPid == pid)
if(maxid >= 0)
{
int id;
- for(id = 0; id <= maxid; id++)
+ for(id = 0; id <= maxid; id++)
{
- struct shmid_ds shmseg;
+ struct shmid_ds shmseg;
int shmid;
- if((shmid = shmctl(id, SHM_STAT, &shmseg)) >= 0)
+ if((shmid = shmctl(id, SHM_STAT, &shmseg)) >= 0)
{
if(shmseg.shm_cpid == pid || shmseg.shm_cpid == thisPid)
{
#endif
xTerminate = false;
xGlobalDisplay = XOpenDisplay(null);
+ // XSynchronize(xGlobalDisplay, True);
frameExtentSupported = unknown;
- joystickFD[0] = open("/dev/js0", O_RDONLY);
+ joystickFD[0] = open("/dev/js0", O_RDONLY);
joystickFD[1] = open("/dev/js1", O_RDONLY);
joystickFD[2] = open("/dev/js2", O_RDONLY);
joystickFD[3] = open("/dev/js3", O_RDONLY);
case KeyPress:
{
XKeyEvent * event = (XKeyEvent *) thisEvent;
+ incref window;
+ timeStamp = event->time;
+ if(!window.active)
+ {
+ Window modalRoot = window.FindModal();
+ XWindowData windowData;
+
+ activeWindow = (X11Window)window.windowHandle;
+
+ if(!window.parent || window != window.parent.activeChild)
+ {
+ if(modalRoot)
+ modalRoot.ExternalActivate(true, true, window, null);
+ else
+ window.ExternalActivate(true, true, window, null); // lastActive);
+ windowData = modalRoot ? modalRoot.windowData : window.windowData;
+ if(windowData && windowData.ic)
+ {
+ // XSetICValues(ic, XNClientWindow, window.windowHandle, XNFocusWindow, window.windowHandle, 0);
+ XSetICFocus(windowData.ic);
+ }
+ }
+ }
//*XUnlockDisplay(xGlobalDisplay);
ProcessKeyMessage(window, event->keycode, (event->keycode == lastKeyCode) ? 2 : 0, event);
//*if(xGlobalDisplay) XLockDisplay(xGlobalDisplay);
lastKeyCode = event->keycode;
+ delete window;
break;
}
case KeyRelease:
XKeyEvent * event = (XKeyEvent *) thisEvent;
XEvent nextEvent;
lastKeyCode = 0;
+ timeStamp = event->time;
if(!autoRepeatDetectable && XCheckIfEvent(xGlobalDisplay, (XEvent *)&nextEvent, EventChecker, (void *)KeyPress))
{
if(im && XFilterEvent(&nextEvent, None))
uint button, buttonDouble, whichButton;
uint buttonMask;
int x = event->x_root, y = event->y_root;
-
+ timeStamp = event->time;
if(event->button == Button1)
{
// Force a raise on click here to deal with confused active state preventing to bring the window up
if(!atomsSupported[_net_active_window] && !window.isRemote)
- {
XRaiseWindow(xGlobalDisplay, (X11Window)window.windowHandle);
- XSetInputFocus(xGlobalDisplay, (X11Window)window.windowHandle, RevertToPointerRoot, CurrentTime);
- }
+ XSetInputFocus(xGlobalDisplay, (X11Window)window.windowHandle, RevertToPointerRoot, CurrentTime);
button = __ecereVMethodID___ecereNameSpace__ecere__gui__Window_OnLeftButtonDown;
buttonDouble = __ecereVMethodID___ecereNameSpace__ecere__gui__Window_OnLeftDoubleClick;
whichButton = 0;
button = __ecereVMethodID___ecereNameSpace__ecere__gui__Window_OnMiddleButtonUp;
buttonMask = Button2Mask;
}
+ timeStamp = event->time;
if(!(event->state & buttonMask)) break;
if(event->state & ShiftMask) keyFlags.shift = true;
if(event->state & ControlMask) keyFlags.ctrl = true;
// if(event->time - lastTime > 15)
{
Modifiers keyFlags = 0;
+ timeStamp = event->time;
// int x = event->x_root, y = event->y_root;
if(event->state & ShiftMask) keyFlags.shift = true;
{
XExposeEvent * event = (XExposeEvent *) thisEvent;
Box box;
- box.left = event->x - window.clientStart.x;
- box.top = event->y - window.clientStart.y;
+ box.left = event->x;
+ box.top = event->y;
box.right = box.left + event->width - 1;
box.bottom = box.top + event->height - 1;
- window.Update(box);
- box.left += window.clientStart.x;
- box.top += window.clientStart.y;
- box.right += window.clientStart.x;
- box.bottom += window.clientStart.y;
window.UpdateDirty(box);
break;
}
case SelectionRequest:
{
- XSelectionRequestEvent *req = (XSelectionRequestEvent *) thisEvent;
- XEvent respond;
- if(req->target == atoms[targets] && clipBoardData)
+ XSelectionRequestEvent *req = (XSelectionRequestEvent *) thisEvent;
+ XEvent respond;
+ if(req->target == atoms[targets] && clipBoardData)
{
Atom * supportedTargets = new Atom[4];
supportedTargets[0] = atoms[targets];
supportedTargets[2] = XA_STRING;
supportedTargets[3] = atoms[utf8_string];
XChangeProperty(xGlobalDisplay,req->requestor, req->_property,
- XA_ATOM,32,PropModeReplace, (byte *) supportedTargets, 4*sizeof(Atom));
+ XA_ATOM,32,PropModeReplace, (byte *) supportedTargets, 4*sizeof(Atom));
respond.xselection._property = req->_property;
delete supportedTargets;
}
else if((req->target == XA_STRING || req->target == atoms[utf8_string]) && clipBoardData)
- {
+ {
Atom _property = (req->_property == None) ? req->target : req->_property;
- XChangeProperty(xGlobalDisplay,req->requestor, _property,
- req->target/*req->_property*/,8,PropModeReplace, (byte *) clipBoardData, strlen(clipBoardData));
- respond.xselection._property = _property;
- }
+ XChangeProperty(xGlobalDisplay,req->requestor, _property,
+ req->target/*req->_property*/,8,PropModeReplace, (byte *) clipBoardData, strlen(clipBoardData));
+ respond.xselection._property = _property;
+ }
else
- respond.xselection._property = None;
+ respond.xselection._property = None;
respond.xselection.type = SelectionNotify;
- respond.xselection.display = req->display;
- respond.xselection.requestor = req->requestor;
- respond.xselection.selection =req->selection;
- respond.xselection.target = req->target;
- respond.xselection.time = CurrentTime;
- XSendEvent(xGlobalDisplay, req->requestor,0,0,&respond);
+ respond.xselection.display = req->display;
+ respond.xselection.requestor = req->requestor;
+ respond.xselection.selection =req->selection;
+ respond.xselection.target = req->target;
+ respond.xselection.time = CurrentTime;
+ XSendEvent(xGlobalDisplay, req->requestor,0,0,&respond);
break;
}
case SelectionClear:
case ConfigureNotify:
{
XConfigureEvent * event = (XConfigureEvent *) thisEvent;
+ bool unmaximized = false;
while(XCheckIfEvent(xGlobalDisplay, (XEvent *)thisEvent, (void *)ConfigureNotifyChecker, (void *)window.windowHandle));
//if(event->x - desktopX != window.position.x || event->y - desktopY != window.position.y || event->width != window.size.w || event->height != window.size.h)
- if(window.nativeDecorations)
+ if(atomsSupported[_net_wm_state]) //window.nativeDecorations)
{
int format;
unsigned long len, fill;
if(maxVert && maxHorz)
{
if(window.state != maximized)
+ {
*&window.state = maximized;
+ if(!window.nativeDecorations)
+ window.CreateSystemChildren();
+ }
}
else if(isMinimized)
{
if(window.state != minimized)
+ {
*&window.state = minimized;
+ if(!window.nativeDecorations)
+ window.CreateSystemChildren();
+ }
}
else if(window.state != normal)
+ {
+ if(window.state == maximized)
+ unmaximized = true;
*&window.state = normal;
+ if(!window.nativeDecorations)
+ window.CreateSystemChildren();
+ }
}
}
{
- int x = event->x;
- int y = event->y;
- int w = event->width, h = event->height;
+ bool offset = false;
+ int x, y, w, h;
+ if(unmaximized && window.nativeDecorations)
+ {
+ if(window.nativeDecorations && RequestFrameExtents((X11Window)window.windowHandle))
+ WaitForFrameExtents(window);
- //if(event->send_event)
+ // Ensure we set the normal size anchor when un-maximizing
+ window.ComputeAnchors(window.normalAnchor, window.normalSizeAnchor, &x, &y, &w, &h);
+ }
+ else
{
- X11Window rootChild;
- int rootX, rootY;
- XTranslateCoordinates(xGlobalDisplay, event->window,
- RootWindow(xGlobalDisplay, DefaultScreen(xGlobalDisplay)), 0, 0,
- &rootX, &rootY, &rootChild);
- x = rootX;
- y = rootY;
+ x = event->x;
+ y = event->y;
+ w = event->width, h = event->height;
+
+ //if(event->send_event)
+ {
+ X11Window rootChild;
+ int rootX, rootY;
+ XTranslateCoordinates(xGlobalDisplay, event->window,
+ RootWindow(xGlobalDisplay, DefaultScreen(xGlobalDisplay)), 0, 0,
+ &rootX, &rootY, &rootChild);
+
+ if(x != rootX || y != rootY)
+ {
+ /*if(event->send_event)
+ offset = true;*/
+ x = rootX;
+ y = rootY;
+ }
+ }
+
+ x -= desktopX;
+ y -= desktopY;
+
+ if(window.nativeDecorations && window.state != maximized)
+ {
+ x -= windowData.decor.left;
+ y -= windowData.decor.top;
+ w += windowData.decor.left + windowData.decor.right;
+ h += windowData.decor.top + windowData.decor.bottom;
+
+ /*
+ x -= window.clientStart.x;
+ y -= window.clientStart.y - (window.hasMenuBar ? skinMenuHeight : 0);
+ w += window.size.w - window.clientSize.w;
+ h += window.size.h - window.clientSize.h;
+ */
+ }
}
- x -= desktopX;
- y -= desktopY;
+ window.Position(x, y, w, h, true, true, true, true, false, unmaximized);
- if(window.nativeDecorations && window.state != maximized)
+ // Break the anchors for moveable/resizable windows
+ // Avoid doing this if the translation wasn't in sync as it will cause the window to move around
+ if(!unmaximized && !offset && window.style.fixed && window.state == normal)
{
- x -= windowData.decor.left;
- y -= windowData.decor.top;
- w += windowData.decor.left + windowData.decor.right;
- h += windowData.decor.top + windowData.decor.bottom;
- /*
- x -= window.clientStart.x;
- y -= window.clientStart.y - (window.hasMenuBar ? skinMenuHeight : 0);
- w += window.size.w - window.clientSize.w;
- h += window.size.h - window.clientSize.h;
- */
+ window.normalAnchor = Anchor
+ {
+ left = x + windowData.decor.left,
+ top = y + windowData.decor.top
+ };
+ window.normalSizeAnchor =
+ SizeAnchor { { window.clientSize.w, window.clientSize.h }, isClientW = true, isClientH = true };
}
- window.Position(x, y, w, h, true, true, true, true, false, false);
}
break;
}
bool laterFocus;
activeWindow = (X11Window)window.windowHandle;
- timeStamp = (int)event->data.l[1];
+ timeStamp = (X11Time)event->data.l[1];
windowData = window.windowData;
laterFocus = windowData.laterFocus;
event.window = (X11Window)modalRoot.windowHandle;
event.send_event = 1;
event.format = 32;
- event.data.l[0] = 0;
+ event.data.l[0] = /*0*/ 1;
+ event.data.l[1] = timeStamp;
+ event.data.l[2] = activeWindow;
/*
- event.data.l[0] = 1;
- event.data.l[1] = atoms[_net_wm_user_time];
event.data.l[2] = activeWindow; //guiApp.desktop.activeChild.windowHandle;
*/
#ifdef _DEBUG
#endif
XSendEvent(xGlobalDisplay, DefaultRootWindow(xGlobalDisplay), bool::false, SubstructureRedirectMask | SubstructureNotifyMask, (union _XEvent *)&event);
- XSetInputFocus(xGlobalDisplay, (X11Window)modalRoot.windowHandle, RevertToPointerRoot, (uint)timeStamp);
+ XSetInputFocus(xGlobalDisplay, (X11Window)modalRoot.windowHandle, RevertToPointerRoot, timeStamp);
//XFlush(xGlobalDisplay);
//printf("Done.\n");
}
else
{
- XSetInputFocus(xGlobalDisplay, (X11Window)window.windowHandle, RevertToPointerRoot, (uint)timeStamp);
+ XSetInputFocus(xGlobalDisplay, (X11Window)window.windowHandle, RevertToPointerRoot, timeStamp);
window.ExternalActivate(true, true, window, null); // lastActive);
if(windowData && windowData.ic)
{
else
{
X11Window parentWindow = (X11Window)null;
- int x = window.position.x, y = window.position.y;
+ int x = window.position.x + desktopX, y = window.position.y + desktopY;
int w = window.state == normal ? Max(1, window.size.w) : Max(1, window.normalSizeAnchor.size.w);
int h = window.state == normal ? Max(1, window.size.h) : Max(1, window.normalSizeAnchor.size.h);
+ MinMaxValue smw = 0, smh = 0;
+ MinMaxValue minW = window.minSize.w, minH = window.minSize.h;
+ window.OnResizing((int *)&minW, (int *)&minH);
+
+ // To fix jumping message boxes on Cinnamon:
+ if(window.state == normal && (minW > window.minSize.w || minH > window.minSize.w))
+ window.ComputeAnchors(window.normalAnchor, window.normalSizeAnchor, &x, &y, &w, &h);
+
+ window.SetWindowMinimum(&smw, &smh);
+ minW = Max(minW, smw);
+ minH = Max(minH, smh);
+
+ if(!window.nativeDecorations && window.state != normal)
+ {
+ w += window.size.w - window.clientSize.w;
+ h += window.size.h - window.clientSize.h;
+ }
if(window.master.rootWindow && window.master.rootWindow != guiApp.desktop && (window._isModal || window.style.interim))
{
//printf("Done.\n");
//XChangeProperty(xGlobalDisplay, windowHandle, atoms[wm_transient_for], XA_WINDOW, 32, PropModeReplace, (unsigned char*)&parentWindow, 1);
if(window.isModal)
- {
- Atom hints[1] = { atoms[_net_wm_state_modal] };
- XChangeProperty(xGlobalDisplay, windowHandle, atoms[_net_wm_state], XA_ATOM, 32, PropModeReplace, (unsigned char*)&hints, 1);
- }
+ SetNETWMState(windowHandle, false, add, atoms[_net_wm_state_modal], 0);
}
{
- Atom hints[2] =
+ Atom hints[4];
+ int count;
+ if(parentWindow && window.interim)
+ {
+ hints[0] = atoms[_net_wm_window_type_dropdown_menu];
+ hints[1] = atoms[_net_wm_window_type_popup_menu];
+ hints[2] = atoms[_net_wm_window_type_menu];
+ count = 3;
+ }
+ else if(parentWindow)
+ {
+ hints[0] = atoms[_net_wm_window_type_normal];
+
+ // Some WMs won't show a close button if dialog is set
+ // Additionally, this casues jumping of all dialog windows on Cinnamon
+ //hints[0] = atoms[_net_wm_window_type_dialog];
+ count = 1;
+ }
+ else
{
- parentWindow ? atoms[_net_wm_window_type_menu] : atoms[_net_wm_window_type_normal],
- parentWindow ? atoms[_net_wm_window_type_popup_menu] : 0
+ hints[0] = atoms[_net_wm_window_type_normal];
+ count = 1;
};
-#if defined(__APPLE__) || defined(__FreeBSD__)
- // Don't set this on non-interim windows for OS X...
- if(parentWindow && window.interim)
-#endif
+ XChangeProperty(xGlobalDisplay, windowHandle, atoms[_net_wm_window_type], XA_ATOM, 32,
+ PropModeReplace, (unsigned char*)&hints, count);
- XChangeProperty(xGlobalDisplay, windowHandle, atoms[_net_wm_window_type], XA_ATOM, 32,
- PropModeReplace, (unsigned char*)&hints, parentWindow ? 2 : 1);
{
XWMHints xwmHints;
xwmHints.flags = InputHint;
}
// Set Normal hints for minimum/maximum size
- if(true) //window.minSize.w || window.minSize.h || window.maxSize.w < MAXINT || window.maxSize.h < MAXINT)
{
XSizeHints hints = { 0 };
- MinMaxValue mw, mh;
- window.SetWindowMinimum(&mw, &mh);
- if(window.minSize.w || window.minSize.h)
- {
- hints.min_width = Max(window.minSize.w, mw);
- hints.min_height = Max(window.minSize.h, mh);
- hints.flags |= PMinSize;
- }
+ hints.min_width = minW;
+ hints.min_height = minH;
+ hints.flags |= PMinSize;
+
if(window.maxSize.w < MAXINT || window.minSize.h < MAXINT)
{
hints.max_width = window.maxSize.w;
}
if(ic)
{
- XGetICValues(ic, XNFilterEvents, &mask, NULL);
- mask |= EVENT_MASK;
+ XGetICValues(ic, XNFilterEvents, &mask, NULL);
+ mask |= EVENT_MASK;
}
/*
XSelectInput(xGlobalDisplay, windowHandle, mask);
XUngrabPointer(xGlobalDisplay, CurrentTime);
}
- if(window.nativeDecorations && frameExtentSupported != broken)
- {
- // Request decoration frame extents
- XClientMessageEvent event = { 0 };
- event.type = ClientMessage;
- event.message_type = atoms[_net_request_frame_extents];
- event.display = xGlobalDisplay;
- event.serial = 0;
- event.window = (X11Window)windowHandle;
- event.send_event = 1;
- window.windowHandle = (void *)windowHandle;
- event.format = 32;
-
- if(frameExtentSupported == unknown && !frameExtentRequest)
- {
- frameExtentRequest = GetTime();
- frameExtentWindow = windowHandle;
- }
-
- XSendEvent(xGlobalDisplay, DefaultRootWindow(xGlobalDisplay), bool::false,
- SubstructureRedirectMask | SubstructureNotifyMask, (union _XEvent *)&event);
- }
- else
+ if(!window.nativeDecorations || !RequestFrameExtents(windowHandle))
((XWindowData)window.windowData).gotFrameExtents = true;
+
return (void *)windowHandle;
}
// Was commenting this out was part of #700/#795 fix, but this causes jumping of e.g. About box after getting frame extents PropertyNotify
// && window.state != maximized -- required for Cinnamon on Mint 14/15
- if(!windowData.gotFrameExtents && window.state != maximized) return;
+ if(!windowData.gotFrameExtents && window.state != maximized)
+ {
+ if(WaitForFrameExtents(window))
+ {
+ x += windowData.decor.left;
+ y += windowData.decor.top ;
+
+ w += windowData.decor.left + windowData.decor.right;
+ h += windowData.decor.top + windowData.decor.bottom;
+ }
+ }
x -= windowData.decor.left;
y -= windowData.decor.top;
h -= windowData.decor.top + windowData.decor.bottom;
// Tweak for first unmaximize on Unity on Ubuntu 11.10
- if(window.state == maximized && (desktopX + w > desktopW || desktopY + h > desktopH))
+ /*if(window.state == maximized && (desktopX + w > desktopW || desktopY + h > desktopH))
{
w -= 40;
h -= 40;
- }
+ }*/
}
x += desktopX;
y += desktopY;
- if(move && resize)
- XMoveResizeWindow(xGlobalDisplay, (X11Window)window.windowHandle, x, y, w, h);
- else if(move)
- XMoveWindow(xGlobalDisplay, (X11Window)window.windowHandle, x, y);
- else if(resize)
- XResizeWindow(xGlobalDisplay, (X11Window)window.windowHandle, w, h);
-#if defined(__APPLE__)
-// if(window.created && !visible)
- // XUnmapWindow(xGlobalDisplay, (X11Window)window.windowHandle);
-#endif
+ if(!atomsSupported[_net_wm_state] || window.state != maximized)
+ {
+ if(move && resize)
+ XMoveResizeWindow(xGlobalDisplay, (X11Window)window.windowHandle, x, y, w, h);
+ else if(move)
+ XMoveWindow(xGlobalDisplay, (X11Window)window.windowHandle, x, y);
+ else if(resize)
+ XResizeWindow(xGlobalDisplay, (X11Window)window.windowHandle, w, h);
+
+ // Reset min/max for fixed size windows on WMs not looking at MWM_FUNC_RESIZE (e.g. Cinnamon)
+ if(window.style.fixed && !window.style.sizable)
+ {
+ XSizeHints hints = { 0 };
+ hints.min_width = hints.max_width = w;
+ hints.min_height = hints.max_height = h;
+ hints.flags |= PMinSize|PMaxSize;
+
+ XSetWMNormalHints(xGlobalDisplay, (X11Window)window.windowHandle, &hints);
+ }
+ }
}
}
if(state == minimized && atomsSupported[_net_wm_state])
{
uint iconic = IconicState;
- /*
- XChangeProperty(xGlobalDisplay, window.windowHandle, atoms[_net_wm_state], XA_ATOM, 32,
- PropModeReplace, (unsigned char*)&atoms[_net_wm_state_hidden], 1);
- */
+
+ // SetNETWMState(window.windowHandle, true, add, atoms[_net_wm_state_hidden], null);
/*
XChangeProperty(xGlobalDisplay, window.windowHandle, atoms[wm_state], XA_CARDINAL, 32,
PropModeReplace, &iconic, 1);
/*
XClientMessageEvent event = { 0 };
event.type = ClientMessage;
- event.message_type = atoms[_net_wm_state];
- event.display = xGlobalDisplay;
- event.serial = 0;
- event.window = window.windowHandle;
- event.send_event = 1;
- event.format = 32;
- event.data.l[0] = 2; // 1;
- event.data.l[1] = atoms[_net_wm_state_hidden];
- XSendEvent(xGlobalDisplay, DefaultRootWindow(xGlobalDisplay), bool::false, SubstructureRedirectMask | SubstructureNotifyMask, &event);
- */
- /*
- XClientMessageEvent event = { 0 };
- event.type = ClientMessage;
event.message_type = atoms[wm_state];
event.display = xGlobalDisplay;
event.window = window.windowHandle;
}
else
{
- if(!atomsSupported[_net_wm_state] || !window.nativeDecorations || (!((XWindowData)window.windowData).gotFrameExtents && window.state == maximized)) //((XWindowData)window.windowData).gotFrameExtents && (!window.nativeDecorations || window.state == state))
+ //((XWindowData)window.windowData).gotFrameExtents && (!window.nativeDecorations || window.state == state))
+ if(!atomsSupported[_net_wm_state] || (!((XWindowData)window.windowData).gotFrameExtents && window.state == maximized))
{
- // With native decorations, we do it the first time
- // or the WM (Gnome) is sticking it to the top/right!
+ // Running this block avoids the initial IDE maximized->unmaximized flicker
+ //if(window.state != maximized || !atomsSupported[_net_wm_state] || window.nativeDecorations)
{
int x = window.position.x;
int y = window.position.y;
if(atomsSupported[_net_wm_state])
{
// Maximize / Restore the window
- XClientMessageEvent event = { 0 };
- event.type = ClientMessage;
- event.message_type = atoms[_net_wm_state];
- event.display = xGlobalDisplay;
- event.serial = 0;
- event.window = (X11Window)window.windowHandle;
- event.send_event = 1;
- event.format = 32;
- event.data.l[0] = (state == maximized) ? 1 : 0;
- event.data.l[1] = atoms[_net_wm_state_maximized_vert];
- event.data.l[2] = atoms[_net_wm_state_maximized_horz];
- XSendEvent(xGlobalDisplay, DefaultRootWindow(xGlobalDisplay), bool::false,
- SubstructureRedirectMask | SubstructureNotifyMask, (union _XEvent *)&event);
+ SetNETWMState((X11Window)window.windowHandle, true, state == maximized ? add: remove,
+ atoms[_net_wm_state_maximized_vert], atoms[_net_wm_state_maximized_horz]);
+ if(state == maximized)
+ {
+ // Prevent the code in ConfigureNotify to think the window has been unmaximized
+ // if the Window Manager hasn't set the hints yet.
+ XFlush(xGlobalDisplay);
+ Sleep(0.01);
+ }
}
}
}
void FlashRootWindow(Window window)
{
- XClientMessageEvent event = { 0 };
// printf("Attempting to flash root window\n");
- event.type = ClientMessage;
- event.message_type = atoms[_net_wm_state];
- event.display = xGlobalDisplay;
- event.serial = 0;
- event.window = (X11Window)window.windowHandle;
- event.send_event = 1;
- event.format = 32;
- event.data.l[0] = 1;
- event.data.l[1] = atoms[_net_wm_state_demands_attention];
- XSendEvent(xGlobalDisplay, DefaultRootWindow(xGlobalDisplay), bool::false, SubstructureRedirectMask | SubstructureNotifyMask, (union _XEvent *)&event);
+ SetNETWMState((X11Window)window.windowHandle, true, add, atoms[_net_wm_state_demands_attention], 0);
}
void ActivateRootWindow(Window window)
event.window = (X11Window)window.windowHandle;
event.send_event = 1;
event.format = 32;
- event.data.l[0] = 0;
-
- //event.data.l[0] = 2;
- //event.data.l[1] = timeStamp;
-
-
- //event.data.l[1] = atoms[_net_wm_user_time];
- //event.data.l[2] = activeWindow; //guiApp.desktop.activeChild.windowHandle;
+ event.data.l[0] = /*0*/ 1;
+ event.data.l[1] = timeStamp;
+ event.data.l[2] = activeWindow; //guiApp.desktop.activeChild.windowHandle;
#ifdef _DEBUG
//printf("(ActivateRootWindow) Setting _NET_ACTIVE_WINDOW for %s (%x)\n", window._class.name, window);
{
if(!window.parent || !window.parent.display)
{
- XMoveResizeWindow(xGlobalDisplay, confineWindow, box.left + desktopX, box.top + desktopY,
+ XMoveResizeWindow(xGlobalDisplay, confineWindow, box.left /*+ desktopX*/, box.top /*+ desktopY*/,
box.right - box.left + 1, box.bottom - box.top + 1);
if(!restrictedWindow)
void SetMouseCursor(Window window, int cursor)
{
- XDefineCursor(xGlobalDisplay, (X11Window) window.rootWindow.windowHandle,
- cursor == -1 ? (X11Cursor)0 : systemCursors[(SystemCursor)cursor]);
+ if(window.rootWindow.windowHandle)
+ XDefineCursor(xGlobalDisplay, (X11Window) window.rootWindow.windowHandle,
+ cursor == -1 ? (X11Cursor)0 : systemCursors[(SystemCursor)cursor]);
}
// --- Caret ---
if(clipBoardData)
{
delete clipBoardData;
- XSetSelectionOwner(xGlobalDisplay, atoms[clipboard], None, CurrentTime);
+ XSetSelectionOwner(xGlobalDisplay, atoms[clipboard], None, CurrentTime);
}
//*XUnlockDisplay(xGlobalDisplay);
}
else
memcpy(icon + 2, bitmap.picture, bitmap.width * bitmap.height * sizeof(uint32));
XChangeProperty(xGlobalDisplay, (X11Window)window.windowHandle, atoms[_net_wm_icon],
- XA_CARDINAL,32,PropModeReplace, (byte *)icon, 2+bitmap.width*bitmap.height);
- delete icon;
+ XA_CARDINAL,32,PropModeReplace, (byte *)icon, 2+bitmap.width*bitmap.height);
+ delete icon;
}
delete bitmap;
}
Ecere Software / sdk / blobdiff