XCB: do not use reserved identifiers

Any identifier starting with underscore followed by a capital letter is
reserved for the implementation in C++, so don't use them. Rename the
entries in the Atom enumeration by adding an "Atom" prefix to them.

Pick-to: 6.2 6.4 6.5
Change-Id: I059e2093149f39cc9324cd1159c0d9e076eda93a
Reviewed-by: JiDe Zhang <zhangjide@uniontech.com>
Reviewed-by: Liang Qi <liang.qi@qt.io>

13 files changed, 466 insertions, 466 deletions

diff --git a/src/plugins/platforms/xcb/qxcbatom.h b/src/plugins/platforms/xcb/qxcbatom.h
index f94620dc5e..07dad31d45 100644
--- a/src/plugins/platforms/xcb/qxcbatom.h
+++ b/src/plugins/platforms/xcb/qxcbatom.h
@@ -10,204 +10,204 @@ class QXcbAtom
 public:
     enum Atom {
         // window-manager <-> client protocols
-        WM_PROTOCOLS,
-        WM_DELETE_WINDOW,
-        WM_TAKE_FOCUS,
-        _NET_WM_PING,
-        _NET_WM_CONTEXT_HELP,
-        _NET_WM_SYNC_REQUEST,
-        _NET_WM_SYNC_REQUEST_COUNTER,
-        MANAGER, // System tray notification
-        _NET_SYSTEM_TRAY_OPCODE, // System tray operation
+        AtomWM_PROTOCOLS,
+        AtomWM_DELETE_WINDOW,
+        AtomWM_TAKE_FOCUS,
+        Atom_NET_WM_PING,
+        Atom_NET_WM_CONTEXT_HELP,
+        Atom_NET_WM_SYNC_REQUEST,
+        Atom_NET_WM_SYNC_REQUEST_COUNTER,
+        AtomMANAGER, // System tray notification
+        Atom_NET_SYSTEM_TRAY_OPCODE, // System tray operation
 
         // ICCCM window state
-        WM_STATE,
-        WM_CHANGE_STATE,
-        WM_CLASS,
-        WM_NAME,
+        AtomWM_STATE,
+        AtomWM_CHANGE_STATE,
+        AtomWM_CLASS,
+        AtomWM_NAME,
 
         // Session management
-        WM_CLIENT_LEADER,
-        WM_WINDOW_ROLE,
-        SM_CLIENT_ID,
-        WM_CLIENT_MACHINE,
+        AtomWM_CLIENT_LEADER,
+        AtomWM_WINDOW_ROLE,
+        AtomSM_CLIENT_ID,
+        AtomWM_CLIENT_MACHINE,
 
         // Clipboard
-        CLIPBOARD,
-        INCR,
-        TARGETS,
-        MULTIPLE,
-        TIMESTAMP,
-        SAVE_TARGETS,
-        CLIP_TEMPORARY,
-        _QT_SELECTION,
-        _QT_CLIPBOARD_SENTINEL,
-        _QT_SELECTION_SENTINEL,
-        CLIPBOARD_MANAGER,
+        AtomCLIPBOARD,
+        AtomINCR,
+        AtomTARGETS,
+        AtomMULTIPLE,
+        AtomTIMESTAMP,
+        AtomSAVE_TARGETS,
+        AtomCLIP_TEMPORARY,
+        Atom_QT_SELECTION,
+        Atom_QT_CLIPBOARD_SENTINEL,
+        Atom_QT_SELECTION_SENTINEL,
+        AtomCLIPBOARD_MANAGER,
 
-        RESOURCE_MANAGER,
+        AtomRESOURCE_MANAGER,
 
-        _XSETROOT_ID,
+        Atom_XSETROOT_ID,
 
-        _QT_SCROLL_DONE,
-        _QT_INPUT_ENCODING,
+        Atom_QT_SCROLL_DONE,
+        Atom_QT_INPUT_ENCODING,
 
         // Qt/XCB specific
-        _QT_CLOSE_CONNECTION,
+        Atom_QT_CLOSE_CONNECTION,
 
-        _QT_GET_TIMESTAMP,
+        Atom_QT_GET_TIMESTAMP,
 
-        _MOTIF_WM_HINTS,
+        Atom_MOTIF_WM_HINTS,
 
-        DTWM_IS_RUNNING,
-        ENLIGHTENMENT_DESKTOP,
-        _DT_SAVE_MODE,
-        _SGI_DESKS_MANAGER,
+        AtomDTWM_IS_RUNNING,
+        AtomENLIGHTENMENT_DESKTOP,
+        Atom_DT_SAVE_MODE,
+        Atom_SGI_DESKS_MANAGER,
 
         // EWMH (aka NETWM)
-        _NET_SUPPORTED,
-        _NET_VIRTUAL_ROOTS,
-        _NET_WORKAREA,
-
-        _NET_MOVERESIZE_WINDOW,
-        _NET_WM_MOVERESIZE,
-
-        _NET_WM_NAME,
-        _NET_WM_ICON_NAME,
-        _NET_WM_ICON,
-
-        _NET_WM_PID,
-
-        _NET_WM_WINDOW_OPACITY,
-
-        _NET_WM_STATE,
-        _NET_WM_STATE_ABOVE,
-        _NET_WM_STATE_BELOW,
-        _NET_WM_STATE_FULLSCREEN,
-        _NET_WM_STATE_MAXIMIZED_HORZ,
-        _NET_WM_STATE_MAXIMIZED_VERT,
-        _NET_WM_STATE_MODAL,
-        _NET_WM_STATE_STAYS_ON_TOP,
-        _NET_WM_STATE_DEMANDS_ATTENTION,
-        _NET_WM_STATE_HIDDEN,
-
-        _NET_WM_USER_TIME,
-        _NET_WM_USER_TIME_WINDOW,
-        _NET_WM_FULL_PLACEMENT,
-
-        _NET_WM_WINDOW_TYPE,
-        _NET_WM_WINDOW_TYPE_DESKTOP,
-        _NET_WM_WINDOW_TYPE_DOCK,
-        _NET_WM_WINDOW_TYPE_TOOLBAR,
-        _NET_WM_WINDOW_TYPE_MENU,
-        _NET_WM_WINDOW_TYPE_UTILITY,
-        _NET_WM_WINDOW_TYPE_SPLASH,
-        _NET_WM_WINDOW_TYPE_DIALOG,
-        _NET_WM_WINDOW_TYPE_DROPDOWN_MENU,
-        _NET_WM_WINDOW_TYPE_POPUP_MENU,
-        _NET_WM_WINDOW_TYPE_TOOLTIP,
-        _NET_WM_WINDOW_TYPE_NOTIFICATION,
-        _NET_WM_WINDOW_TYPE_COMBO,
-        _NET_WM_WINDOW_TYPE_DND,
-        _NET_WM_WINDOW_TYPE_NORMAL,
-        _KDE_NET_WM_WINDOW_TYPE_OVERRIDE,
-
-        _KDE_NET_WM_FRAME_STRUT,
-        _NET_FRAME_EXTENTS,
-
-        _NET_STARTUP_INFO,
-        _NET_STARTUP_INFO_BEGIN,
-        _NET_STARTUP_ID,
-
-        _NET_SUPPORTING_WM_CHECK,
-
-        _NET_WM_CM_S0,
-
-        _NET_SYSTEM_TRAY_VISUAL,
-
-        _NET_ACTIVE_WINDOW,
+        Atom_NET_SUPPORTED,
+        Atom_NET_VIRTUAL_ROOTS,
+        Atom_NET_WORKAREA,
+
+        Atom_NET_MOVERESIZE_WINDOW,
+        Atom_NET_WM_MOVERESIZE,
+
+        Atom_NET_WM_NAME,
+        Atom_NET_WM_ICON_NAME,
+        Atom_NET_WM_ICON,
+
+        Atom_NET_WM_PID,
+
+        Atom_NET_WM_WINDOW_OPACITY,
+
+        Atom_NET_WM_STATE,
+        Atom_NET_WM_STATE_ABOVE,
+        Atom_NET_WM_STATE_BELOW,
+        Atom_NET_WM_STATE_FULLSCREEN,
+        Atom_NET_WM_STATE_MAXIMIZED_HORZ,
+        Atom_NET_WM_STATE_MAXIMIZED_VERT,
+        Atom_NET_WM_STATE_MODAL,
+        Atom_NET_WM_STATE_STAYS_ON_TOP,
+        Atom_NET_WM_STATE_DEMANDS_ATTENTION,
+        Atom_NET_WM_STATE_HIDDEN,
+
+        Atom_NET_WM_USER_TIME,
+        Atom_NET_WM_USER_TIME_WINDOW,
+        Atom_NET_WM_FULL_PLACEMENT,
+
+        Atom_NET_WM_WINDOW_TYPE,
+        Atom_NET_WM_WINDOW_TYPE_DESKTOP,
+        Atom_NET_WM_WINDOW_TYPE_DOCK,
+        Atom_NET_WM_WINDOW_TYPE_TOOLBAR,
+        Atom_NET_WM_WINDOW_TYPE_MENU,
+        Atom_NET_WM_WINDOW_TYPE_UTILITY,
+        Atom_NET_WM_WINDOW_TYPE_SPLASH,
+        Atom_NET_WM_WINDOW_TYPE_DIALOG,
+        Atom_NET_WM_WINDOW_TYPE_DROPDOWN_MENU,
+        Atom_NET_WM_WINDOW_TYPE_POPUP_MENU,
+        Atom_NET_WM_WINDOW_TYPE_TOOLTIP,
+        Atom_NET_WM_WINDOW_TYPE_NOTIFICATION,
+        Atom_NET_WM_WINDOW_TYPE_COMBO,
+        Atom_NET_WM_WINDOW_TYPE_DND,
+        Atom_NET_WM_WINDOW_TYPE_NORMAL,
+        Atom_KDE_NET_WM_WINDOW_TYPE_OVERRIDE,
+
+        Atom_KDE_NET_WM_FRAME_STRUT,
+        Atom_NET_FRAME_EXTENTS,
+
+        Atom_NET_STARTUP_INFO,
+        Atom_NET_STARTUP_INFO_BEGIN,
+        Atom_NET_STARTUP_ID,
+
+        Atom_NET_SUPPORTING_WM_CHECK,
+
+        Atom_NET_WM_CM_S0,
+
+        Atom_NET_SYSTEM_TRAY_VISUAL,
+
+        Atom_NET_ACTIVE_WINDOW,
 
         // Property formats
-        TEXT,
-        UTF8_STRING,
-        CARDINAL,
+        AtomTEXT,
+        AtomUTF8_STRING,
+        AtomCARDINAL,
 
         // Xdnd
-        XdndEnter,
-        XdndPosition,
-        XdndStatus,
-        XdndLeave,
-        XdndDrop,
-        XdndFinished,
-        XdndTypelist,
-        XdndActionList,
-
-        XdndSelection,
-
-        XdndAware,
-        XdndProxy,
-
-        XdndActionCopy,
-        XdndActionLink,
-        XdndActionMove,
-        XdndActionAsk,
-        XdndActionPrivate,
+        AtomXdndEnter,
+        AtomXdndPosition,
+        AtomXdndStatus,
+        AtomXdndLeave,
+        AtomXdndDrop,
+        AtomXdndFinished,
+        AtomXdndTypelist,
+        AtomXdndActionList,
+
+        AtomXdndSelection,
+
+        AtomXdndAware,
+        AtomXdndProxy,
+
+        AtomXdndActionCopy,
+        AtomXdndActionLink,
+        AtomXdndActionMove,
+        AtomXdndActionAsk,
+        AtomXdndActionPrivate,
 
         // Xkb
-        _XKB_RULES_NAMES,
+        Atom_XKB_RULES_NAMES,
 
         // XEMBED
-        _XEMBED,
-        _XEMBED_INFO,
+        Atom_XEMBED,
+        Atom_XEMBED_INFO,
 
         // XInput2
-        ButtonLeft,
-        ButtonMiddle,
-        ButtonRight,
-        ButtonWheelUp,
-        ButtonWheelDown,
-        ButtonHorizWheelLeft,
-        ButtonHorizWheelRight,
-        AbsMTPositionX,
-        AbsMTPositionY,
-        AbsMTTouchMajor,
-        AbsMTTouchMinor,
-        AbsMTOrientation,
-        AbsMTPressure,
-        AbsMTTrackingID,
-        MaxContacts,
-        RelX,
-        RelY,
+        AtomButtonLeft,
+        AtomButtonMiddle,
+        AtomButtonRight,
+        AtomButtonWheelUp,
+        AtomButtonWheelDown,
+        AtomButtonHorizWheelLeft,
+        AtomButtonHorizWheelRight,
+        AtomAbsMTPositionX,
+        AtomAbsMTPositionY,
+        AtomAbsMTTouchMajor,
+        AtomAbsMTTouchMinor,
+        AtomAbsMTOrientation,
+        AtomAbsMTPressure,
+        AtomAbsMTTrackingID,
+        AtomMaxContacts,
+        AtomRelX,
+        AtomRelY,
         // XInput2 tablet
-        AbsX,
-        AbsY,
-        AbsPressure,
-        AbsTiltX,
-        AbsTiltY,
-        AbsWheel,
-        AbsDistance,
-        WacomSerialIDs,
-        INTEGER,
-        RelHorizWheel,
-        RelVertWheel,
-        RelHorizScroll,
-        RelVertScroll,
-
-        _XSETTINGS_SETTINGS,
-
-        _COMPIZ_DECOR_PENDING,
-        _COMPIZ_DECOR_REQUEST,
-        _COMPIZ_DECOR_DELETE_PIXMAP,
-        _COMPIZ_TOOLKIT_ACTION,
-        _GTK_LOAD_ICONTHEMES,
-
-        AT_SPI_BUS,
-
-        EDID,
-        EDID_DATA,
-        XFree86_DDC_EDID1_RAWDATA,
-
-        _ICC_PROFILE,
+        AtomAbsX,
+        AtomAbsY,
+        AtomAbsPressure,
+        AtomAbsTiltX,
+        AtomAbsTiltY,
+        AtomAbsWheel,
+        AtomAbsDistance,
+        AtomWacomSerialIDs,
+        AtomINTEGER,
+        AtomRelHorizWheel,
+        AtomRelVertWheel,
+        AtomRelHorizScroll,
+        AtomRelVertScroll,
+
+        Atom_XSETTINGS_SETTINGS,
+
+        Atom_COMPIZ_DECOR_PENDING,
+        Atom_COMPIZ_DECOR_REQUEST,
+        Atom_COMPIZ_DECOR_DELETE_PIXMAP,
+        Atom_COMPIZ_TOOLKIT_ACTION,
+        Atom_GTK_LOAD_ICONTHEMES,
+
+        AtomAT_SPI_BUS,
+
+        AtomEDID,
+        AtomEDID_DATA,
+        AtomXFree86_DDC_EDID1_RAWDATA,
+
+        Atom_ICC_PROFILE,
 
         NAtoms
     };
diff --git a/src/plugins/platforms/xcb/qxcbclipboard.cpp b/src/plugins/platforms/xcb/qxcbclipboard.cpp
index 7c3a9d0741..0de0db2a58 100644
--- a/src/plugins/platforms/xcb/qxcbclipboard.cpp
+++ b/src/plugins/platforms/xcb/qxcbclipboard.cpp
@@ -31,7 +31,7 @@ public:
             break;
 
         case QClipboard::Clipboard:
-            modeAtom = m_clipboard->atom(QXcbAtom::CLIPBOARD);
+            modeAtom = m_clipboard->atom(QXcbAtom::AtomCLIPBOARD);
             break;
 
         default:
@@ -61,7 +61,7 @@ protected:
             // get the list of targets from the current clipboard owner - we do this
             // once so that multiple calls to this function don't require multiple
             // server round trips...
-            that->format_atoms = m_clipboard->getDataInFormat(modeAtom, m_clipboard->atom(QXcbAtom::TARGETS));
+            that->format_atoms = m_clipboard->getDataInFormat(modeAtom, m_clipboard->atom(QXcbAtom::AtomTARGETS));
 
             if (format_atoms.size() > 0) {
                 const xcb_atom_t *targets = (const xcb_atom_t *) format_atoms.data();
@@ -203,7 +203,7 @@ QXcbClipboard::QXcbClipboard(QXcbConnection *c)
         xcb_xfixes_select_selection_input_checked(xcb_connection(), connection()->qtSelectionOwner(),
                                                   XCB_ATOM_PRIMARY, mask);
         xcb_xfixes_select_selection_input_checked(xcb_connection(), connection()->qtSelectionOwner(),
-                                                  atom(QXcbAtom::CLIPBOARD), mask);
+                                                  atom(QXcbAtom::AtomCLIPBOARD), mask);
     }
 
     // xcb_change_property_request_t and xcb_get_property_request_t are the same size
