File indexing completed on 2024-04-28 03:59:28

 /*
     SPDX-FileCopyrightText: 2000 Troll Tech AS
     SPDX-FileCopyrightText: 2003 Lubos Lunak <l.lunak@kde.org>
 
     SPDX-License-Identifier: MIT
 */
 
 #ifndef netwm_p_h
 #define netwm_p_h
 
 #include <QSharedData>
 #include <QSharedDataPointer>
 
 #include "atoms_p.h"
 
 class Atoms : public QSharedData
 {
 public:
     explicit Atoms(xcb_connection_t *c);
 
     xcb_atom_t atom(KwsAtom atom) const
     {
         return m_atoms[atom];
     }
 
 private:
     void init();
     xcb_atom_t m_atoms[KwsAtomCount];
     xcb_connection_t *m_connection;
 };
 
 /**
    Resizable array class.
 
    This resizable array is used to simplify the implementation.  The existence of
    this class is to keep the implementation from depending on a separate
    framework/library.
    @internal
 **/
 
 template<class Z>
 class NETRArray
 {
 public:
     /**
        Constructs an empty (size == 0) array.
     **/
 
     NETRArray();
 
     /**
        Resizable array destructor.
     **/
 
     ~NETRArray();
 
     /**
        The [] operator does the work.  If the index is larger than the current
        size of the array, it is resized.
      **/
 
     Z &operator[](int);
 
     /**
        Returns the size of the array.
      **/
 
     int size() const
     {
         return sz;
     }
 
     /**
        Resets the array (size == 0).
      **/
     void reset();
 
 private:
     int sz;
     int capacity;
     Z *d;
 };
 
 /**
    Private data for the NETRootInfo class.
    @internal
 **/
 
 struct NETRootInfoPrivate {
     NET::Role role;
 
     // information about the X server
     xcb_connection_t *conn;
     NETSize rootSize;
     xcb_window_t root;
     xcb_window_t supportwindow;
     const char *name;
 
     uint32_t *temp_buf;
     size_t temp_buf_size;
 
     // data that changes (either by the window manager or by a client)
     // and requires updates
     NETRArray<NETPoint> viewport;
     NETRArray<NETRect> workarea;
     NETSize geometry;
     xcb_window_t active;
     xcb_window_t *clients, *stacking, *virtual_roots;
     NETRArray<const char *> desktop_names;
     int number_of_desktops;
     int current_desktop;
 
     unsigned long clients_count, stacking_count, virtual_roots_count;
     bool showing_desktop;
     NET::Orientation desktop_layout_orientation;
     NET::DesktopLayoutCorner desktop_layout_corner;
     int desktop_layout_columns, desktop_layout_rows;
 
     NET::Properties properties;
     NET::Properties2 properties2;
     NET::WindowTypes windowTypes;
     NET::States states;
     NET::Actions actions;
     NET::Properties clientProperties;
     NET::Properties2 clientProperties2;
 
     int ref;
 
     QSharedDataPointer<Atoms> atoms;
     xcb_atom_t atom(KwsAtom atom) const
     {
         return atoms->atom(atom);
     }
 };
 
 /**
    Private data for the NETWinInfo class.
    @internal
 **/
 
 struct NETWinInfoPrivate {
     NET::Role role;
 
     xcb_connection_t *conn;
     xcb_window_t window, root;
     NET::MappingState mapping_state;
     bool mapping_state_dirty;
 
     NETRArray<NETIcon> icons;
     int icon_count;
     int *icon_sizes; // for iconSizes() only
 
     NETRect icon_geom, win_geom;
     NET::States state;
     NETExtendedStrut extended_strut;
     NETStrut strut;
     NETStrut frame_strut; // strut?
     NETStrut frame_overlap;
     NETStrut gtk_frame_extents;
     NETRArray<NET::WindowType> types;
     char *name, *visible_name, *icon_name, *visible_icon_name;
     int desktop;
     int pid;
     bool handled_icons;
     xcb_timestamp_t user_time;
     char *startup_id;
     unsigned long opacity;
     xcb_window_t transient_for, window_group;
     xcb_pixmap_t icon_pixmap, icon_mask;
     NET::Actions allowed_actions;
     char *class_class, *class_name, *window_role, *client_machine, *desktop_file, *appmenu_object_path, *appmenu_service_name, *gtk_application_id;
 
     NET::Properties properties;
     NET::Properties2 properties2;
     NETFullscreenMonitors fullscreen_monitors;
     bool has_net_support;
 
     const char *activities;
     bool blockCompositing;
     bool urgency;
     bool input;
     NET::MappingState initialMappingState;
     NET::Protocols protocols;
     std::vector<NETRect> opaqueRegion;
 
     int ref;
 
     QSharedDataPointer<Atoms> atoms;
     xcb_atom_t atom(KwsAtom atom) const
     {
         return atoms->atom(atom);
     }
 };
 
 #endif // netwm_p_h