File indexing completed on 2024-04-28 05:46:51

 /*****************************************************************************
  *   Copyright 2013 - 2015 Yichao Yu <yyc1992@gmail.com>                     *
  *                                                                           *
  *   This program is free software; you can redistribute it and/or modify    *
  *   it under the terms of the GNU Lesser General Public License as          *
  *   published by the Free Software Foundation; either version 2.1 of the    *
  *   License, or (at your option) version 3, or any later version accepted   *
  *   by the membership of KDE e.V. (or its successor approved by the         *
  *   membership of KDE e.V.), which shall act as a proxy defined in          *
  *   Section 6 of version 3 of the license.                                  *
  *                                                                           *
  *   This program is distributed in the hope that it will be useful,         *
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of          *
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU       *
  *   Lesser General Public License for more details.                         *
  *                                                                           *
  *   You should have received a copy of the GNU Lesser General Public        *
  *   License along with this library. If not,                                *
  *   see <http://www.gnu.org/licenses/>.                                     *
  *****************************************************************************/
 
 // TODO multi screen?
 
 #include "config.h"
 #include "x11utils.h"
 
 QTC_EXPORT xcb_atom_t qtc_x11_qtc_menubar_size;
 QTC_EXPORT xcb_atom_t qtc_x11_qtc_statusbar;
 QTC_EXPORT xcb_atom_t qtc_x11_qtc_titlebar_size;
 QTC_EXPORT xcb_atom_t qtc_x11_qtc_active_window;
 QTC_EXPORT xcb_atom_t qtc_x11_qtc_toggle_menubar;
 QTC_EXPORT xcb_atom_t qtc_x11_qtc_toggle_statusbar;
 QTC_EXPORT xcb_atom_t qtc_x11_qtc_opacity;
 QTC_EXPORT xcb_atom_t qtc_x11_qtc_bgnd;
 
 #ifdef QTC_ENABLE_X11
 
 #include "x11shadow_p.h"
 #include "x11wrap.h"
 #include "log.h"
 #include "x11utils_p.h"
 #include <X11/Xlib-xcb.h>
 // #include <X11/Xutil.h>
 // #include <X11/extensions/Xrender.h>
 
 void *qtc_disp = nullptr;
 xcb_connection_t *qtc_xcb_conn = nullptr;
 int qtc_default_screen_no = -1;
 xcb_window_t qtc_root_window = {0};
 xcb_screen_t *qtc_default_screen = nullptr;
 static char wm_cm_s_atom_name[100] = "_NET_WM_CM_S";
 
 xcb_atom_t qtc_x11_net_wm_moveresize;
 xcb_atom_t qtc_x11_net_wm_cm_s_default;
 xcb_atom_t qtc_x11_kde_net_wm_shadow;
 xcb_atom_t qtc_x11_kde_net_wm_blur_behind_region;
 static xcb_atom_t qtc_x11_xembed_info;
 
 static const struct {
     xcb_atom_t *atom;
     const char *name;
 } qtc_x11_atoms[] = {
     {&qtc_x11_net_wm_moveresize, "_NET_WM_MOVERESIZE"},
     {&qtc_x11_net_wm_cm_s_default, wm_cm_s_atom_name},
     {&qtc_x11_kde_net_wm_shadow, "_KDE_NET_WM_SHADOW"},
     {&qtc_x11_kde_net_wm_blur_behind_region, "_KDE_NET_WM_BLUR_BEHIND_REGION"},
     {&qtc_x11_qtc_menubar_size, "_QTCURVE_MENUBAR_SIZE_"},
     {&qtc_x11_qtc_statusbar, "_QTCURVE_STATUSBAR_"},
     {&qtc_x11_qtc_titlebar_size, "_QTCURVE_TITLEBAR_SIZE_"},
     {&qtc_x11_qtc_active_window, "_QTCURVE_ACTIVE_WINDOW_"},
     {&qtc_x11_qtc_toggle_menubar, "_QTCURVE_TOGGLE_MENUBAR_"},
     {&qtc_x11_qtc_toggle_statusbar, "_QTCURVE_TOGGLE_STATUSBAR_"},
     {&qtc_x11_qtc_opacity, "_QTCURVE_OPACITY_"},
     {&qtc_x11_qtc_bgnd, "_QTCURVE_BGND_"},
     {&qtc_x11_xembed_info, "_XEMBED_INFO"}
 };
 #define QTC_X11_ATOM_N (sizeof(qtc_x11_atoms) / sizeof(qtc_x11_atoms[0]))
 
 QTC_EXPORT bool
 qtcX11Enabled()
 {
     return qtc_xcb_conn != nullptr;
 }
 
 QTC_EXPORT xcb_window_t
 qtcX11RootWindow(int scrn_no)
 {
     if (scrn_no < 0 || scrn_no == qtc_default_screen_no) {
         return qtc_root_window;
     }
     return qtcX11GetScreen(scrn_no)->root;
 }
 
 QTC_EXPORT int
 qtcX11DefaultScreenNo()
 {
     return qtc_default_screen_no;
 }
 
 QTC_EXPORT xcb_screen_t*
 qtcX11DefaultScreen()
 {
     return qtc_default_screen;
 }
 
 static xcb_screen_t*
 screen_of_display(xcb_connection_t *c, int screen)
 {
     xcb_screen_iterator_t iter;
 
     iter = xcb_setup_roots_iterator(xcb_get_setup(c));
     for (;iter.rem;--screen, xcb_screen_next(&iter)) {
         if (screen == 0) {
             return iter.data;
         }
     }
     return nullptr;
 }
 
 static void
 qtcX11AtomsInit()
 {
     xcb_connection_t *conn = qtc_xcb_conn;
     xcb_intern_atom_cookie_t cookies[QTC_X11_ATOM_N];
     for (size_t i = 0;i < QTC_X11_ATOM_N;i++) {
         cookies[i] = xcb_intern_atom(conn, 0, strlen(qtc_x11_atoms[i].name),
                                      qtc_x11_atoms[i].name);
     }
     for (size_t i = 0;i < QTC_X11_ATOM_N;i++) {
         xcb_intern_atom_reply_t *r =
             xcb_intern_atom_reply(conn, cookies[i], nullptr);
         if (qtcLikely(r)) {
             *qtc_x11_atoms[i].atom = r->atom;
             free(r);
         } else {
             *qtc_x11_atoms[i].atom = 0;
         }
     }
 }
 
 QTC_EXPORT xcb_screen_t*
 qtcX11GetScreen(int screen_no)
 {
     QTC_RET_IF_FAIL(qtc_xcb_conn, nullptr);
     if (screen_no == -1 || screen_no == qtc_default_screen_no) {
         return qtc_default_screen;
     }
     return screen_of_display(qtc_xcb_conn, screen_no);
 }
 
 QTC_EXPORT void
 qtcX11InitXcb(xcb_connection_t *conn, int screen_no)
 {
     QTC_RET_IF_FAIL(!qtc_xcb_conn && conn);
     if (screen_no < 0) {
         screen_no = 0;
     }
     qtc_xcb_conn = conn;
     qtc_default_screen_no = screen_no;
     qtc_default_screen = screen_of_display(conn, screen_no);
     if (qtc_default_screen) {
         qtc_root_window = qtc_default_screen->root;
     }
     const size_t base_len = strlen("_NET_WM_CM_S");
     sprintf(wm_cm_s_atom_name + base_len, "%d", screen_no);
     qtcX11AtomsInit();
     qtcX11ShadowInit();
 }
 
 QTC_EXPORT void
 qtcX11InitXlib(void *disp)
 {
     QTC_RET_IF_FAIL(!qtc_xcb_conn && disp);
     qtc_disp = disp;
     qtcX11InitXcb(XGetXCBConnection((Display*)disp), DefaultScreen(disp));
 }
 
 QTC_EXPORT xcb_connection_t*
 qtcX11GetConn()
 {
     return qtc_xcb_conn;
 }
 
 QTC_EXPORT void*
 qtcX11GetDisp()
 {
     return qtc_disp;
 }
 
 QTC_EXPORT void
 qtcX11MapRaised(xcb_window_t win)
 {
     QTC_RET_IF_FAIL(qtc_xcb_conn && win);
     static const uint32_t val = XCB_STACK_MODE_ABOVE;
     qtcX11CallVoid(configure_window, win, XCB_CONFIG_WINDOW_STACK_MODE, &val);
     qtcX11CallVoid(map_window, win);
 }
 
 QTC_EXPORT bool
 qtcX11CompositingActive()
 {
     QTC_RET_IF_FAIL(qtc_xcb_conn, false);
     xcb_get_selection_owner_reply_t *reply =
         qtcX11Call(get_selection_owner, qtc_x11_net_wm_cm_s_default);
     QTC_RET_IF_FAIL(reply, false);
     bool res = (reply->owner != 0);
     free(reply);
     return res;
 }
 
 QTC_EXPORT bool
 qtcX11HasAlpha(xcb_window_t win)
 {
     QTC_RET_IF_FAIL(qtc_xcb_conn && win, false);
     if (!qtcX11CompositingActive()) {
         return false;
     }
     xcb_get_geometry_reply_t *reply = qtcX11Call(get_geometry, win);
     QTC_RET_IF_FAIL(reply, false);
     bool res = (reply->depth == 32);
     free(reply);
     return res;
 }
 
 QTC_EXPORT bool
 qtcX11IsEmbed(xcb_window_t win)
 {
     QTC_RET_IF_FAIL(qtc_xcb_conn && win, false);
     xcb_get_property_reply_t *reply =
         qtcX11GetProperty(0, win, qtc_x11_xembed_info,
                           qtc_x11_xembed_info, 0, 1);
     QTC_RET_IF_FAIL(reply, false);
     bool res = xcb_get_property_value_length(reply) > 0;
     free(reply);
     return res;
 }
 
 #if 0
 QTC_EXPORT void*
 qtcX11RgbaVisual(unsigned long *colormap, int *map_entries, int screen)
 {
     QTC_RET_IF_FAIL(qtc_disp, nullptr);
     if (screen < 0) {
         screen = qtc_default_screen_no;
     }
     // Copied from Qt4
     Visual *argbVisual = nullptr;
     int nvi;
     XVisualInfo templ;
     templ.screen = screen;
     templ.depth = 32;
     templ.class = TrueColor;
     XVisualInfo *xvi = XGetVisualInfo(qtc_disp, VisualScreenMask |
                                       VisualDepthMask | VisualClassMask,
                                       &templ, &nvi);
     for (int idx = 0; idx < nvi; ++idx) {
         XRenderPictFormat *format = XRenderFindVisualFormat(qtc_disp,
                                                             xvi[idx].visual);
         if (format->type == PictTypeDirect && format->direct.alphaMask) {
             argbVisual = xvi[idx].visual;
             break;
         }
     }
     XFree(xvi);
     QTC_RET_IF_FAIL(argbVisual, nullptr);
     qtcAssign(colormap, XCreateColormap(qtc_disp, RootWindow(qtc_disp, screen),
                                         argbVisual, AllocNone));
     qtcAssign(map_entries, argbVisual->map_entries);
     return argbVisual;
 }
 #endif
 
 #else
 
 QTC_EXPORT bool
 qtcX11Enabled()
 {
     return false;
 }
 
 QTC_EXPORT xcb_window_t
 qtcX11RootWindow(int)
 {
     return 0;
 }
 
 QTC_EXPORT int
 qtcX11DefaultScreenNo()
 {
     return -1;
 }
 
 QTC_EXPORT xcb_screen_t*
 qtcX11DefaultScreen()
 {
     return nullptr;
 }
 
 QTC_EXPORT xcb_screen_t*
 qtcX11GetScreen(int)
 {
     return nullptr;
 }
 
 QTC_EXPORT void
 qtcX11InitXcb(xcb_connection_t*, int)
 {
 }
 
 QTC_EXPORT void
 qtcX11InitXlib(void*)
 {
 }
 
 QTC_EXPORT xcb_connection_t*
 qtcX11GetConn()
 {
     return nullptr;
 }
 
 QTC_EXPORT void*
 qtcX11GetDisp()
 {
     return nullptr;
 }
 
 QTC_EXPORT void
 qtcX11MapRaised(xcb_window_t)
 {
 }
 
 QTC_EXPORT bool
 qtcX11CompositingActive()
 {
     return false;
 }
 
 QTC_EXPORT bool
 qtcX11HasAlpha(xcb_window_t)
 {
     return false;
 }
 
 QTC_EXPORT bool
 qtcX11IsEmbed(xcb_window_t)
 {
     return false;
 }
 
 #if 0
 QTC_EXPORT void*
 qtcX11RgbaVisual(unsigned long*, int*, int)
 {
     return nullptr;
 }
 #endif
 
 #endif