@@ -218,13 +218,13 @@ QXcbClipboard::~QXcbClipboard()
             m_timestamp[QClipboard::Selection] != XCB_CURRENT_TIME) {
 
         // First we check if there is a clipboard manager.
-        if (connection()->selectionOwner(atom(QXcbAtom::CLIPBOARD_MANAGER)) != XCB_NONE) {
+        if (connection()->selectionOwner(atom(QXcbAtom::AtomCLIPBOARD_MANAGER)) != XCB_NONE) {
             // we delete the property so the manager saves all TARGETS.
             xcb_delete_property(xcb_connection(), connection()->qtSelectionOwner(),
-                                atom(QXcbAtom::_QT_SELECTION));
+                                atom(QXcbAtom::Atom_QT_SELECTION));
             xcb_convert_selection(xcb_connection(), connection()->qtSelectionOwner(),
-                                  atom(QXcbAtom::CLIPBOARD_MANAGER), atom(QXcbAtom::SAVE_TARGETS),
-                                  atom(QXcbAtom::_QT_SELECTION), connection()->time());
+                                  atom(QXcbAtom::AtomCLIPBOARD_MANAGER), atom(QXcbAtom::AtomSAVE_TARGETS),
+                                  atom(QXcbAtom::Atom_QT_SELECTION), connection()->time());
             connection()->sync();
 
             // waiting until the clipboard manager fetches the content.
@@ -259,7 +259,7 @@ bool QXcbClipboard::handlePropertyNotify(const xcb_generic_event_t *event)
 xcb_atom_t QXcbClipboard::atomForMode(QClipboard::Mode mode) const
 {
     if (mode == QClipboard::Clipboard)
-        return atom(QXcbAtom::CLIPBOARD);
+        return atom(QXcbAtom::AtomCLIPBOARD);
     if (mode == QClipboard::Selection)
         return XCB_ATOM_PRIMARY;
     return XCB_NONE;
@@ -269,7 +269,7 @@ QClipboard::Mode QXcbClipboard::modeForAtom(xcb_atom_t a) const
 {
     if (a == XCB_ATOM_PRIMARY)
         return QClipboard::Selection;
-    if (a == atom(QXcbAtom::CLIPBOARD))
+    if (a == atom(QXcbAtom::AtomCLIPBOARD))
         return QClipboard::Clipboard;
     // not supported enum value, used to detect errors
     return QClipboard::FindBuffer;
@@ -412,10 +412,10 @@ xcb_atom_t QXcbClipboard::sendTargetsSelection(QMimeData *d, xcb_window_t window
                 types.append(atoms.at(j));
         }
     }
-    types.append(atom(QXcbAtom::TARGETS));
-    types.append(atom(QXcbAtom::MULTIPLE));
-    types.append(atom(QXcbAtom::TIMESTAMP));
-    types.append(atom(QXcbAtom::SAVE_TARGETS));
+    types.append(atom(QXcbAtom::AtomTARGETS));
+    types.append(atom(QXcbAtom::AtomMULTIPLE));
+    types.append(atom(QXcbAtom::AtomTIMESTAMP));
+    types.append(atom(QXcbAtom::AtomSAVE_TARGETS));
 
     xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, window, property, XCB_ATOM_ATOM,
                         32, types.size(), (const void *)types.constData());
@@ -439,7 +439,7 @@ xcb_atom_t QXcbClipboard::sendSelection(QMimeData *d, xcb_atom_t target, xcb_win
 
          // don't allow INCR transfers when using MULTIPLE or to
         // Motif clients (since Motif doesn't support INCR)
-        static xcb_atom_t motif_clip_temporary = atom(QXcbAtom::CLIP_TEMPORARY);
+        static xcb_atom_t motif_clip_temporary = atom(QXcbAtom::AtomCLIP_TEMPORARY);
         bool allow_incr = property != motif_clip_temporary;
         // This 'bool' can be removed once there is a proper fix for QTBUG-32853
         if (m_clipboard_closing)
@@ -448,7 +448,7 @@ xcb_atom_t QXcbClipboard::sendSelection(QMimeData *d, xcb_atom_t target, xcb_win
         if (data.size() > m_maxPropertyRequestDataBytes && allow_incr) {
             long bytes = data.size();
             xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, window, property,
-                                atom(QXcbAtom::INCR), 32, 1, (const void *)&bytes);
+                                atom(QXcbAtom::AtomINCR), 32, 1, (const void *)&bytes);
             auto transaction = new QXcbClipboardTransaction(this, window, property, data, atomFormat, dataFormat);
             m_transactions.insert(window, transaction);
             return property;
@@ -532,9 +532,9 @@ void QXcbClipboard::handleSelectionRequest(xcb_selection_request_event_t *req)
         return;
     }
 
-    xcb_atom_t targetsAtom = atom(QXcbAtom::TARGETS);
-    xcb_atom_t multipleAtom = atom(QXcbAtom::MULTIPLE);
-    xcb_atom_t timestampAtom = atom(QXcbAtom::TIMESTAMP);
+    xcb_atom_t targetsAtom = atom(QXcbAtom::AtomTARGETS);
+    xcb_atom_t multipleAtom = atom(QXcbAtom::AtomMULTIPLE);
+    xcb_atom_t timestampAtom = atom(QXcbAtom::AtomTIMESTAMP);
 
     struct AtomPair { xcb_atom_t target; xcb_atom_t property; } *multi = nullptr;
     xcb_atom_t multi_type = XCB_NONE;
@@ -708,7 +708,7 @@ bool QXcbClipboard::clipboardReadProperty(xcb_window_t win, xcb_atom_t property,
     // correct size, not 0-term.
     if (size)
         *size = buffer_offset;
-    if (*type == atom(QXcbAtom::INCR))
+    if (*type == atom(QXcbAtom::AtomINCR))
         m_incr_receive_time = connection()->getTimestamp();
     if (deleteProperty)
         xcb_delete_property(xcb_connection(), win, property);
@@ -747,12 +747,12 @@ xcb_generic_event_t *QXcbClipboard::waitForClipboardEvent(xcb_window_t window, i
         const QXcbEventNode *flushedTailNode = queue->flushedTail();
 
         if (checkManager) {
-            if (connection()->selectionOwner(atom(QXcbAtom::CLIPBOARD_MANAGER)) == XCB_NONE)
+            if (connection()->selectionOwner(atom(QXcbAtom::AtomCLIPBOARD_MANAGER)) == XCB_NONE)
                 return nullptr;
         }
 
         // process other clipboard events, since someone is probably requesting data from us
-        auto clipboardAtom = atom(QXcbAtom::CLIPBOARD);
+        auto clipboardAtom = atom(QXcbAtom::AtomCLIPBOARD);
         e = queue->peek([clipboardAtom](xcb_generic_event_t *event, int type) {
             xcb_atom_t selection = XCB_ATOM_NONE;
             if (type == XCB_SELECTION_REQUEST)
@@ -846,7 +846,7 @@ QByteArray QXcbClipboard::clipboardReadIncrementalProperty(xcb_window_t win, xcb
 
 QByteArray QXcbClipboard::getDataInFormat(xcb_atom_t modeAtom, xcb_atom_t fmtAtom)
 {
-    return getSelection(modeAtom, fmtAtom, atom(QXcbAtom::_QT_SELECTION));
+    return getSelection(modeAtom, fmtAtom, atom(QXcbAtom::Atom_QT_SELECTION));
 }
 
 QByteArray QXcbClipboard::getSelection(xcb_atom_t selection, xcb_atom_t target, xcb_atom_t property, xcb_timestamp_t time)
@@ -870,7 +870,7 @@ QByteArray QXcbClipboard::getSelection(xcb_atom_t selection, xcb_atom_t target,
 
     xcb_atom_t type;
     if (clipboardReadProperty(win, property, true, &buf, nullptr, &type, nullptr)) {
-        if (type == atom(QXcbAtom::INCR)) {
+        if (type == atom(QXcbAtom::AtomINCR)) {
             int nbytes = buf.size() >= 4 ? *((int*)buf.data()) : 0;
             buf = clipboardReadIncrementalProperty(win, property, nbytes, false);
         }
diff --git a/src/plugins/platforms/xcb/qxcbconnection.cpp b/src/plugins/platforms/xcb/qxcbconnection.cpp
index 1be95b8414..2e103b0eb2 100644
--- a/src/plugins/platforms/xcb/qxcbconnection.cpp
+++ b/src/plugins/platforms/xcb/qxcbconnection.cpp
@@ -602,12 +602,12 @@ void QXcbConnection::handleXcbEvent(xcb_generic_event_t *event)
         if (clientMessage->format != 32)
             return;
 #if QT_CONFIG(draganddrop)
-        if (clientMessage->type == atom(QXcbAtom::XdndStatus))
+        if (clientMessage->type == atom(QXcbAtom::AtomXdndStatus))
             drag()->handleStatus(clientMessage);
-        else if (clientMessage->type == atom(QXcbAtom::XdndFinished))
+        else if (clientMessage->type == atom(QXcbAtom::AtomXdndFinished))
             drag()->handleFinished(clientMessage);
 #endif
-        if (m_systemTrayTracker && clientMessage->type == atom(QXcbAtom::MANAGER))
+        if (m_systemTrayTracker && clientMessage->type == atom(QXcbAtom::AtomMANAGER))
             m_systemTrayTracker->notifyManagerClientMessageEvent(clientMessage);
         HANDLE_PLATFORM_WINDOW_EVENT(xcb_client_message_event_t, window, handleClientMessageEvent);
     }
@@ -658,7 +658,7 @@ void QXcbConnection::handleXcbEvent(xcb_generic_event_t *event)
         setTime(selectionRequest->time);
 #endif
 #if QT_CONFIG(draganddrop)
-        if (selectionRequest->selection == atom(QXcbAtom::XdndSelection))
+        if (selectionRequest->selection == atom(QXcbAtom::AtomXdndSelection))
             m_drag->handleSelectionRequest(selectionRequest);
         else
 #endif
@@ -686,11 +686,11 @@ void QXcbConnection::handleXcbEvent(xcb_generic_event_t *event)
         if (m_clipboard->handlePropertyNotify(event))
             break;
 #endif
-        if (propertyNotify->atom == atom(QXcbAtom::_NET_WORKAREA)) {
+        if (propertyNotify->atom == atom(QXcbAtom::Atom_NET_WORKAREA)) {
             QXcbVirtualDesktop *virtualDesktop = virtualDesktopForRootWindow(propertyNotify->window);
             if (virtualDesktop)
                 virtualDesktop->updateWorkArea();
-        } else if (propertyNotify->atom == atom(QXcbAtom::_NET_SUPPORTED)) {
+        } else if (propertyNotify->atom == atom(QXcbAtom::Atom_NET_SUPPORTED)) {
             m_wmSupport->updateNetWMAtoms();
         } else {
             HANDLE_PLATFORM_WINDOW_EVENT(xcb_property_notify_event_t, window, handlePropertyNotifyEvent);
@@ -787,13 +787,13 @@ void QXcbConnection::setStartupId(const QByteArray &nextId)
             xcb_change_property(xcb_connection(),
                                 XCB_PROP_MODE_REPLACE,
                                 clientLeader(),
-                                atom(QXcbAtom::_NET_STARTUP_ID),
-                                atom(QXcbAtom::UTF8_STRING),
+                                atom(QXcbAtom::Atom_NET_STARTUP_ID),
+                                atom(QXcbAtom::AtomUTF8_STRING),
                                 8,
                                 nextId.size(),
                                 nextId.constData());
         else
-            xcb_delete_property(xcb_connection(), clientLeader(), atom(QXcbAtom::_NET_STARTUP_ID));
+            xcb_delete_property(xcb_connection(), clientLeader(), atom(QXcbAtom::Atom_NET_STARTUP_ID));
     }
 }
 
@@ -822,7 +822,7 @@ xcb_timestamp_t QXcbConnection::getTimestamp()
 {
     // send a dummy event to myself to get the timestamp from X server.
     xcb_window_t window = rootWindow();
-    xcb_atom_t dummyAtom = atom(QXcbAtom::_QT_GET_TIMESTAMP);
+    xcb_atom_t dummyAtom = atom(QXcbAtom::Atom_QT_GET_TIMESTAMP);
     xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, window, dummyAtom,
                         XCB_ATOM_INTEGER, 32, 0, nullptr);
 
@@ -921,7 +921,7 @@ xcb_window_t QXcbConnection::clientLeader()
         xcb_change_property(xcb_connection(),
                             XCB_PROP_MODE_REPLACE,
                             m_clientLeader,
-                            atom(QXcbAtom::WM_CLIENT_LEADER),
+                            atom(QXcbAtom::AtomWM_CLIENT_LEADER),
                             XCB_ATOM_WINDOW,
                             32,
                             1,
@@ -934,7 +934,7 @@ xcb_window_t QXcbConnection::clientLeader()
             xcb_change_property(xcb_connection(),
                                 XCB_PROP_MODE_REPLACE,
                                 m_clientLeader,
-                                atom(QXcbAtom::SM_CLIENT_ID),
+                                atom(QXcbAtom::AtomSM_CLIENT_ID),
                                 XCB_ATOM_STRING,
                                 8,
                                 session.size(),
@@ -1055,8 +1055,8 @@ bool QXcbConnection::isUserInputEvent(xcb_generic_event_t *event) const
 
     if (eventType == XCB_CLIENT_MESSAGE) {
         auto clientMessage = reinterpret_cast<const xcb_client_message_event_t *>(event);
-        if (clientMessage->format == 32 && clientMessage->type == atom(QXcbAtom::WM_PROTOCOLS))
-            if (clientMessage->data.data32[0] == atom(QXcbAtom::WM_DELETE_WINDOW))
+        if (clientMessage->format == 32 && clientMessage->type == atom(QXcbAtom::AtomWM_PROTOCOLS))
+            if (clientMessage->data.data32[0] == atom(QXcbAtom::AtomWM_DELETE_WINDOW))
                 isInputEvent = true;
     }
 
diff --git a/src/plugins/platforms/xcb/qxcbconnection_xi2.cpp b/src/plugins/platforms/xcb/qxcbconnection_xi2.cpp
index 03e758bf85..c995a27d33 100644
--- a/src/plugins/platforms/xcb/qxcbconnection_xi2.cpp
+++ b/src/plugins/platforms/xcb/qxcbconnection_xi2.cpp
@@ -270,9 +270,9 @@ void QXcbConnection::xi2SetupSlavePointerDevice(void *info, bool removeExisting,
                 tabletData.valuatorInfo[valuatorAtom] = info;
             }
 #endif // QT_CONFIG(tabletevent)
-            if (valuatorAtom == QXcbAtom::RelHorizScroll || valuatorAtom == QXcbAtom::RelHorizWheel)
+            if (valuatorAtom == QXcbAtom::AtomRelHorizScroll || valuatorAtom == QXcbAtom::AtomRelHorizWheel)
                 scrollingDevice()->lastScrollPosition.setX(fixed3232ToReal(vci->value));
-            else if (valuatorAtom == QXcbAtom::RelVertScroll || valuatorAtom == QXcbAtom::RelVertWheel)
+            else if (valuatorAtom == QXcbAtom::AtomRelVertScroll || valuatorAtom == QXcbAtom::AtomRelVertWheel)
                 scrollingDevice()->lastScrollPosition.setY(fixed3232ToReal(vci->value));
             break;
         }
@@ -300,14 +300,14 @@ void QXcbConnection::xi2SetupSlavePointerDevice(void *info, bool removeExisting,
                 xcb_atom_t label5 = labels[4];
                 // Some drivers have no labels on the wheel buttons, some have no label on just one and some have no label on
                 // button 4 and the wrong one on button 5. So we just check that they are not labelled with unrelated buttons.
-                if ((!label4 || qatom(label4) == QXcbAtom::ButtonWheelUp || qatom(label4) == QXcbAtom::ButtonWheelDown) &&
-                    (!label5 || qatom(label5) == QXcbAtom::ButtonWheelUp || qatom(label5) == QXcbAtom::ButtonWheelDown))
+                if ((!label4 || qatom(label4) == QXcbAtom::AtomButtonWheelUp || qatom(label4) == QXcbAtom::AtomButtonWheelDown) &&
+                    (!label5 || qatom(label5) == QXcbAtom::AtomButtonWheelUp || qatom(label5) == QXcbAtom::AtomButtonWheelDown))
                     scrollingDevice()->legacyOrientations |= Qt::Vertical;
             }
             if (bci->num_buttons >= 7) {
                 xcb_atom_t label6 = labels[5];
                 xcb_atom_t label7 = labels[6];
-                if ((!label6 || qatom(label6) == QXcbAtom::ButtonHorizWheelLeft) && (!label7 || qatom(label7) == QXcbAtom::ButtonHorizWheelRight))
+                if ((!label6 || qatom(label6) == QXcbAtom::AtomButtonHorizWheelLeft) && (!label7 || qatom(label7) == QXcbAtom::AtomButtonHorizWheelRight))
                     scrollingDevice()->legacyOrientations |= Qt::Horizontal;
             }
             buttonCount = bci->num_buttons;
@@ -331,9 +331,9 @@ void QXcbConnection::xi2SetupSlavePointerDevice(void *info, bool removeExisting,
     bool isTablet = false;
 #if QT_CONFIG(tabletevent)
     // If we have found the valuators which we expect a tablet to have, it might be a tablet.
-    if (tabletData.valuatorInfo.contains(QXcbAtom::AbsX) &&
-            tabletData.valuatorInfo.contains(QXcbAtom::AbsY) &&
-            tabletData.valuatorInfo.contains(QXcbAtom::AbsPressure))
+    if (tabletData.valuatorInfo.contains(QXcbAtom::AtomAbsX) &&
+            tabletData.valuatorInfo.contains(QXcbAtom::AtomAbsY) &&
+            tabletData.valuatorInfo.contains(QXcbAtom::AtomAbsPressure))
         isTablet = true;
 
     // But we need to be careful not to take the touch and tablet-button devices as tablets.
@@ -356,7 +356,7 @@ void QXcbConnection::xi2SetupSlavePointerDevice(void *info, bool removeExisting,
         // combined device (evdev) rather than separate pen/eraser (wacom driver)
         tabletData.pointerType = QPointingDevice::PointerType::Pen;
         dbgType = "pen"_L1;
-    } else if (nameLower.contains("aiptek") /* && device == QXcbAtom::KEYBOARD */) {
+    } else if (nameLower.contains("aiptek") /* && device == QXcbAtom::AtomKEYBOARD */) {
         // some "Genius" tablets
         isTablet = true;
         tabletData.pointerType = QPointingDevice::PointerType::Pen;
@@ -384,9 +384,9 @@ void QXcbConnection::xi2SetupSlavePointerDevice(void *info, bool removeExisting,
         m_tabletData.append(tabletData);
         qCDebug(lcQpaXInputDevices) << "   it's a tablet with pointer type" << dbgType;
         QPointingDevice::Capabilities capsOverride = QInputDevice::Capability::None;
-        if (tabletData.valuatorInfo.contains(QXcbAtom::AbsTiltX))
+        if (tabletData.valuatorInfo.contains(QXcbAtom::AtomAbsTiltX))
             capsOverride.setFlag(QInputDevice::Capability::XTilt);
-        if (tabletData.valuatorInfo.contains(QXcbAtom::AbsTiltY))
+        if (tabletData.valuatorInfo.contains(QXcbAtom::AtomAbsTiltY))
             capsOverride.setFlag(QInputDevice::Capability::YTilt);
         // TODO can we get USB ID?
         Q_ASSERT(deviceInfo->deviceid == tabletData.deviceId);
@@ -573,27 +573,27 @@ QXcbConnection::TouchDeviceData *QXcbConnection::populateTouchDevices(void *info
             // Some devices (mice) report a resolution of 0; they will be excluded later,
             // for now just prevent a division by zero
             const int vciResolution = vci->resolution ? vci->resolution : 1;
-            if (valuatorAtom == QXcbAtom::AbsMTPositionX)
+            if (valuatorAtom == QXcbAtom::AtomAbsMTPositionX)
                 caps |= QInputDevice::Capability::Position | QInputDevice::Capability::NormalizedPosition;
-            else if (valuatorAtom == QXcbAtom::AbsMTTouchMajor)
+            else if (valuatorAtom == QXcbAtom::AtomAbsMTTouchMajor)
                 caps |= QInputDevice::Capability::Area;
-            else if (valuatorAtom == QXcbAtom::AbsMTOrientation)
+            else if (valuatorAtom == QXcbAtom::AtomAbsMTOrientation)
                 dev.providesTouchOrientation = true;
-            else if (valuatorAtom == QXcbAtom::AbsMTPressure || valuatorAtom == QXcbAtom::AbsPressure)
+            else if (valuatorAtom == QXcbAtom::AtomAbsMTPressure || valuatorAtom == QXcbAtom::AtomAbsPressure)
                 caps |= QInputDevice::Capability::Pressure;
-            else if (valuatorAtom == QXcbAtom::RelX) {
+            else if (valuatorAtom == QXcbAtom::AtomRelX) {
                 hasRelativeCoords = true;
                 dev.size.setWidth((fixed3232ToReal(vci->max) - fixed3232ToReal(vci->min)) * 1000.0 / vciResolution);
-            } else if (valuatorAtom == QXcbAtom::RelY) {
+            } else if (valuatorAtom == QXcbAtom::AtomRelY) {
                 hasRelativeCoords = true;
                 dev.size.setHeight((fixed3232ToReal(vci->max) - fixed3232ToReal(vci->min)) * 1000.0 / vciResolution);
-            } else if (valuatorAtom == QXcbAtom::AbsX) {
+            } else if (valuatorAtom == QXcbAtom::AtomAbsX) {
                 caps |= QInputDevice::Capability::Position;
                 dev.size.setWidth((fixed3232ToReal(vci->max) - fixed3232ToReal(vci->min)) * 1000.0 / vciResolution);
-            } else if (valuatorAtom == QXcbAtom::AbsY) {
+            } else if (valuatorAtom == QXcbAtom::AtomAbsY) {
                 caps |= QInputDevice::Capability::Position;
                 dev.size.setHeight((fixed3232ToReal(vci->max) - fixed3232ToReal(vci->min)) * 1000.0 / vciResolution);
-            } else if (valuatorAtom == QXcbAtom::RelVertWheel || valuatorAtom == QXcbAtom::RelHorizWheel) {
+            } else if (valuatorAtom == QXcbAtom::AtomRelVertWheel || valuatorAtom == QXcbAtom::AtomRelHorizWheel) {
                 caps |= QInputDevice::Capability::Scroll;
             }
             break;
@@ -804,27 +804,27 @@ void QXcbConnection::xi2ProcessTouch(void *xiDevEvent, QXcbWindow *platformWindo
         if (value < vci.min)
             value = vci.min;
         qreal valuatorNormalized = (value - vci.min) / (vci.max - vci.min);
-        if (vci.label == QXcbAtom::RelX) {
+        if (vci.label == QXcbAtom::AtomRelX) {
             nx = valuatorNormalized;
-        } else if (vci.label == QXcbAtom::RelY) {
+        } else if (vci.label == QXcbAtom::AtomRelY) {
             ny = valuatorNormalized;
-        } else if (vci.label == QXcbAtom::AbsX) {
+        } else if (vci.label == QXcbAtom::AtomAbsX) {
             nx = valuatorNormalized;
-        } else if (vci.label == QXcbAtom::AbsY) {
+        } else if (vci.label == QXcbAtom::AtomAbsY) {
             ny = valuatorNormalized;
-        } else if (vci.label == QXcbAtom::AbsMTPositionX) {
+        } else if (vci.label == QXcbAtom::AtomAbsMTPositionX) {
             nx = valuatorNormalized;
-        } else if (vci.label == QXcbAtom::AbsMTPositionY) {
+        } else if (vci.label == QXcbAtom::AtomAbsMTPositionY) {
             ny = valuatorNormalized;
-        } else if (vci.label == QXcbAtom::AbsMTTouchMajor) {
+        } else if (vci.label == QXcbAtom::AtomAbsMTTouchMajor) {
             const qreal sw = screen->geometry().width();
             const qreal sh = screen->geometry().height();
             w = valuatorNormalized * qHypot(sw, sh);
-        } else if (vci.label == QXcbAtom::AbsMTTouchMinor) {
+        } else if (vci.label == QXcbAtom::AtomAbsMTTouchMinor) {
             const qreal sw = screen->geometry().width();
             const qreal sh = screen->geometry().height();
             h = valuatorNormalized * qHypot(sw, sh);
-        } else if (vci.label == QXcbAtom::AbsMTOrientation) {
+        } else if (vci.label == QXcbAtom::AtomAbsMTOrientation) {
             // Find the closest axis.
             // 0 corresponds to the Y axis, vci.max to the X axis.
             // Flipping over the Y axis and rotating by 180 degrees
@@ -835,7 +835,7 @@ void QXcbConnection::xi2ProcessTouch(void *xiDevEvent, QXcbWindow *platformWindo
                 value -= 2 * vci.max;
             value = qAbs(value);
             majorAxisIsY = value < vci.max - value;
-        } else if (vci.label == QXcbAtom::AbsMTPressure || vci.label == QXcbAtom::AbsPressure) {
+        } else if (vci.label == QXcbAtom::AtomAbsMTPressure || vci.label == QXcbAtom::AtomAbsPressure) {
             touchPoint.pressure = valuatorNormalized;
         }
 
@@ -967,7 +967,7 @@ void QXcbConnection::abortSystemMoveResize(xcb_window_t window)
     qCDebug(lcQpaXInputDevices) << "sending client message NET_WM_MOVERESIZE_CANCEL to window: " << window;
     m_startSystemMoveResizeInfo.window = XCB_NONE;
 
-    const xcb_atom_t moveResize = connection()->atom(QXcbAtom::_NET_WM_MOVERESIZE);
+    const xcb_atom_t moveResize = connection()->atom(QXcbAtom::Atom_NET_WM_MOVERESIZE);
     xcb_client_message_event_t xev;
     xev.response_type = XCB_CLIENT_MESSAGE;
     xev.type = moveResize;
@@ -1275,9 +1275,9 @@ void QXcbConnection::xi2UpdateScrollingDevice(QInputDevice *dev)
         if (classInfo->type == XCB_INPUT_DEVICE_CLASS_TYPE_VALUATOR) {
             auto *vci = reinterpret_cast<xcb_input_valuator_class_t *>(classInfo);
             const int valuatorAtom = qatom(vci->label);
-            if (valuatorAtom == QXcbAtom::RelHorizScroll || valuatorAtom == QXcbAtom::RelHorizWheel)
+            if (valuatorAtom == QXcbAtom::AtomRelHorizScroll || valuatorAtom == QXcbAtom::AtomRelHorizWheel)
                 scrollingDevice->lastScrollPosition.setX(fixed3232ToReal(vci->value));
-            else if (valuatorAtom == QXcbAtom::RelVertScroll || valuatorAtom == QXcbAtom::RelVertWheel)
+            else if (valuatorAtom == QXcbAtom::AtomRelVertScroll || valuatorAtom == QXcbAtom::AtomRelVertWheel)
                 scrollingDevice->lastScrollPosition.setY(fixed3232ToReal(vci->value));
         }
     }
@@ -1464,7 +1464,7 @@ bool QXcbConnection::xi2HandleTabletEvent(const void *event, TabletData *tabletD
         // The evdev driver doesn't do it this way.
         const auto *ev = reinterpret_cast<const xcb_input_property_event_t *>(event);
         if (ev->what == XCB_INPUT_PROPERTY_FLAG_MODIFIED) {
-            if (ev->property == atom(QXcbAtom::WacomSerialIDs)) {
+            if (ev->property == atom(QXcbAtom::AtomWacomSerialIDs)) {
                 enum WacomSerialIndex {
                     _WACSER_USB_ID = 0,
                     _WACSER_LAST_TOOL_SERIAL,
@@ -1477,7 +1477,7 @@ bool QXcbConnection::xi2HandleTabletEvent(const void *event, TabletData *tabletD
                 auto reply = Q_XCB_REPLY(xcb_input_xi_get_property, xcb_connection(), tabletData->deviceId, 0,
                                          ev->property, XCB_GET_PROPERTY_TYPE_ANY, 0, 100);
                 if (reply) {
-                    if (reply->type == atom(QXcbAtom::INTEGER) && reply->format == 32 && reply->num_items == _WACSER_COUNT) {
+                    if (reply->type == atom(QXcbAtom::AtomINTEGER) && reply->format == 32 && reply->num_items == _WACSER_COUNT) {
                         quint32 *ptr = reinterpret_cast<quint32 *>(xcb_input_xi_get_property_items(reply.get()));
                         quint32 tool = ptr[_WACSER_TOOL_ID];
                         // Workaround for http://sourceforge.net/p/linuxwacom/bugs/246/
@@ -1570,30 +1570,30 @@ void QXcbConnection::xi2ReportTabletEvent(const void *event, TabletData *tabletD
         xi2GetValuatorValueIfSet(event, classInfo.number, &classInfo.curVal);
         double normalizedValue = (classInfo.curVal - classInfo.minVal) / (classInfo.maxVal - classInfo.minVal);
         switch (valuator) {
-        case QXcbAtom::AbsX:
+        case QXcbAtom::AtomAbsX:
             if (Q_LIKELY(useValuators)) {
                 const qreal value = scaleOneValuator(normalizedValue, physicalScreenArea.x(), physicalScreenArea.width());
                 global.setX(value);
                 local.setX(xcbWindow->mapFromGlobalF(global).x());
             }
             break;
-        case QXcbAtom::AbsY:
+        case QXcbAtom::AtomAbsY:
             if (Q_LIKELY(useValuators)) {
                 qreal value = scaleOneValuator(normalizedValue, physicalScreenArea.y(), physicalScreenArea.height());
                 global.setY(value);
                 local.setY(xcbWindow->mapFromGlobalF(global).y());
             }
             break;
-        case QXcbAtom::AbsPressure:
+        case QXcbAtom::AtomAbsPressure:
             pressure = normalizedValue;
             break;
-        case QXcbAtom::AbsTiltX:
+        case QXcbAtom::AtomAbsTiltX:
             xTilt = classInfo.curVal;
             break;
-        case QXcbAtom::AbsTiltY:
+        case QXcbAtom::AtomAbsTiltY:
             yTilt = classInfo.curVal;
             break;
-        case QXcbAtom::AbsWheel:
+        case QXcbAtom::AtomAbsWheel:
             switch (tabletData->tool) {
             case QInputDevice::DeviceType::Airbrush:
                 tangentialPressure = normalizedValue * 2.0 - 1.0; // Convert 0..1 range to -1..+1 range
diff --git a/src/plugins/platforms/xcb/qxcbdrag.cpp b/src/plugins/platforms/xcb/qxcbdrag.cpp
index 3dc52c9f06..e209277144 100644
--- a/src/plugins/platforms/xcb/qxcbdrag.cpp
+++ b/src/plugins/platforms/xcb/qxcbdrag.cpp
@@ -44,7 +44,7 @@ static xcb_window_t xdndProxy(QXcbConnection *c, xcb_window_t w)
     xcb_window_t proxy = XCB_NONE;
 
     auto reply = Q_XCB_REPLY(xcb_get_property, c->xcb_connection(),
-                             false, w, c->atom(QXcbAtom::XdndProxy), XCB_ATOM_WINDOW, 0, 1);
+                             false, w, c->atom(QXcbAtom::AtomXdndProxy), XCB_ATOM_WINDOW, 0, 1);
 
     if (reply && reply->type == XCB_ATOM_WINDOW)
         proxy = *((xcb_window_t *)xcb_get_property_value(reply.get()));
@@ -54,7 +54,7 @@ static xcb_window_t xdndProxy(QXcbConnection *c, xcb_window_t w)
 
     // exists and is real?
     reply = Q_XCB_REPLY(xcb_get_property, c->xcb_connection(),
-                        false, proxy, c->atom(QXcbAtom::XdndProxy), XCB_ATOM_WINDOW, 0, 1);
+                        false, proxy, c->atom(QXcbAtom::AtomXdndProxy), XCB_ATOM_WINDOW, 0, 1);
 
     if (reply && reply->type == XCB_ATOM_WINDOW) {
         xcb_window_t p = *((xcb_window_t *)xcb_get_property_value(reply.get()));
@@ -140,7 +140,7 @@ void QXcbDrag::startDrag()
 
     qCDebug(lcQpaXDnd) << "starting drag where source:" << connection()->qtSelectionOwner();
     xcb_set_selection_owner(xcb_connection(), connection()->qtSelectionOwner(),
-                            atom(QXcbAtom::XdndSelection), connection()->time());
+                            atom(QXcbAtom::AtomXdndSelection), connection()->time());
 
     QStringList fmts = QXcbMime::formatsHelper(drag()->mimeData());
     for (int i = 0; i < fmts.size(); ++i) {
@@ -153,7 +153,7 @@ void QXcbDrag::startDrag()
 
     if (drag_types.size() > 3)
         xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, connection()->qtSelectionOwner(),
-                            atom(QXcbAtom::XdndTypelist),
+                            atom(QXcbAtom::AtomXdndTypelist),
                             XCB_ATOM_ATOM, 32, drag_types.size(), (const void *)drag_types.constData());
 
     setUseCompositing(current_virtual_desktop->compositingActive());
@@ -187,7 +187,7 @@ Qt::DropAction QXcbDrag::defaultAction(Qt::DropActions possibleActions, Qt::Keyb
 
 void QXcbDrag::handlePropertyNotifyEvent(const xcb_property_notify_event_t *event)
 {
-    if (event->window != xdnd_dragsource || event->atom != atom(QXcbAtom::XdndActionList))
+    if (event->window != xdnd_dragsource || event->atom != atom(QXcbAtom::AtomXdndActionList))
         return;
 
     readActionList();
@@ -233,7 +233,7 @@ xcb_window_t QXcbDrag::findRealWindow(const QPoint & pos, xcb_window_t w, int md
             bool windowContainsMouse = !ignoreNonXdndAwareWindows;
             {
                 auto reply = Q_XCB_REPLY(xcb_get_property, xcb_connection(),
-                                         false, w, connection()->atom(QXcbAtom::XdndAware),
+                                         false, w, connection()->atom(QXcbAtom::AtomXdndAware),
                                          XCB_GET_PROPERTY_TYPE_ANY, 0, 0);
                 bool isAware = reply && reply->type != XCB_NONE;
                 if (isAware) {
@@ -306,7 +306,7 @@ bool QXcbDrag::findXdndAwareTarget(const QPoint &globalPos, xcb_window_t *target
             xcb_window_t child = translate->child;
 
             auto reply = Q_XCB_REPLY(xcb_get_property, xcb_connection(), false, target,
-                                     atom(QXcbAtom::XdndAware), XCB_GET_PROPERTY_TYPE_ANY, 0, 0);
+                                     atom(QXcbAtom::AtomXdndAware), XCB_GET_PROPERTY_TYPE_ANY, 0, 0);
             bool aware = reply && reply->type != XCB_NONE;
             if (aware) {
                 qCDebug(lcQpaXDnd) << "found XdndAware on" << target;
@@ -379,7 +379,7 @@ void QXcbDrag::move(const QPoint &globalPos, Qt::MouseButtons b, Qt::KeyboardMod
     if (proxy_target) {
         auto reply = Q_XCB_REPLY(xcb_get_property, xcb_connection(),
                                  false, proxy_target,
-                                 atom(QXcbAtom::XdndAware), XCB_GET_PROPERTY_TYPE_ANY, 0, 1);
+                                 atom(QXcbAtom::AtomXdndAware), XCB_GET_PROPERTY_TYPE_ANY, 0, 1);
         if (!reply || reply->type == XCB_NONE) {
             target = 0;
         } else {
@@ -404,7 +404,7 @@ void QXcbDrag::move(const QPoint &globalPos, Qt::MouseButtons b, Qt::KeyboardMod
             enter.sequence = 0;
             enter.window = target;
             enter.format = 32;
-            enter.type = atom(QXcbAtom::XdndEnter);
+            enter.type = atom(QXcbAtom::AtomXdndEnter);
             enter.data.data32[0] = connection()->qtSelectionOwner();
             enter.data.data32[1] = flags;
             enter.data.data32[2] = drag_types.size() > 0 ? drag_types.at(0) : 0;
@@ -435,7 +435,7 @@ void QXcbDrag::move(const QPoint &globalPos, Qt::MouseButtons b, Qt::KeyboardMod
         move.sequence = 0;
         move.window = target;
         move.format = 32;
-        move.type = atom(QXcbAtom::XdndPosition);
+        move.type = atom(QXcbAtom::AtomXdndPosition);
         move.data.data32[0] = connection()->qtSelectionOwner();
         move.data.data32[1] = 0; // flags
         move.data.data32[2] = (globalPos.x() << 16) + globalPos.y();
@@ -481,7 +481,7 @@ void QXcbDrag::drop(const QPoint &globalPos, Qt::MouseButtons b, Qt::KeyboardMod
     drop.sequence = 0;
     drop.window = current_target;
     drop.format = 32;
-    drop.type = atom(QXcbAtom::XdndDrop);
+    drop.type = atom(QXcbAtom::AtomXdndDrop);
     drop.data.data32[0] = connection()->qtSelectionOwner();
     drop.data.data32[1] = 0; // flags
     drop.data.data32[2] = connection()->time();
@@ -521,11 +521,11 @@ void QXcbDrag::drop(const QPoint &globalPos, Qt::MouseButtons b, Qt::KeyboardMod
 
 Qt::DropAction QXcbDrag::toDropAction(xcb_atom_t a) const
 {
-    if (a == atom(QXcbAtom::XdndActionCopy) || a == 0)
+    if (a == atom(QXcbAtom::AtomXdndActionCopy) || a == 0)
         return Qt::CopyAction;
-    if (a == atom(QXcbAtom::XdndActionLink))
+    if (a == atom(QXcbAtom::AtomXdndActionLink))
         return Qt::LinkAction;
-    if (a == atom(QXcbAtom::XdndActionMove))
+    if (a == atom(QXcbAtom::AtomXdndActionMove))
         return Qt::MoveAction;
     return Qt::CopyAction;
 }
@@ -534,7 +534,7 @@ Qt::DropActions QXcbDrag::toDropActions(const QList<xcb_atom_t> &atoms) const
 {
     Qt::DropActions actions;
     for (const auto actionAtom : atoms) {
-        if (actionAtom != atom(QXcbAtom::XdndActionAsk))
+        if (actionAtom != atom(QXcbAtom::AtomXdndActionAsk))
             actions |= toDropAction(actionAtom);
     }
     return actions;
@@ -544,16 +544,16 @@ xcb_atom_t QXcbDrag::toXdndAction(Qt::DropAction a) const
 {
     switch (a) {
     case Qt::CopyAction:
-        return atom(QXcbAtom::XdndActionCopy);
+        return atom(QXcbAtom::AtomXdndActionCopy);
     case Qt::LinkAction:
-        return atom(QXcbAtom::XdndActionLink);
+        return atom(QXcbAtom::AtomXdndActionLink);
     case Qt::MoveAction:
     case Qt::TargetMoveAction:
-        return atom(QXcbAtom::XdndActionMove);
+        return atom(QXcbAtom::AtomXdndActionMove);
     case Qt::IgnoreAction:
         return XCB_NONE;
     default:
-        return atom(QXcbAtom::XdndActionCopy);
+        return atom(QXcbAtom::AtomXdndActionCopy);
     }
 }
 
@@ -561,7 +561,7 @@ void QXcbDrag::readActionList()
 {
     drop_actions.clear();
     auto reply = Q_XCB_REPLY(xcb_get_property, xcb_connection(), false, xdnd_dragsource,
-                             atom(QXcbAtom::XdndActionList), XCB_ATOM_ATOM,
+                             atom(QXcbAtom::AtomXdndActionList), XCB_ATOM_ATOM,
                              0, 1024);
     if (reply && reply->type != XCB_NONE && reply->format == 32) {
         int length = xcb_get_property_value_length(reply.get()) / 4;
@@ -590,7 +590,7 @@ void QXcbDrag::setActionList(Qt::DropAction requestedAction, Qt::DropActions sup
 
     if (current_actions != actions) {
         xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, connection()->qtSelectionOwner(),
-                            atom(QXcbAtom::XdndActionList),
+                            atom(QXcbAtom::AtomXdndActionList),
                             XCB_ATOM_ATOM, 32, actions.size(), actions.constData());
         current_actions = actions;
     }
@@ -701,7 +701,7 @@ void QXcbDrag::handleEnter(QPlatformWindow *, const xcb_client_message_event_t *
     if (event->data.data32[1] & 1) {
         // get the types from XdndTypeList
         auto reply = Q_XCB_REPLY(xcb_get_property, xcb_connection(), false, xdnd_dragsource,
-                                 atom(QXcbAtom::XdndTypelist), XCB_ATOM_ATOM,
+                                 atom(QXcbAtom::AtomXdndTypelist), XCB_ATOM_ATOM,
                                  0, xdnd_max_type);
         if (reply && reply->type != XCB_NONE && reply->format == 32) {
             int length = xcb_get_property_value_length(reply.get()) / 4;
@@ -761,7 +761,7 @@ void QXcbDrag::handle_xdnd_position(QPlatformWindow *w, const xcb_client_message
     } else {
         dropData = m_dropData;
         supported_actions = toDropActions(drop_actions);
-        if (e->data.data32[4] != atom(QXcbAtom::XdndActionAsk))
+        if (e->data.data32[4] != atom(QXcbAtom::AtomXdndActionAsk))
             supported_actions |= Qt::DropActions(toDropAction(e->data.data32[4]));
     }
 
@@ -783,7 +783,7 @@ void QXcbDrag::handle_xdnd_position(QPlatformWindow *w, const xcb_client_message
     response.sequence = 0;
     response.window = xdnd_dragsource;
     response.format = 32;
-    response.type = atom(QXcbAtom::XdndStatus);
+    response.type = atom(QXcbAtom::AtomXdndStatus);
     response.data.data32[0] = xcb_window(w);
     response.data.data32[1] = qt_response.isAccepted(); // flags
     response.data.data32[2] = 0; // x, y
@@ -835,7 +835,7 @@ namespace
 void QXcbDrag::handlePosition(QPlatformWindow * w, const xcb_client_message_event_t *event)
 {
     xcb_client_message_event_t *lastEvent = const_cast<xcb_client_message_event_t *>(event);
-    ClientMessageScanner scanner(atom(QXcbAtom::XdndPosition));
+    ClientMessageScanner scanner(atom(QXcbAtom::AtomXdndPosition));
     while (auto nextEvent = connection()->eventQueue()->peek(scanner)) {
         if (lastEvent != event)
             free(lastEvent);
@@ -883,7 +883,7 @@ void QXcbDrag::handleStatus(const xcb_client_message_event_t *event)
 
     xcb_client_message_event_t *lastEvent = const_cast<xcb_client_message_event_t *>(event);
     xcb_generic_event_t *nextEvent;
-    ClientMessageScanner scanner(atom(QXcbAtom::XdndStatus));
+    ClientMessageScanner scanner(atom(QXcbAtom::AtomXdndStatus));
     while ((nextEvent = connection()->eventQueue()->peek(scanner))) {
         if (lastEvent != event)
             free(lastEvent);
@@ -934,7 +934,7 @@ void QXcbDrag::send_leave()
     leave.sequence = 0;
     leave.window = current_target;
     leave.format = 32;
-    leave.type = atom(QXcbAtom::XdndLeave);
+    leave.type = atom(QXcbAtom::AtomXdndLeave);
     leave.data.data32[0] = connection()->qtSelectionOwner();
     leave.data.data32[1] = 0; // flags
     leave.data.data32[2] = 0; // x, y
@@ -1024,7 +1024,7 @@ void QXcbDrag::handleDrop(QPlatformWindow *, const xcb_client_message_event_t *e
     finished.sequence = 0;
     finished.window = xdnd_dragsource;
     finished.format = 32;
-    finished.type = atom(QXcbAtom::XdndFinished);
+    finished.type = atom(QXcbAtom::AtomXdndFinished);
     finished.data.data32[0] = currentWindow ? xcb_window(currentWindow.data()) : XCB_NONE;
     finished.data.data32[1] = response.isAccepted(); // flags
     finished.data.data32[2] = toXdndAction(acceptedAaction);
@@ -1141,7 +1141,7 @@ static xcb_window_t findXdndAwareParent(QXcbConnection *c, xcb_window_t window)
     forever {
         // check if window has XdndAware
         auto gpReply = Q_XCB_REPLY(xcb_get_property, c->xcb_connection(), false, window,
-                                   c->atom(QXcbAtom::XdndAware), XCB_GET_PROPERTY_TYPE_ANY, 0, 0);
+                                   c->atom(QXcbAtom::AtomXdndAware), XCB_GET_PROPERTY_TYPE_ANY, 0, 0);
         bool aware = gpReply && gpReply->type != XCB_NONE;
         if (aware) {
             target = window;
@@ -1248,7 +1248,7 @@ bool QXcbDrag::dndEnable(QXcbWindow *w, bool on)
                 desktop_proxy = new QWindow;
                 window = static_cast<QXcbWindow *>(desktop_proxy->handle());
                 proxy_id = window->xcb_window();
-                xcb_atom_t xdnd_proxy = atom(QXcbAtom::XdndProxy);
+                xcb_atom_t xdnd_proxy = atom(QXcbAtom::AtomXdndProxy);
                 xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, w->xcb_window(), xdnd_proxy,
                                     XCB_ATOM_WINDOW, 32, 1, &proxy_id);
                 xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, proxy_id, xdnd_proxy,
@@ -1262,14 +1262,14 @@ bool QXcbDrag::dndEnable(QXcbWindow *w, bool on)
             qCDebug(lcQpaXDnd) << "setting XdndAware for" << window->xcb_window();
             xcb_atom_t atm = xdnd_version;
             xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, window->xcb_window(),
-                                atom(QXcbAtom::XdndAware), XCB_ATOM_ATOM, 32, 1, &atm);
+                                atom(QXcbAtom::AtomXdndAware), XCB_ATOM_ATOM, 32, 1, &atm);
             return true;
         } else {
             return false;
         }
     } else {
         if (w->window()->type() == Qt::Desktop) {
-            xcb_delete_property(xcb_connection(), w->xcb_window(), atom(QXcbAtom::XdndProxy));
+            xcb_delete_property(xcb_connection(), w->xcb_window(), atom(QXcbAtom::AtomXdndProxy));
             delete desktop_proxy;
             desktop_proxy = nullptr;
         } else {
@@ -1321,10 +1321,10 @@ QVariant QXcbDropData::xdndObtainData(const QByteArray &format, QMetaType reques
         return result;
 
 #ifndef QT_NO_CLIPBOARD
-    if (c->selectionOwner(c->atom(QXcbAtom::XdndSelection)) == XCB_NONE)
+    if (c->selectionOwner(c->atom(QXcbAtom::AtomXdndSelection)) == XCB_NONE)
         return result; // should never happen?
 
-    xcb_atom_t xdnd_selection = c->atom(QXcbAtom::XdndSelection);
+    xcb_atom_t xdnd_selection = c->atom(QXcbAtom::AtomXdndSelection);
     result = c->clipboard()->getSelection(xdnd_selection, a, xdnd_selection, drag->targetTime());
 #endif
 
diff --git a/src/plugins/platforms/xcb/qxcbeventqueue.cpp b/src/plugins/platforms/xcb/qxcbeventqueue.cpp
index 5c87cba80d..33795d63cf 100644
--- a/src/plugins/platforms/xcb/qxcbeventqueue.cpp
+++ b/src/plugins/platforms/xcb/qxcbeventqueue.cpp
@@ -345,7 +345,7 @@ void QXcbEventQueue::sendCloseConnectionEvent() const
     event.format = 32;
     event.sequence = 0;
     event.window = window;
-    event.type = m_connection->atom(QXcbAtom::_QT_CLOSE_CONNECTION);
+    event.type = m_connection->atom(QXcbAtom::Atom_QT_CLOSE_CONNECTION);
     event.data.data32[0] = 0;
 
     xcb_send_event(c, false, window, XCB_EVENT_MASK_NO_EVENT, reinterpret_cast<const char *>(&event));
@@ -357,7 +357,7 @@ bool QXcbEventQueue::isCloseConnectionEvent(const xcb_generic_event_t *event)
 {
     if (event && (event->response_type & ~0x80) == XCB_CLIENT_MESSAGE) {
         auto clientMessage = reinterpret_cast<const xcb_client_message_event_t *>(event);
-        if (clientMessage->type == m_connection->atom(QXcbAtom::_QT_CLOSE_CONNECTION))
+        if (clientMessage->type == m_connection->atom(QXcbAtom::Atom_QT_CLOSE_CONNECTION))
             m_closeConnectionDetected = true;
     }
     return m_closeConnectionDetected;
diff --git a/src/plugins/platforms/xcb/qxcbmime.cpp b/src/plugins/platforms/xcb/qxcbmime.cpp
index 9df9dd2bd9..9d62423071 100644
--- a/src/plugins/platforms/xcb/qxcbmime.cpp
+++ b/src/plugins/platforms/xcb/qxcbmime.cpp
@@ -27,8 +27,8 @@ QString QXcbMime::mimeAtomToString(QXcbConnection *connection, xcb_atom_t a)
 
     // special cases for string type
     if (a == XCB_ATOM_STRING
-        || a == connection->atom(QXcbAtom::UTF8_STRING)
-        || a == connection->atom(QXcbAtom::TEXT))
+        || a == connection->atom(QXcbAtom::AtomUTF8_STRING)
+        || a == connection->atom(QXcbAtom::AtomTEXT))
         return "text/plain"_L1;
 
     // special case for images
@@ -54,15 +54,15 @@ bool QXcbMime::mimeDataForAtom(QXcbConnection *connection, xcb_atom_t a, QMimeDa
     *atomFormat = a;
     *dataFormat = 8;
 
-    if ((a == connection->atom(QXcbAtom::UTF8_STRING)
+    if ((a == connection->atom(QXcbAtom::AtomUTF8_STRING)
          || a == XCB_ATOM_STRING
-         || a == connection->atom(QXcbAtom::TEXT))
+         || a == connection->atom(QXcbAtom::AtomTEXT))
         && QInternalMimeData::hasFormatHelper("text/plain"_L1, mimeData)) {
-        if (a == connection->atom(QXcbAtom::UTF8_STRING)) {
+        if (a == connection->atom(QXcbAtom::AtomUTF8_STRING)) {
             *data = QInternalMimeData::renderDataHelper("text/plain"_L1, mimeData);
             ret = true;
         } else if (a == XCB_ATOM_STRING ||
-                   a == connection->atom(QXcbAtom::TEXT)) {
+                   a == connection->atom(QXcbAtom::AtomTEXT)) {
             // ICCCM says STRING is latin1
             *data = QString::fromUtf8(QInternalMimeData::renderDataHelper(
                         "text/plain"_L1, mimeData)).toLatin1();
@@ -102,9 +102,9 @@ QList<xcb_atom_t> QXcbMime::mimeAtomsForFormat(QXcbConnection *connection, const
 
     // special cases for strings
     if (format == "text/plain"_L1) {
-        atoms.append(connection->atom(QXcbAtom::UTF8_STRING));
+        atoms.append(connection->atom(QXcbAtom::AtomUTF8_STRING));
         atoms.append(XCB_ATOM_STRING);
-        atoms.append(connection->atom(QXcbAtom::TEXT));
+        atoms.append(connection->atom(QXcbAtom::AtomTEXT));
     }
 
     // special cases for uris
@@ -139,11 +139,11 @@ QVariant QXcbMime::mimeConvertToFormat(QXcbConnection *connection, xcb_atom_t a,
     if (format == "text/plain"_L1) {
         if (data.endsWith('\0'))
             data.chop(1);
-        if (a == connection->atom(QXcbAtom::UTF8_STRING)) {
+        if (a == connection->atom(QXcbAtom::AtomUTF8_STRING)) {
             return QString::fromUtf8(data);
         }
         if (a == XCB_ATOM_STRING ||
-            a == connection->atom(QXcbAtom::TEXT))
+            a == connection->atom(QXcbAtom::AtomTEXT))
             return QString::fromLatin1(data);
     }
     // If data contains UTF16 text, convert it to a string.
@@ -227,12 +227,12 @@ xcb_atom_t QXcbMime::mimeAtomForFormat(QXcbConnection *connection, const QString
 
     // find matches for string types
     if (format == "text/plain"_L1) {
-        if (atoms.contains(connection->atom(QXcbAtom::UTF8_STRING)))
-            return connection->atom(QXcbAtom::UTF8_STRING);
+        if (atoms.contains(connection->atom(QXcbAtom::AtomUTF8_STRING)))
+            return connection->atom(QXcbAtom::AtomUTF8_STRING);
         if (atoms.contains(XCB_ATOM_STRING))
             return XCB_ATOM_STRING;
-        if (atoms.contains(connection->atom(QXcbAtom::TEXT)))
-            return connection->atom(QXcbAtom::TEXT);
+        if (atoms.contains(connection->atom(QXcbAtom::AtomTEXT)))
+            return connection->atom(QXcbAtom::AtomTEXT);
     }
 
     // find matches for uri types
diff --git a/src/plugins/platforms/xcb/qxcbnativeinterface.cpp b/src/plugins/platforms/xcb/qxcbnativeinterface.cpp
index cd6ff40df9..06f5241d8c 100644
--- a/src/plugins/platforms/xcb/qxcbnativeinterface.cpp
+++ b/src/plugins/platforms/xcb/qxcbnativeinterface.cpp
@@ -350,7 +350,7 @@ void *QXcbNativeInterface::atspiBus()
     QXcbIntegration *integration = static_cast<QXcbIntegration *>(QGuiApplicationPrivate::platformIntegration());
     QXcbConnection *connection = integration->connection();
     if (connection) {
-        auto atspiBusAtom = connection->atom(QXcbAtom::AT_SPI_BUS);
+        auto atspiBusAtom = connection->atom(QXcbAtom::AtomAT_SPI_BUS);
         auto reply = Q_XCB_REPLY(xcb_get_property, connection->xcb_connection(),
                                      false, connection->rootWindow(),
                                      atspiBusAtom, XCB_ATOM_STRING, 0, 128);
diff --git a/src/plugins/platforms/xcb/qxcbscreen.cpp b/src/plugins/platforms/xcb/qxcbscreen.cpp
index 1192af1469..06f4b66edb 100644
--- a/src/plugins/platforms/xcb/qxcbscreen.cpp
+++ b/src/plugins/platforms/xcb/qxcbscreen.cpp
@@ -50,7 +50,7 @@ QXcbVirtualDesktop::QXcbVirtualDesktop(QXcbConnection *connection, xcb_screen_t
 
     auto reply = Q_XCB_REPLY_UNCHECKED(xcb_get_property, xcb_connection(),
                                        false, screen->root,
-                                       atom(QXcbAtom::_NET_SUPPORTING_WM_CHECK),
+                                       atom(QXcbAtom::Atom_NET_SUPPORTING_WM_CHECK),
                                        XCB_ATOM_WINDOW, 0, 1024);
     if (reply && reply->format == 32 && reply->type == XCB_ATOM_WINDOW) {
         xcb_window_t windowManager = *((xcb_window_t *)xcb_get_property_value(reply.get()));
@@ -249,7 +249,7 @@ QRect QXcbVirtualDesktop::getWorkArea() const
 {
     QRect r;
     auto workArea = Q_XCB_REPLY_UNCHECKED(xcb_get_property, xcb_connection(), false, screen()->root,
-                                          atom(QXcbAtom::_NET_WORKAREA),
+                                          atom(QXcbAtom::Atom_NET_WORKAREA),
                                           XCB_ATOM_CARDINAL, 0, 1024);
     if (workArea && workArea->type == XCB_ATOM_CARDINAL && workArea->format == 32 && workArea->value_len >= 4) {
         // If workArea->value_len > 4, the remaining ones seem to be for WM's virtual desktops
@@ -529,7 +529,7 @@ void QXcbScreen::updateColorSpaceAndEdid()
         // Read colord ICC data (from GNOME settings)
         auto reply = Q_XCB_REPLY_UNCHECKED(xcb_get_property, xcb_connection(),
                                            false, screen()->root,
-                                           connection()->atom(QXcbAtom::_ICC_PROFILE),
+                                           connection()->atom(QXcbAtom::Atom_ICC_PROFILE),
                                            XCB_ATOM_CARDINAL, 0, 8192);
         if (reply->format == 8 && reply->type == XCB_ATOM_CARDINAL) {
             QByteArray data(reinterpret_cast<const char *>(xcb_get_property_value(reply.get())), reply->value_len);
@@ -817,7 +817,7 @@ void QXcbScreen::sendStartupMessage(const QByteArray &message) const
     xcb_client_message_event_t ev;
     ev.response_type = XCB_CLIENT_MESSAGE;
     ev.format = 8;
-    ev.type = connection()->atom(QXcbAtom::_NET_STARTUP_INFO_BEGIN);
+    ev.type = connection()->atom(QXcbAtom::Atom_NET_STARTUP_INFO_BEGIN);
     ev.sequence = 0;
     ev.window = rootWindow;
     int sent = 0;
@@ -825,7 +825,7 @@ void QXcbScreen::sendStartupMessage(const QByteArray &message) const
     const char *data = message.constData();
     do {
         if (sent == 20)
-            ev.type = connection()->atom(QXcbAtom::_NET_STARTUP_INFO);
+            ev.type = connection()->atom(QXcbAtom::Atom_NET_STARTUP_INFO);
 
         const int start = sent;
         const int numBytes = qMin(length - start, 20);
@@ -1095,11 +1095,11 @@ QByteArray QXcbScreen::getEdid() const
         return result;
 
     // Try a bunch of atoms
-    result = getOutputProperty(atom(QXcbAtom::EDID));
+    result = getOutputProperty(atom(QXcbAtom::AtomEDID));
     if (result.isEmpty())
-        result = getOutputProperty(atom(QXcbAtom::EDID_DATA));
+        result = getOutputProperty(atom(QXcbAtom::AtomEDID_DATA));
     if (result.isEmpty())
-        result = getOutputProperty(atom(QXcbAtom::XFree86_DDC_EDID1_RAWDATA));
+        result = getOutputProperty(atom(QXcbAtom::AtomXFree86_DDC_EDID1_RAWDATA));
 
     return result;
 }
diff --git a/src/plugins/platforms/xcb/qxcbsystemtraytracker.cpp b/src/plugins/platforms/xcb/qxcbsystemtraytracker.cpp
index e184c07128..84d2d73f91 100644
--- a/src/plugins/platforms/xcb/qxcbsystemtraytracker.cpp
+++ b/src/plugins/platforms/xcb/qxcbsystemtraytracker.cpp
@@ -26,7 +26,7 @@ enum {
 QXcbSystemTrayTracker *QXcbSystemTrayTracker::create(QXcbConnection *connection)
 {
     // Selection, tray atoms for GNOME, NET WM Specification
-    const xcb_atom_t trayAtom = connection->atom(QXcbAtom::_NET_SYSTEM_TRAY_OPCODE);
+    const xcb_atom_t trayAtom = connection->atom(QXcbAtom::Atom_NET_SYSTEM_TRAY_OPCODE);
     if (!trayAtom)
         return nullptr;
     const QByteArray netSysTray = QByteArrayLiteral("_NET_SYSTEM_TRAY_S") + QByteArray::number(connection->primaryScreenNumber());
@@ -113,7 +113,7 @@ xcb_visualid_t QXcbSystemTrayTracker::netSystemTrayVisual()
     if (m_trayWindow == XCB_WINDOW_NONE)
         return XCB_NONE;
 
-    xcb_atom_t tray_atom = m_connection->atom(QXcbAtom::_NET_SYSTEM_TRAY_VISUAL);
+    xcb_atom_t tray_atom = m_connection->atom(QXcbAtom::Atom_NET_SYSTEM_TRAY_VISUAL);
 
     // Get the xcb property for the _NET_SYSTEM_TRAY_VISUAL atom
     auto systray_atom_reply = Q_XCB_REPLY_UNCHECKED(xcb_get_property, m_connection->xcb_connection(),
diff --git a/src/plugins/platforms/xcb/qxcbwindow.cpp b/src/plugins/platforms/xcb/qxcbwindow.cpp
index a7b3ce8005..584f1e5406 100644
--- a/src/plugins/platforms/xcb/qxcbwindow.cpp
+++ b/src/plugins/platforms/xcb/qxcbwindow.cpp
@@ -360,20 +360,20 @@ void QXcbWindow::create()
 
     xcb_atom_t properties[5];
     int propertyCount = 0;
-    properties[propertyCount++] = atom(QXcbAtom::WM_DELETE_WINDOW);
-    properties[propertyCount++] = atom(QXcbAtom::WM_TAKE_FOCUS);
-    properties[propertyCount++] = atom(QXcbAtom::_NET_WM_PING);
+    properties[propertyCount++] = atom(QXcbAtom::AtomWM_DELETE_WINDOW);
+    properties[propertyCount++] = atom(QXcbAtom::AtomWM_TAKE_FOCUS);
+    properties[propertyCount++] = atom(QXcbAtom::Atom_NET_WM_PING);
 
     if (connection()->hasXSync())
-        properties[propertyCount++] = atom(QXcbAtom::_NET_WM_SYNC_REQUEST);
+        properties[propertyCount++] = atom(QXcbAtom::Atom_NET_WM_SYNC_REQUEST);
 
     if (window()->flags() & Qt::WindowContextHelpButtonHint)
-        properties[propertyCount++] = atom(QXcbAtom::_NET_WM_CONTEXT_HELP);
+        properties[propertyCount++] = atom(QXcbAtom::Atom_NET_WM_CONTEXT_HELP);
 
     xcb_change_property(xcb_connection(),
                         XCB_PROP_MODE_REPLACE,
                         m_window,
-                        atom(QXcbAtom::WM_PROTOCOLS),
+                        atom(QXcbAtom::AtomWM_PROTOCOLS),
                         XCB_ATOM_ATOM,
                         32,
                         propertyCount,
@@ -384,7 +384,7 @@ void QXcbWindow::create()
     const QByteArray wmClass = QXcbIntegration::instance()->wmClass();
     if (!wmClass.isEmpty()) {
         xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE,
-                            m_window, atom(QXcbAtom::WM_CLASS),
+                            m_window, atom(QXcbAtom::AtomWM_CLASS),
                             XCB_ATOM_STRING, 8, wmClass.size(), wmClass.constData());
     }
 
@@ -395,7 +395,7 @@ void QXcbWindow::create()
         xcb_change_property(xcb_connection(),
                             XCB_PROP_MODE_REPLACE,
                             m_window,
-                            atom(QXcbAtom::_NET_WM_SYNC_REQUEST_COUNTER),
+                            atom(QXcbAtom::Atom_NET_WM_SYNC_REQUEST_COUNTER),
                             XCB_ATOM_CARDINAL,
                             32,
                             1,
@@ -405,13 +405,13 @@ void QXcbWindow::create()
     // set the PID to let the WM kill the application if unresponsive
     quint32 pid = getpid();
     xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, m_window,
-                        atom(QXcbAtom::_NET_WM_PID), XCB_ATOM_CARDINAL, 32,
+                        atom(QXcbAtom::Atom_NET_WM_PID), XCB_ATOM_CARDINAL, 32,
                         1, &pid);
 
     const QByteArray clientMachine = QSysInfo::machineHostName().toLocal8Bit();
     if (!clientMachine.isEmpty()) {
         xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, m_window,
-                            atom(QXcbAtom::WM_CLIENT_MACHINE), XCB_ATOM_STRING, 8,
+                            atom(QXcbAtom::AtomWM_CLIENT_MACHINE), XCB_ATOM_STRING, 8,
                             clientMachine.size(), clientMachine.constData());
     }
 
@@ -425,14 +425,14 @@ void QXcbWindow::create()
 
     xcb_window_t leader = connection()->clientLeader();
     xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, m_window,
-                        atom(QXcbAtom::WM_CLIENT_LEADER), XCB_ATOM_WINDOW, 32,
+                        atom(QXcbAtom::AtomWM_CLIENT_LEADER), XCB_ATOM_WINDOW, 32,
                         1, &leader);
 
     /* Add XEMBED info; this operation doesn't initiate the embedding. */
     quint32 data[] = { XEMBED_VERSION, XEMBED_MAPPED };
     xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, m_window,
-                        atom(QXcbAtom::_XEMBED_INFO),
-                        atom(QXcbAtom::_XEMBED_INFO),
+                        atom(QXcbAtom::Atom_XEMBED_INFO),
+                        atom(QXcbAtom::Atom_XEMBED_INFO),
                         32, 2, (void *)data);
 
     if (connection()->hasXInput2())
@@ -494,7 +494,7 @@ void QXcbWindow::destroy()
         xcb_sync_destroy_counter(xcb_connection(), m_syncCounter);
     if (m_window) {
         if (m_netWmUserTimeWindow) {
-            xcb_delete_property(xcb_connection(), m_window, atom(QXcbAtom::_NET_WM_USER_TIME_WINDOW));
+            xcb_delete_property(xcb_connection(), m_window, atom(QXcbAtom::Atom_NET_WM_USER_TIME_WINDOW));
             // Some window managers, like metacity, do XSelectInput on the _NET_WM_USER_TIME_WINDOW window,
             // without trapping BadWindow (which crashes when the user time window is destroyed).
             connection()->sync();
@@ -563,9 +563,9 @@ void QXcbWindow::setGeometry(const QRect &rect)
 QMargins QXcbWindow::frameMargins() const
 {
     if (m_dirtyFrameMargins) {
-        if (connection()->wmSupport()->isSupportedByWM(atom(QXcbAtom::_NET_FRAME_EXTENTS))) {
+        if (connection()->wmSupport()->isSupportedByWM(atom(QXcbAtom::Atom_NET_FRAME_EXTENTS))) {
             auto reply = Q_XCB_REPLY(xcb_get_property, xcb_connection(), false, m_window,
-                                     atom(QXcbAtom::_NET_FRAME_EXTENTS), XCB_ATOM_CARDINAL, 0, 4);
+                                     atom(QXcbAtom::Atom_NET_FRAME_EXTENTS), XCB_ATOM_CARDINAL, 0, 4);
             if (reply && reply->type == XCB_ATOM_CARDINAL && reply->format == 32 && reply->value_len == 4) {
                 quint32 *data = (quint32 *)xcb_get_property_value(reply.get());
                 // _NET_FRAME_EXTENTS format is left, right, top, bottom
@@ -824,29 +824,29 @@ QXcbWindow::NetWmStates QXcbWindow::netWmStates()
     NetWmStates result;
 
     auto reply = Q_XCB_REPLY_UNCHECKED(xcb_get_property, xcb_connection(),
-                                       0, m_window, atom(QXcbAtom::_NET_WM_STATE),
+                                       0, m_window, atom(QXcbAtom::Atom_NET_WM_STATE),
                                        XCB_ATOM_ATOM, 0, 1024);
 
     if (reply && reply->format == 32 && reply->type == XCB_ATOM_ATOM) {
         const xcb_atom_t *states = static_cast<const xcb_atom_t *>(xcb_get_property_value(reply.get()));
         const xcb_atom_t *statesEnd = states + reply->length;
-        if (statesEnd != std::find(states, statesEnd, atom(QXcbAtom::_NET_WM_STATE_ABOVE)))
+        if (statesEnd != std::find(states, statesEnd, atom(QXcbAtom::Atom_NET_WM_STATE_ABOVE)))
             result |= NetWmStateAbove;
-        if (statesEnd != std::find(states, statesEnd, atom(QXcbAtom::_NET_WM_STATE_BELOW)))
+        if (statesEnd != std::find(states, statesEnd, atom(QXcbAtom::Atom_NET_WM_STATE_BELOW)))
             result |= NetWmStateBelow;
-        if (statesEnd != std::find(states, statesEnd, atom(QXcbAtom::_NET_WM_STATE_FULLSCREEN)))
+        if (statesEnd != std::find(states, statesEnd, atom(QXcbAtom::Atom_NET_WM_STATE_FULLSCREEN)))
             result |= NetWmStateFullScreen;
-        if (statesEnd != std::find(states, statesEnd, atom(QXcbAtom::_NET_WM_STATE_MAXIMIZED_HORZ)))
+        if (statesEnd != std::find(states, statesEnd, atom(QXcbAtom::Atom_NET_WM_STATE_MAXIMIZED_HORZ)))
             result |= NetWmStateMaximizedHorz;
-        if (statesEnd != std::find(states, statesEnd, atom(QXcbAtom::_NET_WM_STATE_MAXIMIZED_VERT)))
+        if (statesEnd != std::find(states, statesEnd, atom(QXcbAtom::Atom_NET_WM_STATE_MAXIMIZED_VERT)))
             result |= NetWmStateMaximizedVert;
-        if (statesEnd != std::find(states, statesEnd, atom(QXcbAtom::_NET_WM_STATE_MODAL)))
+        if (statesEnd != std::find(states, statesEnd, atom(QXcbAtom::Atom_NET_WM_STATE_MODAL)))
             result |= NetWmStateModal;
-        if (statesEnd != std::find(states, statesEnd, atom(QXcbAtom::_NET_WM_STATE_STAYS_ON_TOP)))
+        if (statesEnd != std::find(states, statesEnd, atom(QXcbAtom::Atom_NET_WM_STATE_STAYS_ON_TOP)))
             result |= NetWmStateStaysOnTop;
-        if (statesEnd != std::find(states, statesEnd, atom(QXcbAtom::_NET_WM_STATE_DEMANDS_ATTENTION)))
+        if (statesEnd != std::find(states, statesEnd, atom(QXcbAtom::Atom_NET_WM_STATE_DEMANDS_ATTENTION)))
             result |= NetWmStateDemandsAttention;
-        if (statesEnd != std::find(states, statesEnd, atom(QXcbAtom::_NET_WM_STATE_HIDDEN)))
+        if (statesEnd != std::find(states, statesEnd, atom(QXcbAtom::Atom_NET_WM_STATE_HIDDEN)))
             result |= NetWmStateHidden;
     } else {
         qCDebug(lcQpaXcb, "getting net wm state (%x), empty\n", m_window);
@@ -961,13 +961,13 @@ void QXcbWindow::setMotifWmHints(Qt::WindowFlags flags)
         xcb_change_property(xcb_connection(),
                             XCB_PROP_MODE_REPLACE,
                             m_window,
-                            atom(QXcbAtom::_MOTIF_WM_HINTS),
-                            atom(QXcbAtom::_MOTIF_WM_HINTS),
+                            atom(QXcbAtom::Atom_MOTIF_WM_HINTS),
+                            atom(QXcbAtom::Atom_MOTIF_WM_HINTS),
                             32,
                             5,
                             &mwmhints);
     } else {
-        xcb_delete_property(xcb_connection(), m_window, atom(QXcbAtom::_MOTIF_WM_HINTS));
+        xcb_delete_property(xcb_connection(), m_window, atom(QXcbAtom::Atom_MOTIF_WM_HINTS));
     }
 }
 
@@ -979,7 +979,7 @@ void QXcbWindow::setNetWmState(bool set, xcb_atom_t one, xcb_atom_t two)
     event.format = 32;
     event.sequence = 0;
     event.window = m_window;
-    event.type = atom(QXcbAtom::_NET_WM_STATE);
+    event.type = atom(QXcbAtom::Atom_NET_WM_STATE);
     event.data.data32[0] = set ? 1 : 0;
     event.data.data32[1] = one;
     event.data.data32[2] = two;
@@ -995,20 +995,20 @@ void QXcbWindow::setNetWmState(Qt::WindowStates state)
 {
     if ((m_windowState ^ state) & Qt::WindowMaximized) {
         setNetWmState(state & Qt::WindowMaximized,
-                      atom(QXcbAtom::_NET_WM_STATE_MAXIMIZED_HORZ),
-                      atom(QXcbAtom::_NET_WM_STATE_MAXIMIZED_VERT));
+                      atom(QXcbAtom::Atom_NET_WM_STATE_MAXIMIZED_HORZ),
+                      atom(QXcbAtom::Atom_NET_WM_STATE_MAXIMIZED_VERT));
     }
 
     if ((m_windowState ^ state) & Qt::WindowFullScreen)
-        setNetWmState(state & Qt::WindowFullScreen, atom(QXcbAtom::_NET_WM_STATE_FULLSCREEN));
+        setNetWmState(state & Qt::WindowFullScreen, atom(QXcbAtom::Atom_NET_WM_STATE_FULLSCREEN));
 }
 
 void QXcbWindow::setNetWmState(Qt::WindowFlags flags)
 {
     setNetWmState(flags & Qt::WindowStaysOnTopHint,
-                  atom(QXcbAtom::_NET_WM_STATE_ABOVE),
-                  atom(QXcbAtom::_NET_WM_STATE_STAYS_ON_TOP));
-    setNetWmState(flags & Qt::WindowStaysOnBottomHint, atom(QXcbAtom::_NET_WM_STATE_BELOW));
+                  atom(QXcbAtom::Atom_NET_WM_STATE_ABOVE),
+                  atom(QXcbAtom::Atom_NET_WM_STATE_STAYS_ON_TOP));
+    setNetWmState(flags & Qt::WindowStaysOnBottomHint, atom(QXcbAtom::Atom_NET_WM_STATE_BELOW));
 }
 
 void QXcbWindow::setNetWmStateOnUnmappedWindow()
@@ -1049,7 +1049,7 @@ void QXcbWindow::setNetWmStateOnUnmappedWindow()
 
     QList<xcb_atom_t> atoms;
     auto reply = Q_XCB_REPLY_UNCHECKED(xcb_get_property, xcb_connection(),
-                                       0, m_window, atom(QXcbAtom::_NET_WM_STATE),
+                                       0, m_window, atom(QXcbAtom::Atom_NET_WM_STATE),
                                        XCB_ATOM_ATOM, 0, 1024);
     if (reply && reply->format == 32 && reply->type == XCB_ATOM_ATOM && reply->value_len > 0) {
         const xcb_atom_t *data = static_cast<const xcb_atom_t *>(xcb_get_property_value(reply.get()));
@@ -1057,30 +1057,30 @@ void QXcbWindow::setNetWmStateOnUnmappedWindow()
         memcpy((void *)&atoms.first(), (void *)data, reply->value_len * sizeof(xcb_atom_t));
     }
 
-    if (states & NetWmStateAbove && !atoms.contains(atom(QXcbAtom::_NET_WM_STATE_ABOVE)))
-        atoms.push_back(atom(QXcbAtom::_NET_WM_STATE_ABOVE));
-    if (states & NetWmStateBelow && !atoms.contains(atom(QXcbAtom::_NET_WM_STATE_BELOW)))
-        atoms.push_back(atom(QXcbAtom::_NET_WM_STATE_BELOW));
-    if (states & NetWmStateHidden && !atoms.contains(atom(QXcbAtom::_NET_WM_STATE_HIDDEN)))
-        atoms.push_back(atom(QXcbAtom::_NET_WM_STATE_HIDDEN));
-    if (states & NetWmStateFullScreen && !atoms.contains(atom(QXcbAtom::_NET_WM_STATE_FULLSCREEN)))
-        atoms.push_back(atom(QXcbAtom::_NET_WM_STATE_FULLSCREEN));
-    if (states & NetWmStateMaximizedHorz && !atoms.contains(atom(QXcbAtom::_NET_WM_STATE_MAXIMIZED_HORZ)))
-        atoms.push_back(atom(QXcbAtom::_NET_WM_STATE_MAXIMIZED_HORZ));
-    if (states & NetWmStateMaximizedVert && !atoms.contains(atom(QXcbAtom::_NET_WM_STATE_MAXIMIZED_VERT)))
-        atoms.push_back(atom(QXcbAtom::_NET_WM_STATE_MAXIMIZED_VERT));
-    if (states & NetWmStateModal && !atoms.contains(atom(QXcbAtom::_NET_WM_STATE_MODAL)))
-        atoms.push_back(atom(QXcbAtom::_NET_WM_STATE_MODAL));
-    if (states & NetWmStateStaysOnTop && !atoms.contains(atom(QXcbAtom::_NET_WM_STATE_STAYS_ON_TOP)))
-        atoms.push_back(atom(QXcbAtom::_NET_WM_STATE_STAYS_ON_TOP));
-    if (states & NetWmStateDemandsAttention && !atoms.contains(atom(QXcbAtom::_NET_WM_STATE_DEMANDS_ATTENTION)))
-        atoms.push_back(atom(QXcbAtom::_NET_WM_STATE_DEMANDS_ATTENTION));
+    if (states & NetWmStateAbove && !atoms.contains(atom(QXcbAtom::Atom_NET_WM_STATE_ABOVE)))
+        atoms.push_back(atom(QXcbAtom::Atom_NET_WM_STATE_ABOVE));
+    if (states & NetWmStateBelow && !atoms.contains(atom(QXcbAtom::Atom_NET_WM_STATE_BELOW)))
+        atoms.push_back(atom(QXcbAtom::Atom_NET_WM_STATE_BELOW));
+    if (states & NetWmStateHidden && !atoms.contains(atom(QXcbAtom::Atom_NET_WM_STATE_HIDDEN)))
+        atoms.push_back(atom(QXcbAtom::Atom_NET_WM_STATE_HIDDEN));
+    if (states & NetWmStateFullScreen && !atoms.contains(atom(QXcbAtom::Atom_NET_WM_STATE_FULLSCREEN)))
+        atoms.push_back(atom(QXcbAtom::Atom_NET_WM_STATE_FULLSCREEN));
+    if (states & NetWmStateMaximizedHorz && !atoms.contains(atom(QXcbAtom::Atom_NET_WM_STATE_MAXIMIZED_HORZ)))
+        atoms.push_back(atom(QXcbAtom::Atom_NET_WM_STATE_MAXIMIZED_HORZ));
+    if (states & NetWmStateMaximizedVert && !atoms.contains(atom(QXcbAtom::Atom_NET_WM_STATE_MAXIMIZED_VERT)))
+        atoms.push_back(atom(QXcbAtom::Atom_NET_WM_STATE_MAXIMIZED_VERT));
+    if (states & NetWmStateModal && !atoms.contains(atom(QXcbAtom::Atom_NET_WM_STATE_MODAL)))
+        atoms.push_back(atom(QXcbAtom::Atom_NET_WM_STATE_MODAL));
+    if (states & NetWmStateStaysOnTop && !atoms.contains(atom(QXcbAtom::Atom_NET_WM_STATE_STAYS_ON_TOP)))
+        atoms.push_back(atom(QXcbAtom::Atom_NET_WM_STATE_STAYS_ON_TOP));
+    if (states & NetWmStateDemandsAttention && !atoms.contains(atom(QXcbAtom::Atom_NET_WM_STATE_DEMANDS_ATTENTION)))
+        atoms.push_back(atom(QXcbAtom::Atom_NET_WM_STATE_DEMANDS_ATTENTION));
 
     if (atoms.isEmpty()) {
-        xcb_delete_property(xcb_connection(), m_window, atom(QXcbAtom::_NET_WM_STATE));
+        xcb_delete_property(xcb_connection(), m_window, atom(QXcbAtom::Atom_NET_WM_STATE));
     } else {
         xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, m_window,
-                            atom(QXcbAtom::_NET_WM_STATE), XCB_ATOM_ATOM, 32,
+                            atom(QXcbAtom::Atom_NET_WM_STATE), XCB_ATOM_ATOM, 32,
                             atoms.size(), atoms.constData());
     }
     xcb_flush(xcb_connection());
@@ -1096,10 +1096,10 @@ void QXcbWindow::setWindowState(Qt::WindowStates state)
         xcb_map_window(xcb_connection(), m_window);
     if (m_windowState & Qt::WindowMaximized)
         setNetWmState(false,
-                      atom(QXcbAtom::_NET_WM_STATE_MAXIMIZED_HORZ),
-                      atom(QXcbAtom::_NET_WM_STATE_MAXIMIZED_VERT));
+                      atom(QXcbAtom::Atom_NET_WM_STATE_MAXIMIZED_HORZ),
+                      atom(QXcbAtom::Atom_NET_WM_STATE_MAXIMIZED_VERT));
     if (m_windowState & Qt::WindowFullScreen)
-        setNetWmState(false, atom(QXcbAtom::_NET_WM_STATE_FULLSCREEN));
+        setNetWmState(false, atom(QXcbAtom::Atom_NET_WM_STATE_FULLSCREEN));
 
     // set new state
     if (state & Qt::WindowMinimized) {
@@ -1110,7 +1110,7 @@ void QXcbWindow::setWindowState(Qt::WindowStates state)
             event.format = 32;
             event.sequence = 0;
             event.window = m_window;
-            event.type = atom(QXcbAtom::WM_CHANGE_STATE);
+            event.type = atom(QXcbAtom::AtomWM_CHANGE_STATE);
             event.data.data32[0] = XCB_ICCCM_WM_STATE_ICONIC;
             event.data.data32[1] = 0;
             event.data.data32[2] = 0;
@@ -1125,10 +1125,10 @@ void QXcbWindow::setWindowState(Qt::WindowStates state)
     }
     if (state & Qt::WindowMaximized)
         setNetWmState(true,
-                      atom(QXcbAtom::_NET_WM_STATE_MAXIMIZED_HORZ),
-                      atom(QXcbAtom::_NET_WM_STATE_MAXIMIZED_VERT));
+                      atom(QXcbAtom::Atom_NET_WM_STATE_MAXIMIZED_HORZ),
+                      atom(QXcbAtom::Atom_NET_WM_STATE_MAXIMIZED_VERT));
     if (state & Qt::WindowFullScreen)
-        setNetWmState(true, atom(QXcbAtom::_NET_WM_STATE_FULLSCREEN));
+        setNetWmState(true, atom(QXcbAtom::Atom_NET_WM_STATE_FULLSCREEN));
 
     setNetWmState(state);
 
@@ -1155,7 +1155,7 @@ void QXcbWindow::updateNetWmUserTime(xcb_timestamp_t timestamp)
     if (timestamp != 0)
         connection()->setNetWmUserTime(timestamp);
 
-    const bool isSupportedByWM = connection()->wmSupport()->isSupportedByWM(atom(QXcbAtom::_NET_WM_USER_TIME_WINDOW));
+    const bool isSupportedByWM = connection()->wmSupport()->isSupportedByWM(atom(QXcbAtom::Atom_NET_WM_USER_TIME_WINDOW));
     if (m_netWmUserTimeWindow || isSupportedByWM) {
         if (!m_netWmUserTimeWindow) {
             m_netWmUserTimeWindow = xcb_generate_id(xcb_connection());
@@ -1170,9 +1170,9 @@ void QXcbWindow::updateNetWmUserTime(xcb_timestamp_t timestamp)
                               0,                               // value mask
                               nullptr);                        // value list
             wid = m_netWmUserTimeWindow;
-            xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, m_window, atom(QXcbAtom::_NET_WM_USER_TIME_WINDOW),
+            xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, m_window, atom(QXcbAtom::Atom_NET_WM_USER_TIME_WINDOW),
                                 XCB_ATOM_WINDOW, 32, 1, &m_netWmUserTimeWindow);
-            xcb_delete_property(xcb_connection(), m_window, atom(QXcbAtom::_NET_WM_USER_TIME));
+            xcb_delete_property(xcb_connection(), m_window, atom(QXcbAtom::Atom_NET_WM_USER_TIME));
 
             QXcbWindow::setWindowTitle(connection(), m_netWmUserTimeWindow,
                                        QStringLiteral("Qt NET_WM User Time Window"));
@@ -1180,14 +1180,14 @@ void QXcbWindow::updateNetWmUserTime(xcb_timestamp_t timestamp)
         } else if (!isSupportedByWM) {
             // WM no longer supports it, then we should remove the
             // _NET_WM_USER_TIME_WINDOW atom.
-            xcb_delete_property(xcb_connection(), m_window, atom(QXcbAtom::_NET_WM_USER_TIME_WINDOW));
+            xcb_delete_property(xcb_connection(), m_window, atom(QXcbAtom::Atom_NET_WM_USER_TIME_WINDOW));
             xcb_destroy_window(xcb_connection(), m_netWmUserTimeWindow);
             m_netWmUserTimeWindow = XCB_NONE;
         } else {
             wid = m_netWmUserTimeWindow;
         }
     }
-    xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, wid, atom(QXcbAtom::_NET_WM_USER_TIME),
+    xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, wid, atom(QXcbAtom::Atom_NET_WM_USER_TIME),
                         XCB_ATOM_CARDINAL, 32, 1, &timestamp);
 }
 
@@ -1262,8 +1262,8 @@ void QXcbWindow::setWindowIconText(const QString &title)
     xcb_change_property(xcb_connection(),
                         XCB_PROP_MODE_REPLACE,
                         m_window,
-                        atom(QXcbAtom::_NET_WM_ICON_NAME),
-                        atom(QXcbAtom::UTF8_STRING),
+                        atom(QXcbAtom::Atom_NET_WM_ICON_NAME),
+                        atom(QXcbAtom::AtomUTF8_STRING),
                         8,
                         ba.size(),
                         ba.constData());
@@ -1306,15 +1306,15 @@ void QXcbWindow::setWindowIcon(const QIcon &icon)
         xcb_change_property(xcb_connection(),
                             XCB_PROP_MODE_REPLACE,
                             m_window,
-                            atom(QXcbAtom::_NET_WM_ICON),
-                            atom(QXcbAtom::CARDINAL),
+                            atom(QXcbAtom::Atom_NET_WM_ICON),
+                            atom(QXcbAtom::AtomCARDINAL),
                             32,
                             icon_data.size(),
                             (unsigned char *) icon_data.data());
     } else {
         xcb_delete_property(xcb_connection(),
                             m_window,
-                            atom(QXcbAtom::_NET_WM_ICON));
+                            atom(QXcbAtom::Atom_NET_WM_ICON));
     }
 }
 
@@ -1401,14 +1401,14 @@ void QXcbWindow::requestActivateWindow()
     if (window()->isTopLevel()
         && !(window()->flags() & Qt::X11BypassWindowManagerHint)
         && (!focusWindow || !window()->isAncestorOf(focusWindow))
-        && connection()->wmSupport()->isSupportedByWM(atom(QXcbAtom::_NET_ACTIVE_WINDOW))) {
+        && connection()->wmSupport()->isSupportedByWM(atom(QXcbAtom::Atom_NET_ACTIVE_WINDOW))) {
         xcb_client_message_event_t event;
 
         event.response_type = XCB_CLIENT_MESSAGE;
         event.format = 32;
         event.sequence = 0;
         event.window = m_window;
-        event.type = atom(QXcbAtom::_NET_ACTIVE_WINDOW);
+        event.type = atom(QXcbAtom::Atom_NET_ACTIVE_WINDOW);
         event.data.data32[0] = 1;
         event.data.data32[1] = connection()->time();
         event.data.data32[2] = focusWindow ? focusWindow->winId() : XCB_NONE;
@@ -1435,7 +1435,7 @@ QXcbWindow::WindowTypes QXcbWindow::wmWindowTypes() const
     WindowTypes result;
 
     auto reply = Q_XCB_REPLY_UNCHECKED(xcb_get_property, xcb_connection(),
-                                       0, m_window, atom(QXcbAtom::_NET_WM_WINDOW_TYPE),
+                                       0, m_window, atom(QXcbAtom::Atom_NET_WM_WINDOW_TYPE),
                                        XCB_ATOM_ATOM, 0, 1024);
     if (reply && reply->format == 32 && reply->type == XCB_ATOM_ATOM) {
         const xcb_atom_t *types = static_cast<const xcb_atom_t *>(xcb_get_property_value(reply.get()));
@@ -1443,49 +1443,49 @@ QXcbWindow::WindowTypes QXcbWindow::wmWindowTypes() const
         for (; types != types_end; types++) {
             QXcbAtom::Atom type = connection()->qatom(*types);
             switch (type) {
-            case QXcbAtom::_NET_WM_WINDOW_TYPE_NORMAL:
+            case QXcbAtom::Atom_NET_WM_WINDOW_TYPE_NORMAL:
                 result |= WindowType::Normal;
                 break;
-            case QXcbAtom::_NET_WM_WINDOW_TYPE_DESKTOP:
+            case QXcbAtom::Atom_NET_WM_WINDOW_TYPE_DESKTOP:
                 result |= WindowType::Desktop;
                 break;
-            case QXcbAtom::_NET_WM_WINDOW_TYPE_DOCK:
+            case QXcbAtom::Atom_NET_WM_WINDOW_TYPE_DOCK:
                 result |= WindowType::Dock;
                 break;
-            case QXcbAtom::_NET_WM_WINDOW_TYPE_TOOLBAR:
+            case QXcbAtom::Atom_NET_WM_WINDOW_TYPE_TOOLBAR:
                 result |= WindowType::Toolbar;
                 break;
-            case QXcbAtom::_NET_WM_WINDOW_TYPE_MENU:
+            case QXcbAtom::Atom_NET_WM_WINDOW_TYPE_MENU:
                 result |= WindowType::Menu;
                 break;
-            case QXcbAtom::_NET_WM_WINDOW_TYPE_UTILITY:
+            case QXcbAtom::Atom_NET_WM_WINDOW_TYPE_UTILITY:
                 result |= WindowType::Utility;
                 break;
-            case QXcbAtom::_NET_WM_WINDOW_TYPE_SPLASH:
+            case QXcbAtom::Atom_NET_WM_WINDOW_TYPE_SPLASH:
                 result |= WindowType::Splash;
                 break;
-            case QXcbAtom::_NET_WM_WINDOW_TYPE_DIALOG:
+            case QXcbAtom::Atom_NET_WM_WINDOW_TYPE_DIALOG:
                 result |= WindowType::Dialog;
                 break;
-            case QXcbAtom::_NET_WM_WINDOW_TYPE_DROPDOWN_MENU:
+            case QXcbAtom::Atom_NET_WM_WINDOW_TYPE_DROPDOWN_MENU:
                 result |= WindowType::DropDownMenu;
                 break;
-            case QXcbAtom::_NET_WM_WINDOW_TYPE_POPUP_MENU:
+            case QXcbAtom::Atom_NET_WM_WINDOW_TYPE_POPUP_MENU:
                 result |= WindowType::PopupMenu;
                 break;
-            case QXcbAtom::_NET_WM_WINDOW_TYPE_TOOLTIP:
+            case QXcbAtom::Atom_NET_WM_WINDOW_TYPE_TOOLTIP:
                 result |= WindowType::Tooltip;
                 break;
-            case QXcbAtom::_NET_WM_WINDOW_TYPE_NOTIFICATION:
+            case QXcbAtom::Atom_NET_WM_WINDOW_TYPE_NOTIFICATION:
                 result |= WindowType::Notification;
                 break;
-            case QXcbAtom::_NET_WM_WINDOW_TYPE_COMBO:
+            case QXcbAtom::Atom_NET_WM_WINDOW_TYPE_COMBO:
                 result |= WindowType::Combo;
                 break;
-            case QXcbAtom::_NET_WM_WINDOW_TYPE_DND:
+            case QXcbAtom::Atom_NET_WM_WINDOW_TYPE_DND:
                 result |= WindowType::Dnd;
                 break;
-            case QXcbAtom::_KDE_NET_WM_WINDOW_TYPE_OVERRIDE:
+            case QXcbAtom::Atom_KDE_NET_WM_WINDOW_TYPE_OVERRIDE:
                 result |= WindowType::KdeOverride;
                 break;
             default:
@@ -1502,41 +1502,41 @@ void QXcbWindow::setWmWindowType(WindowTypes types, Qt::WindowFlags flags)
 
     // manual selection 1 (these are never set by Qt and take precedence)
     if (types & WindowType::Normal)
-        atoms.append(atom(QXcbAtom::_NET_WM_WINDOW_TYPE_NORMAL));
+        atoms.append(atom(QXcbAtom::Atom_NET_WM_WINDOW_TYPE_NORMAL));
     if (types & WindowType::Desktop)
-        atoms.append(atom(QXcbAtom::_NET_WM_WINDOW_TYPE_DESKTOP));
+        atoms.append(atom(QXcbAtom::Atom_NET_WM_WINDOW_TYPE_DESKTOP));
     if (types & WindowType::Dock)
-        atoms.append(atom(QXcbAtom::_NET_WM_WINDOW_TYPE_DOCK));
+        atoms.append(atom(QXcbAtom::Atom_NET_WM_WINDOW_TYPE_DOCK));
     if (types & WindowType::Notification)
-        atoms.append(atom(QXcbAtom::_NET_WM_WINDOW_TYPE_NOTIFICATION));
+        atoms.append(atom(QXcbAtom::Atom_NET_WM_WINDOW_TYPE_NOTIFICATION));
 
     // manual selection 2 (Qt uses these during auto selection);
     if (types & WindowType::Utility)
-        atoms.append(atom(QXcbAtom::_NET_WM_WINDOW_TYPE_UTILITY));
+        atoms.append(atom(QXcbAtom::Atom_NET_WM_WINDOW_TYPE_UTILITY));
     if (types & WindowType::Splash)
-        atoms.append(atom(QXcbAtom::_NET_WM_WINDOW_TYPE_SPLASH));
+        atoms.append(atom(QXcbAtom::Atom_NET_WM_WINDOW_TYPE_SPLASH));
     if (types & WindowType::Dialog)
-        atoms.append(atom(QXcbAtom::_NET_WM_WINDOW_TYPE_DIALOG));
+        atoms.append(atom(QXcbAtom::Atom_NET_WM_WINDOW_TYPE_DIALOG));
     if (types & WindowType::Tooltip)
-        atoms.append(atom(QXcbAtom::_NET_WM_WINDOW_TYPE_TOOLTIP));
+        atoms.append(atom(QXcbAtom::Atom_NET_WM_WINDOW_TYPE_TOOLTIP));
     if (types & WindowType::KdeOverride)
-        atoms.append(atom(QXcbAtom::_KDE_NET_WM_WINDOW_TYPE_OVERRIDE));
+        atoms.append(atom(QXcbAtom::Atom_KDE_NET_WM_WINDOW_TYPE_OVERRIDE));
 
     // manual selection 3 (these can be set by Qt, but don't have a
     // corresponding Qt::WindowType). note that order of the *MENU
     // atoms is important
     if (types & WindowType::Menu)
-        atoms.append(atom(QXcbAtom::_NET_WM_WINDOW_TYPE_MENU));
+        atoms.append(atom(QXcbAtom::Atom_NET_WM_WINDOW_TYPE_MENU));
     if (types & WindowType::DropDownMenu)
-        atoms.append(atom(QXcbAtom::_NET_WM_WINDOW_TYPE_DROPDOWN_MENU));
+        atoms.append(atom(QXcbAtom::Atom_NET_WM_WINDOW_TYPE_DROPDOWN_MENU));
     if (types & WindowType::PopupMenu)
-        atoms.append(atom(QXcbAtom::_NET_WM_WINDOW_TYPE_POPUP_MENU));
+        atoms.append(atom(QXcbAtom::Atom_NET_WM_WINDOW_TYPE_POPUP_MENU));
     if (types & WindowType::Toolbar)
-        atoms.append(atom(QXcbAtom::_NET_WM_WINDOW_TYPE_TOOLBAR));
+        atoms.append(atom(QXcbAtom::Atom_NET_WM_WINDOW_TYPE_TOOLBAR));
     if (types & WindowType::Combo)
-        atoms.append(atom(QXcbAtom::_NET_WM_WINDOW_TYPE_COMBO));
+        atoms.append(atom(QXcbAtom::Atom_NET_WM_WINDOW_TYPE_COMBO));
     if (types & WindowType::Dnd)
-        atoms.append(atom(QXcbAtom::_NET_WM_WINDOW_TYPE_DND));
+        atoms.append(atom(QXcbAtom::Atom_NET_WM_WINDOW_TYPE_DND));
 
     // automatic selection
     Qt::WindowType type = static_cast<Qt::WindowType>(int(flags & Qt::WindowType_Mask));
@@ -1544,20 +1544,20 @@ void QXcbWindow::setWmWindowType(WindowTypes types, Qt::WindowFlags flags)
     case Qt::Dialog:
     case Qt::Sheet:
         if (!(types & WindowType::Dialog))
-            atoms.append(atom(QXcbAtom::_NET_WM_WINDOW_TYPE_DIALOG));
+            atoms.append(atom(QXcbAtom::Atom_NET_WM_WINDOW_TYPE_DIALOG));
         break;
     case Qt::Tool:
     case Qt::Drawer:
         if (!(types & WindowType::Utility))
-            atoms.append(atom(QXcbAtom::_NET_WM_WINDOW_TYPE_UTILITY));
+            atoms.append(atom(QXcbAtom::Atom_NET_WM_WINDOW_TYPE_UTILITY));
         break;
     case Qt::ToolTip:
         if (!(types & WindowType::Tooltip))
-            atoms.append(atom(QXcbAtom::_NET_WM_WINDOW_TYPE_TOOLTIP));
+            atoms.append(atom(QXcbAtom::Atom_NET_WM_WINDOW_TYPE_TOOLTIP));
         break;
     case Qt::SplashScreen:
         if (!(types & WindowType::Splash))
-            atoms.append(atom(QXcbAtom::_NET_WM_WINDOW_TYPE_SPLASH));
+            atoms.append(atom(QXcbAtom::Atom_NET_WM_WINDOW_TYPE_SPLASH));
         break;
     default:
         break;
@@ -1565,19 +1565,19 @@ void QXcbWindow::setWmWindowType(WindowTypes types, Qt::WindowFlags flags)
 
     if ((flags & Qt::FramelessWindowHint) && !(types & WindowType::KdeOverride)) {
         // override netwm type - quick and easy for KDE noborder
-        atoms.append(atom(QXcbAtom::_KDE_NET_WM_WINDOW_TYPE_OVERRIDE));
+        atoms.append(atom(QXcbAtom::Atom_KDE_NET_WM_WINDOW_TYPE_OVERRIDE));
     }
 
-    if (atoms.size() == 1 && atoms.first() == atom(QXcbAtom::_NET_WM_WINDOW_TYPE_NORMAL))
+    if (atoms.size() == 1 && atoms.first() == atom(QXcbAtom::Atom_NET_WM_WINDOW_TYPE_NORMAL))
         atoms.clear();
     else
-        atoms.append(atom(QXcbAtom::_NET_WM_WINDOW_TYPE_NORMAL));
+        atoms.append(atom(QXcbAtom::Atom_NET_WM_WINDOW_TYPE_NORMAL));
 
     if (atoms.isEmpty()) {
-        xcb_delete_property(xcb_connection(), m_window, atom(QXcbAtom::_NET_WM_WINDOW_TYPE));
+        xcb_delete_property(xcb_connection(), m_window, atom(QXcbAtom::Atom_NET_WM_WINDOW_TYPE));
     } else {
         xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, m_window,
-                            atom(QXcbAtom::_NET_WM_WINDOW_TYPE), XCB_ATOM_ATOM, 32,
+                            atom(QXcbAtom::Atom_NET_WM_WINDOW_TYPE), XCB_ATOM_ATOM, 32,
                             atoms.size(), atoms.constData());
     }
     xcb_flush(xcb_connection());
@@ -1587,7 +1587,7 @@ void QXcbWindow::setWindowRole(const QString &role)
 {
     QByteArray roleData = role.toLatin1();
     xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, m_window,
-                        atom(QXcbAtom::WM_WINDOW_ROLE), XCB_ATOM_STRING, 8,
+                        atom(QXcbAtom::AtomWM_WINDOW_ROLE), XCB_ATOM_STRING, 8,
                         roleData.size(), roleData.constData());
 }
 
@@ -1646,15 +1646,15 @@ void QXcbWindow::handleClientMessageEvent(const xcb_client_message_event_t *even
     if (event->format != 32)
         return;
 
-    if (event->type == atom(QXcbAtom::WM_PROTOCOLS)) {
+    if (event->type == atom(QXcbAtom::AtomWM_PROTOCOLS)) {
         xcb_atom_t protocolAtom = event->data.data32[0];
-        if (protocolAtom == atom(QXcbAtom::WM_DELETE_WINDOW)) {
+        if (protocolAtom == atom(QXcbAtom::AtomWM_DELETE_WINDOW)) {
             QWindowSystemInterface::handleCloseEvent(window());
-        } else if (protocolAtom == atom(QXcbAtom::WM_TAKE_FOCUS)) {
+        } else if (protocolAtom == atom(QXcbAtom::AtomWM_TAKE_FOCUS)) {
             connection()->setTime(event->data.data32[1]);
             relayFocusToModalWindow();
             return;
-        } else if (protocolAtom == atom(QXcbAtom::_NET_WM_PING)) {
+        } else if (protocolAtom == atom(QXcbAtom::Atom_NET_WM_PING)) {
             if (event->window == xcbScreen()->root())
                 return;
 
@@ -1667,14 +1667,14 @@ void QXcbWindow::handleClientMessageEvent(const xcb_client_message_event_t *even
                            XCB_EVENT_MASK_STRUCTURE_NOTIFY | XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT,
                            (const char *)&reply);
             xcb_flush(xcb_connection());
-        } else if (protocolAtom == atom(QXcbAtom::_NET_WM_SYNC_REQUEST)) {
+        } else if (protocolAtom == atom(QXcbAtom::Atom_NET_WM_SYNC_REQUEST)) {
             connection()->setTime(event->data.data32[1]);
             m_syncValue.lo = event->data.data32[2];
             m_syncValue.hi = event->data.data32[3];
             if (connection()->hasXSync())
                 m_syncState = SyncReceived;
 #ifndef QT_NO_WHATSTHIS
-        } else if (protocolAtom == atom(QXcbAtom::_NET_WM_CONTEXT_HELP)) {
+        } else if (protocolAtom == atom(QXcbAtom::Atom_NET_WM_CONTEXT_HELP)) {
             QWindowSystemInterface::handleEnterWhatsThisEvent();
 #endif
         } else {
@@ -1682,29 +1682,29 @@ void QXcbWindow::handleClientMessageEvent(const xcb_client_message_event_t *even
                       connection()->atomName(protocolAtom).constData());
         }
 #if QT_CONFIG(draganddrop)
-    } else if (event->type == atom(QXcbAtom::XdndEnter)) {
+    } else if (event->type == atom(QXcbAtom::AtomXdndEnter)) {
         connection()->drag()->handleEnter(this, event);
-    } else if (event->type == atom(QXcbAtom::XdndPosition)) {
+    } else if (event->type == atom(QXcbAtom::AtomXdndPosition)) {
         connection()->drag()->handlePosition(this, event);
-    } else if (event->type == atom(QXcbAtom::XdndLeave)) {
+    } else if (event->type == atom(QXcbAtom::AtomXdndLeave)) {
         connection()->drag()->handleLeave(this, event);
-    } else if (event->type == atom(QXcbAtom::XdndDrop)) {
+    } else if (event->type == atom(QXcbAtom::AtomXdndDrop)) {
         connection()->drag()->handleDrop(this, event);
 #endif
-    } else if (event->type == atom(QXcbAtom::_XEMBED)) {
+    } else if (event->type == atom(QXcbAtom::Atom_XEMBED)) {
         handleXEmbedMessage(event);
-    } else if (event->type == atom(QXcbAtom::_NET_ACTIVE_WINDOW)) {
+    } else if (event->type == atom(QXcbAtom::Atom_NET_ACTIVE_WINDOW)) {
         doFocusIn();
-    } else if (event->type == atom(QXcbAtom::MANAGER)
-               || event->type == atom(QXcbAtom::_NET_WM_STATE)
-               || event->type == atom(QXcbAtom::WM_CHANGE_STATE)) {
+    } else if (event->type == atom(QXcbAtom::AtomMANAGER)
+               || event->type == atom(QXcbAtom::Atom_NET_WM_STATE)
+               || event->type == atom(QXcbAtom::AtomWM_CHANGE_STATE)) {
         // Ignore _NET_WM_STATE, MANAGER which are relate to tray icons
         // and other messages.
-    } else if (event->type == atom(QXcbAtom::_COMPIZ_DECOR_PENDING)
-            || event->type == atom(QXcbAtom::_COMPIZ_DECOR_REQUEST)
-            || event->type == atom(QXcbAtom::_COMPIZ_DECOR_DELETE_PIXMAP)
-            || event->type == atom(QXcbAtom::_COMPIZ_TOOLKIT_ACTION)
-            || event->type == atom(QXcbAtom::_GTK_LOAD_ICONTHEMES)) {
+    } else if (event->type == atom(QXcbAtom::Atom_COMPIZ_DECOR_PENDING)
+            || event->type == atom(QXcbAtom::Atom_COMPIZ_DECOR_REQUEST)
+            || event->type == atom(QXcbAtom::Atom_COMPIZ_DECOR_DELETE_PIXMAP)
+            || event->type == atom(QXcbAtom::Atom_COMPIZ_TOOLKIT_ACTION)
+            || event->type == atom(QXcbAtom::Atom_GTK_LOAD_ICONTHEMES)) {
         //silence the _COMPIZ and _GTK messages for now
     } else {
         qCWarning(lcQpaXcb) << "Unhandled client message: " << connection()->atomName(event->type);
@@ -2136,17 +2136,17 @@ void QXcbWindow::handlePropertyNotifyEvent(const xcb_property_notify_event_t *ev
 
     const bool propertyDeleted = event->state == XCB_PROPERTY_DELETE;
 
-    if (event->atom == atom(QXcbAtom::_NET_WM_STATE) || event->atom == atom(QXcbAtom::WM_STATE)) {
+    if (event->atom == atom(QXcbAtom::Atom_NET_WM_STATE) || event->atom == atom(QXcbAtom::AtomWM_STATE)) {
         if (propertyDeleted)
             return;
 
         Qt::WindowStates newState = Qt::WindowNoState;
 
-        if (event->atom == atom(QXcbAtom::WM_STATE)) { // WM_STATE: Quick check for 'Minimize'.
+        if (event->atom == atom(QXcbAtom::AtomWM_STATE)) { // WM_STATE: Quick check for 'Minimize'.
             auto reply = Q_XCB_REPLY(xcb_get_property, xcb_connection(),
-                                     0, m_window, atom(QXcbAtom::WM_STATE),
+                                     0, m_window, atom(QXcbAtom::AtomWM_STATE),
                                      XCB_ATOM_ANY, 0, 1024);
-            if (reply && reply->format == 32 && reply->type == atom(QXcbAtom::WM_STATE)) {
+            if (reply && reply->format == 32 && reply->type == atom(QXcbAtom::AtomWM_STATE)) {
                 const quint32 *data = (const quint32 *)xcb_get_property_value(reply.get());
                 if (reply->length != 0)
                     m_minimized = (data[0] == XCB_ICCCM_WM_STATE_ICONIC
@@ -2176,7 +2176,7 @@ void QXcbWindow::handlePropertyNotifyEvent(const xcb_property_notify_event_t *ev
                 connection()->setMouseGrabber(nullptr);
         }
         return;
-    } else if (event->atom == atom(QXcbAtom::_NET_FRAME_EXTENTS)) {
+    } else if (event->atom == atom(QXcbAtom::Atom_NET_FRAME_EXTENTS)) {
         m_dirtyFrameMargins = true;
     }
 }
@@ -2315,7 +2315,7 @@ bool QXcbWindow::startSystemMove()
 
 bool QXcbWindow::startSystemMoveResize(const QPoint &pos, int edges)
 {
-    const xcb_atom_t moveResize = connection()->atom(QXcbAtom::_NET_WM_MOVERESIZE);
+    const xcb_atom_t moveResize = connection()->atom(QXcbAtom::Atom_NET_WM_MOVERESIZE);
     if (!connection()->wmSupport()->isSupportedByWM(moveResize))
         return false;
 
@@ -2363,7 +2363,7 @@ static uint qtEdgesToXcbMoveResizeDirection(Qt::Edges edges)
 void QXcbWindow::doStartSystemMoveResize(const QPoint &globalPos, int edges)
 {
     qCDebug(lcQpaXInputDevices) << "triggered system move or resize via sending _NET_WM_MOVERESIZE client message";
-    const xcb_atom_t moveResize = connection()->atom(QXcbAtom::_NET_WM_MOVERESIZE);
+    const xcb_atom_t moveResize = connection()->atom(QXcbAtom::Atom_NET_WM_MOVERESIZE);
     xcb_client_message_event_t xev;
     xev.response_type = XCB_CLIENT_MESSAGE;
     xev.type = moveResize;
@@ -2396,7 +2396,7 @@ void QXcbWindow::sendXEmbedMessage(xcb_window_t window, quint32 message,
     event.format = 32;
     event.sequence = 0;
     event.window = window;
-    event.type = atom(QXcbAtom::_XEMBED);
+    event.type = atom(QXcbAtom::Atom_XEMBED);
     event.data.data32[0] = connection()->time();
     event.data.data32[1] = message;
     event.data.data32[2] = detail;
@@ -2475,7 +2475,7 @@ void QXcbWindow::setOpacity(qreal level)
     xcb_change_property(xcb_connection(),
                         XCB_PROP_MODE_REPLACE,
                         m_window,
-                        atom(QXcbAtom::_NET_WM_WINDOW_OPACITY),
+                        atom(QXcbAtom::Atom_NET_WM_WINDOW_OPACITY),
                         XCB_ATOM_CARDINAL,
                         32,
                         1,
@@ -2513,7 +2513,7 @@ void QXcbWindow::setAlertState(bool enabled)
 
     m_alertState = enabled;
 
-    setNetWmState(enabled, atom(QXcbAtom::_NET_WM_STATE_DEMANDS_ATTENTION));
+    setNetWmState(enabled, atom(QXcbAtom::Atom_NET_WM_STATE_DEMANDS_ATTENTION));
 }
 
 uint QXcbWindow::visualId() const
@@ -2547,8 +2547,8 @@ void QXcbWindow::setWindowTitle(const QXcbConnection *conn, xcb_window_t window,
     xcb_change_property(conn->xcb_connection(),
                         XCB_PROP_MODE_REPLACE,
                         window,
-                        conn->atom(QXcbAtom::_NET_WM_NAME),
-                        conn->atom(QXcbAtom::UTF8_STRING),
+                        conn->atom(QXcbAtom::Atom_NET_WM_NAME),
+                        conn->atom(QXcbAtom::AtomUTF8_STRING),
                         8,
                         ba.size(),
                         ba.constData());
@@ -2564,9 +2564,9 @@ void QXcbWindow::setWindowTitle(const QXcbConnection *conn, xcb_window_t window,
 
 QString QXcbWindow::windowTitle(const QXcbConnection *conn, xcb_window_t window)
 {
-    const xcb_atom_t utf8Atom = conn->atom(QXcbAtom::UTF8_STRING);
+    const xcb_atom_t utf8Atom = conn->atom(QXcbAtom::AtomUTF8_STRING);
     auto reply = Q_XCB_REPLY_UNCHECKED(xcb_get_property, conn->xcb_connection(),
-                                       false, window, conn->atom(QXcbAtom::_NET_WM_NAME),
+                                       false, window, conn->atom(QXcbAtom::Atom_NET_WM_NAME),
                                        utf8Atom, 0, 1024);
     if (reply && reply->format == 8 && reply->type == utf8Atom) {
         const char *name = reinterpret_cast<const char *>(xcb_get_property_value(reply.get()));
@@ -2574,7 +2574,7 @@ QString QXcbWindow::windowTitle(const QXcbConnection *conn, xcb_window_t window)
     }
 
     reply = Q_XCB_REPLY_UNCHECKED(xcb_get_property, conn->xcb_connection(),
-                                  false, window, conn->atom(QXcbAtom::WM_NAME),
+                                  false, window, conn->atom(QXcbAtom::AtomWM_NAME),
                                   XCB_ATOM_STRING, 0, 1024);
     if (reply && reply->format == 8 && reply->type == XCB_ATOM_STRING) {
         const char *name = reinterpret_cast<const char *>(xcb_get_property_value(reply.get()));
diff --git a/src/plugins/platforms/xcb/qxcbwmsupport.cpp b/src/plugins/platforms/xcb/qxcbwmsupport.cpp
index 50e85c0aa5..0e3c470c89 100644
--- a/src/plugins/platforms/xcb/qxcbwmsupport.cpp
+++ b/src/plugins/platforms/xcb/qxcbwmsupport.cpp
@@ -30,7 +30,7 @@ void QXcbWMSupport::updateNetWMAtoms()
     int offset = 0;
     int remaining = 0;
     do {
-        auto reply = Q_XCB_REPLY(xcb_get_property, xcb_connection(), false, root, atom(QXcbAtom::_NET_SUPPORTED), XCB_ATOM_ATOM, offset, 1024);
+        auto reply = Q_XCB_REPLY(xcb_get_property, xcb_connection(), false, root, atom(QXcbAtom::Atom_NET_SUPPORTED), XCB_ATOM_ATOM, offset, 1024);
         if (!reply)
             break;
 
@@ -54,7 +54,7 @@ void QXcbWMSupport::updateVirtualRoots()
 {
     net_virtual_roots.clear();
 
-    if (!isSupportedByWM(atom(QXcbAtom::_NET_VIRTUAL_ROOTS)))
+    if (!isSupportedByWM(atom(QXcbAtom::Atom_NET_VIRTUAL_ROOTS)))
         return;
 
     xcb_window_t root = connection()->primaryScreen()->root();
@@ -62,7 +62,7 @@ void QXcbWMSupport::updateVirtualRoots()
     int remaining = 0;
     do {
         auto reply = Q_XCB_REPLY(xcb_get_property, xcb_connection(),
-                                 false, root, atom(QXcbAtom::_NET_VIRTUAL_ROOTS), XCB_ATOM_WINDOW, offset, 1024);
+                                 false, root, atom(QXcbAtom::Atom_NET_VIRTUAL_ROOTS), XCB_ATOM_WINDOW, offset, 1024);
         if (!reply)
             break;
 
diff --git a/src/plugins/platforms/xcb/qxcbxsettings.cpp b/src/plugins/platforms/xcb/qxcbxsettings.cpp
index 21828922c6..6b62864add 100644
--- a/src/plugins/platforms/xcb/qxcbxsettings.cpp
+++ b/src/plugins/platforms/xcb/qxcbxsettings.cpp
@@ -68,7 +68,7 @@ public:
 
         int offset = 0;
         QByteArray settings;
-        xcb_atom_t _xsettings_atom = screen->connection()->atom(QXcbAtom::_XSETTINGS_SETTINGS);
+        xcb_atom_t _xsettings_atom = screen->connection()->atom(QXcbAtom::Atom_XSETTINGS_SETTINGS);
         while (1) {
             auto reply = Q_XCB_REPLY_UNCHECKED(xcb_get_property,
                                                screen->xcb_connection(),