/**
* @brief gets the desktop of the windows _wid
*/
int XfitMan::getWindowDesktop(Window _wid) const
{
int res = -1;
unsigned long length, *data;
// so we try to use net_wm_desktop first, but if the
// system does not use net_wm standard we use win_workspace!
if (getWindowProperty(_wid, atom("_NET_WM_DESKTOP"), XA_CARDINAL, &length, (unsigned char**) &data))
{
if (!data)
return res;
res = data[0];
XFree(data);
}
else
{
if (getWindowProperty(_wid, atom("_WIN_WORKSPACE"), XA_CARDINAL, &length, (unsigned char**) &data))
{
if (!data)
return res;
res = data[0];
XFree(data);
}
}
return res;
}
void WebApplicationWindow::updateWindowProperty(const QString &name)
{
qDebug() << Q_FUNC_INFO << "Window property" << name << "was updated";
if (name == "_LUNE_WINDOW_ID")
mWindowId = getWindowProperty("_LUNE_WINDOW_ID").toInt();
else if (name == "_LUNE_WINDOW_PARENT_ID")
mParentWindowId = getWindowProperty("_LUNE_WINDOW_PARENT_ID").toInt();
}
void cv::imshow( const String& winname, InputArray _img )
{
CV_TRACE_FUNCTION();
const Size size = _img.size();
#ifndef HAVE_OPENGL
CV_Assert(size.width>0 && size.height>0);
{
Mat img = _img.getMat();
CvMat c_img = cvMat(img);
cvShowImage(winname.c_str(), &c_img);
}
#else
const double useGl = getWindowProperty(winname, WND_PROP_OPENGL);
CV_Assert(size.width>0 && size.height>0);
if (useGl <= 0)
{
Mat img = _img.getMat();
CvMat c_img = cvMat(img);
cvShowImage(winname.c_str(), &c_img);
}
else
{
const double autoSize = getWindowProperty(winname, WND_PROP_AUTOSIZE);
if (autoSize > 0)
{
resizeWindow(winname, size.width, size.height);
}
setOpenGlContext(winname);
cv::ogl::Texture2D& tex = ownWndTexs[winname];
if (_img.kind() == _InputArray::CUDA_GPU_MAT)
{
cv::ogl::Buffer& buf = ownWndBufs[winname];
buf.copyFrom(_img);
buf.setAutoRelease(false);
tex.copyFrom(buf);
tex.setAutoRelease(false);
}
else
{
tex.copyFrom(_img);
}
tex.setAutoRelease(false);
setOpenGlDrawCallback(winname, glDrawTextureCallback, &tex);
updateWindow(winname);
}
#endif
}
// i got the idea for this from taskbar-plugin of LXPanel - so credits fly out :)
QString XfitMan::getWindowTitle(Window _wid) const
{
QString name = "";
//first try the modern net-wm ones
unsigned long length;
unsigned char *data = nullptr;
Atom utf8Atom = atom("UTF8_STRING");
if (getWindowProperty(_wid, atom("_NET_WM_VISIBLE_NAME"), utf8Atom, &length, &data))
{
name = QString::fromUtf8((char*) data);
XFree(data);
}
if (name.isEmpty())
{
if (getWindowProperty(_wid, atom("_NET_WM_NAME"), utf8Atom, &length, &data))
{
name = QString::fromUtf8((char*) data);
XFree(data);
}
}
if (name.isEmpty())
{
if (getWindowProperty(_wid, atom("XA_WM_NAME"), XA_STRING, &length, &data))
{
name = (char*) data;
XFree(data);
}
}
if (name.isEmpty())
{
Status ok = XFetchName(QX11Info::display(), _wid, (char**) &data);
name = QString((char*) data);
if (0 != ok) XFree(data);
}
if (name.isEmpty())
{
XTextProperty prop;
if (XGetWMName(QX11Info::display(), _wid, &prop))
{
name = QString::fromUtf8((char*) prop.value);
XFree(prop.value);
}
}
return name;
}
WindowState XfitMan::getWindowState(Window window) const
{
WindowState state = { };
unsigned long len;
unsigned long *data;
if (getWindowProperty(window, atom("_NET_WM_STATE"), XA_ATOM, &len, (unsigned char**) &data))
{
for (unsigned long i=0; i<len; ++i)
{
if (data[i] == atom("_NET_WM_STATE_MODAL")) state.Modal = true; else
if (data[i] == atom("_NET_WM_STATE_STICKY")) state.Sticky = true; else
if (data[i] == atom("_NET_WM_STATE_MAXIMIZED_VERT")) state.MaximizedVert = true; else
if (data[i] == atom("_NET_WM_STATE_MAXIMIZED_HORZ")) state.MaximizedHoriz = true; else
if (data[i] == atom("_NET_WM_STATE_SHADED")) state.Shaded = true; else
if (data[i] == atom("_NET_WM_STATE_SKIP_TASKBAR")) state.SkipTaskBar = true; else
if (data[i] == atom("_NET_WM_STATE_SKIP_PAGER")) state.SkipPager = true; else
if (data[i] == atom("_NET_WM_STATE_HIDDEN")) state.Hidden = true; else
if (data[i] == atom("_NET_WM_STATE_FULLSCREEN")) state.FullScreen = true; else
if (data[i] == atom("_NET_WM_STATE_ABOVE")) state.AboveLayer = true; else
if (data[i] == atom("_NET_WM_STATE_BELOW")) state.BelowLayer = true; else
if (data[i] == atom("_NET_WM_STATE_DEMANDS_ATTENTION")) state.Attention = true;
}
XFree(data);
}
return state;
}
WindowAllowedActions XfitMan::getAllowedActions(Window window) const
{
WindowAllowedActions actions = { };
unsigned long len;
unsigned long *data;
if (getWindowProperty(window, atom("_NET_WM_ALLOWED_ACTIONS"), XA_ATOM, &len, (unsigned char**) &data))
{
for (unsigned long i=0; i<len; ++i)
{
if (data[i] == atom("_NET_WM_ACTION_MOVE")) actions.Move = true; else
if (data[i] == atom("_NET_WM_ACTION_RESIZE")) actions.Resize = true; else
if (data[i] == atom("_NET_WM_ACTION_MINIMIZE")) actions.Minimize = true; else
if (data[i] == atom("_NET_WM_ACTION_SHADE")) actions.Shade = true; else
if (data[i] == atom("_NET_WM_ACTION_STICK")) actions.Stick = true; else
if (data[i] == atom("_NET_WM_ACTION_MAXIMIZE_HORZ")) actions.MaximizeHoriz = true; else
if (data[i] == atom("_NET_WM_ACTION_MAXIMIZE_VERT")) actions.MaximizeVert = true; else
if (data[i] == atom("_NET_WM_ACTION_FULLSCREEN")) actions.FullScreen = true; else
if (data[i] == atom("_NET_WM_ACTION_CHANGE_DESKTOP")) actions.ChangeDesktop = true; else
if (data[i] == atom("_NET_WM_ACTION_CLOSE")) actions.Close = true; else
if (data[i] == atom("_NET_WM_ACTION_ABOVE")) actions.AboveLayer = true; else
if (data[i] == atom("_NET_WM_ACTION_BELOW")) actions.BelowLayer = true;
}
XFree(data);
}
return actions;
}
bool XfitMan::getRootWindowProperty(Atom atom, // property
Atom reqType, // req_type
unsigned long* resultLen,// nitems_return
unsigned char** result // prop_return
) const
{
return getWindowProperty(root, atom, reqType, resultLen, result);
}
int XVWindow::getWMType() {
unsigned int i;
int wmType = 0;
int metacityHack=0;
unsigned long nitems;
Atom *args = NULL;
// check if WM supports layers
if (getWindowProperty(XA_WIN_PROTOCOLS, &args, &nitems)) {
LOG_DEBUG("[x11] Detected wm supports layers.");
for (i = 0; i < nitems; i++) {
if (args[i] == XA_WIN_LAYER) {
wmType |= wm_LAYER;
metacityHack |= 1;
} else {
metacityHack |= 2;
}
}
XFree(args);
// metacity WM reports that it supports layers, but it is not really truth :-)
if (wmType && (metacityHack == 1)) {
wmType ^= wm_LAYER;
LOG_DEBUG("[x11] Using workaround for Metacity bugs.");
}
}
// NETWM
if (getWindowProperty(XA_NET_SUPPORTED, &args, &nitems)) {
LOG_DEBUG("[x11] Detected wm supports NetWM.");
for (i = 0; i < nitems; i++) {
wmType |= getSupportedState(args[i]);
}
XFree(args);
}
// unknown WM
if (wmType == 0) {
LOG_DEBUG("[x11] Unknown wm type...");
}
return wmType;
}
void cv::imshow(const String& winname, const ogl::Texture2D& _tex)
{
CV_TRACE_FUNCTION();
#ifndef HAVE_OPENGL
CV_UNUSED(winname);
CV_UNUSED(_tex);
CV_Error(cv::Error::OpenGlNotSupported, "The library is compiled without OpenGL support");
#else
const double useGl = getWindowProperty(winname, WND_PROP_OPENGL);
if (useGl <= 0)
{
CV_Error(cv::Error::OpenGlNotSupported, "The window was created without OpenGL context");
}
else
{
const double autoSize = getWindowProperty(winname, WND_PROP_AUTOSIZE);
if (autoSize > 0)
{
Size size = _tex.size();
resizeWindow(winname, size.width, size.height);
}
setOpenGlContext(winname);
cv::ogl::Texture2D& tex = wndTexs[winname];
tex = _tex;
tex.setAutoRelease(false);
setOpenGlDrawCallback(winname, glDrawTextureCallback, &tex);
updateWindow(winname);
}
#endif
}
AtomList XfitMan::getWindowType(Window window) const
{
AtomList result;
unsigned long length, *data;
length=0;
if (!getWindowProperty(window, atom("_NET_WM_WINDOW_TYPE"), (Atom)AnyPropertyType, &length, (unsigned char**) &data))
return result;
for (unsigned int i = 0; i < length; i++)
result.append(data[i]);
XFree(data);
return result;
}
/**
* @brief returns the window that currently has inputfocus
*/
Window XfitMan::getActiveWindow() const
{
unsigned long len;
unsigned long *data;
if (!getWindowProperty(root, atom("_NET_ACTIVE_WINDOW"), XA_WINDOW,
&len, (unsigned char**) &data)
)
return 0;
Window result = 0;
if (len)
result = data[0];
XFree(data);
return result;
}
void cv::imshow( const std::string& winname, InputArray _img )
{
#ifndef HAVE_OPENGL
Mat img = _img.getMat();
CvMat c_img = img;
cvShowImage(winname.c_str(), &c_img);
#else
const double useGl = getWindowProperty(winname, WND_PROP_OPENGL);
if (useGl <= 0)
{
Mat img = _img.getMat();
CvMat c_img = img;
cvShowImage(winname.c_str(), &c_img);
}
else
{
const double autoSize = getWindowProperty(winname, WND_PROP_AUTOSIZE);
if (autoSize > 0)
{
Size size = _img.size();
resizeWindow(winname, size.width, size.height);
}
setOpenGlContext(winname);
if (_img.kind() == _InputArray::OPENGL_TEXTURE)
{
cv::ogl::Texture2D& tex = wndTexs[winname];
tex = _img.getOGlTexture2D();
tex.setAutoRelease(false);
setOpenGlDrawCallback(winname, glDrawTextureCallback, &tex);
}
else
{
cv::ogl::Texture2D& tex = ownWndTexs[winname];
if (_img.kind() == _InputArray::GPU_MAT)
{
cv::ogl::Buffer& buf = ownWndBufs[winname];
buf.copyFrom(_img);
buf.setAutoRelease(false);
tex.copyFrom(buf);
tex.setAutoRelease(false);
}
else
{
tex.copyFrom(_img);
}
tex.setAutoRelease(false);
setOpenGlDrawCallback(winname, glDrawTextureCallback, &tex);
}
updateWindow(winname);
}
#endif
}
static void initEWMH(void)
{
Window* windowFromRoot = NULL;
Window* windowFromChild = NULL;
// First we need a couple of atoms, which should already be there
Atom supportingWmCheck =
XInternAtom(_glfwLibrary.X11.display, "_NET_SUPPORTING_WM_CHECK", True);
Atom wmSupported =
XInternAtom(_glfwLibrary.X11.display, "_NET_SUPPORTED", True);
if (supportingWmCheck == None || wmSupported == None)
return;
// Then we look for the _NET_SUPPORTING_WM_CHECK property of the root window
if (getWindowProperty(_glfwLibrary.X11.root,
supportingWmCheck,
XA_WINDOW,
(unsigned char**) &windowFromRoot) != 1)
{
XFree(windowFromRoot);
return;
}
// It should be the ID of a child window (of the root)
// Then we look for the same property on the child window
if (getWindowProperty(*windowFromRoot,
supportingWmCheck,
XA_WINDOW,
(unsigned char**) &windowFromChild) != 1)
{
XFree(windowFromRoot);
XFree(windowFromChild);
return;
}
// It should be the ID of that same child window
if (*windowFromRoot != *windowFromChild)
{
XFree(windowFromRoot);
XFree(windowFromChild);
return;
}
XFree(windowFromRoot);
XFree(windowFromChild);
// We are now fairly sure that an EWMH-compliant window manager is running
Atom* supportedAtoms;
unsigned long atomCount;
// Now we need to check the _NET_SUPPORTED property of the root window
// It should be a list of supported WM protocol and state atoms
atomCount = getWindowProperty(_glfwLibrary.X11.root,
wmSupported,
XA_ATOM,
(unsigned char**) &supportedAtoms);
// See which of the atoms we support that are supported by the WM
_glfwLibrary.X11.wmState =
getSupportedAtom(supportedAtoms, atomCount, "_NET_WM_STATE");
_glfwLibrary.X11.wmStateFullscreen =
getSupportedAtom(supportedAtoms, atomCount, "_NET_WM_STATE_FULLSCREEN");
_glfwLibrary.X11.wmName =
getSupportedAtom(supportedAtoms, atomCount, "_NET_WM_NAME");
_glfwLibrary.X11.wmIconName =
getSupportedAtom(supportedAtoms, atomCount, "_NET_WM_ICON_NAME");
_glfwLibrary.X11.wmPing =
getSupportedAtom(supportedAtoms, atomCount, "_NET_WM_PING");
_glfwLibrary.X11.wmActiveWindow =
getSupportedAtom(supportedAtoms, atomCount, "_NET_ACTIVE_WINDOW");
XFree(supportedAtoms);
_glfwLibrary.X11.hasEWMH = GL_TRUE;
}
