RGFW sous le capot : XDrag & Drop-C++-php.cn

RGFW Under the Hood: XDrag

Introduction

Pour gérer les événements Drag 'n Drop avec X11, vous devez utiliser le protocole XDnD. Bien que le protocole XDnD soit nettement plus compliqué que les autres API Drag 'n Drop, il reste relativement simple en théorie. Cependant, sa mise en œuvre est fastidieuse car elle nécessite de bien communiquer avec le serveur X11 et la fenêtre source.

Ce tutoriel explique comment gérer le protocole XDnD et gérer les événements Drag 'n Drop X11. Le code est basé sur le code source de RGFW.

Aperçu

Un aperçu détaillé des étapes requises :

Tout d’abord, les X11 Atoms seront initialisés. Les atomes X11 sont utilisés pour demander ou envoyer des données ou des propriétés spécifiques via X11.
Ensuite, les propriétés de la fenêtre seront modifiées, lui permettant d'être au courant des événements XDND (X Drag 'n Drop).
Lorsqu'un glissement se produit, la fenêtre recevra un événement ClientMessage qui inclut un message XdndEnter indiquant à la fenêtre cible que le glissement a commencé.
Pendant que le glisser est en cours, la fenêtre source envoie des mises à jour sur le glisser à la fenêtre cible via les événements ClientMessage. Chaque fois que la fenêtre cible reçoit une mise à jour, elle doit confirmer qu'elle a reçu la mise à jour ; sinon, l'interaction prendra fin.
Une fois le dépôt effectué, la fenêtre source enverra un message XdndDrop. Ensuite, la fenêtre cible convertira la sélection déposée via X11 et recevra un événement SelectionNotify pour obtenir les données converties.
La fenêtre cible gérera cet événement, convertira les données en une chaîne lisible et enfin enverra un ClientMessage avec l'atome XdndFinished pour indiquer à la fenêtre source que l'interaction est terminée.

Un aperçu rapide des étapes requises :

1) Définir les atomes X11
2) Activer les événements XDnD pour la fenêtre
3) Gérer les événements XDnD via ClientMessage
4) Obtenez les données de dépôt XDnD via ClientMessage et terminez l'interaction

Étape 1 (Définir les atomes X11)

Pour gérer les événements XDnD, les atomes XDnD doivent être initialisés via XInternAtom. Les atomes sont utilisés lors de l'envoi ou de la demande de données ou d'actions spécifiques.

XdndTypeList est utilisé lorsque la fenêtre cible souhaite connaître les types de données pris en charge par la fenêtre source.
XdndSelection est utilisé pour examiner la sélection de données après un dépôt et pour récupérer les données après leur conversion.

const Atom XdndTypeList = XInternAtom(display, "XdndTypeList", False);
const Atom XdndSelection = XInternAtom(display, "XdndSelection", False);

Copier après la connexion

Ces atomes Xdnd génériques sont des messages envoyés par la fenêtre source à l'exception de XdndStatus.

XdndEnter, est utilisé lorsque le drop est entré dans la fenêtre cible.
XdndPosition est utilisé pour mettre à jour la fenêtre cible sur la position du drop.
XdndStatus est utilisé pour indiquer à la fenêtre source que la cible a reçu le message.
XdndLeave est utilisé lorsque le drop a quitté la fenêtre cible.
XdndDrop est utilisé lorsque le dépôt a été déposé dans la fenêtre cible.
XdndFinished est utilisé lorsque le dépôt est terminé.

const Atom XdndEnter = XInternAtom(display, "XdndEnter", False);
const Atom XdndPosition = XInternAtom(display, "XdndPosition", False);
const Atom XdndStatus = XInternAtom(display, "XdndStatus", False);
const Atom XdndLeave = XInternAtom(display, "XdndLeave", False);    
const Atom XdndDrop = XInternAtom(display, "XdndDrop", False);  
const Atom XdndFinished = XInternAtom(display, "XdndFinished", False);

Copier après la connexion

Les actions Xdnd sont les actions que la fenêtre cible souhaite effectuer avec les données de déplacement.

XdndActionCopy est utilisé lorsque la fenêtre cible souhaite copier les données de glissement.

const Atom XdndActionCopy = XInternAtom(display, "XdndActionCopy", False);

Copier après la connexion

Les atomes text/uri-list et text/plain sont nécessaires pour vérifier le format des données déposées.

const Atom XtextUriList = XInternAtom((Display*) display, "text/uri-list", False); 
const Atom XtextPlain = XInternAtom((Display*) display, "text/plain", False);

Copier après la connexion

Étape 2 (Activer les événements XDnD pour la fenêtre)

Pour recevoir des événements XDnD, la fenêtre doit activer l'atome XDndAware. Cet atome indique au gestionnaire de fenêtres et à la fenêtre source que la fenêtre souhaite recevoir des événements XDnD.

Cela peut être fait en créant un atome XdndAware et en utilisant XChangeProperty pour modifier la propriété XdndAware de la fenêtre.

Vous devez également définir la version XDnD à l'aide d'un pointeur, la version 5 doit être utilisée car il s'agit de la version la plus récente du protocole XDnD.

const Atom XdndAware = XInternAtom(display, "XdndAware", False);
const char myversion = 5;

XChangeProperty(display, window, XdndAware, 4, 32, PropModeReplace, &myversion, 1);

Copier après la connexion

Étape 3 (Gérer les événements XDnD via ClientMessage)

Avant de gérer un événement, certaines variables doivent être définies.
Ces variables nous sont fournies par la fenêtre source et sont utilisées sur plusieurs instances.

Ces variables sont la fenêtre source, la version XDnD Protocall utilisée et le format des données de dépôt.

int64_t source, version;
int32_t format;

Copier après la connexion

L'événement ClientMessage peut désormais être géré.

case ClientMessage:

Copier après la connexion

Tout d'abord, je vais créer une structure XEvent générique pour répondre aux événements XDnD. Ceci est facultatif, mais en l'utilisant, nous devrons faire moins de travail.

Cela enverra l'événement à la fenêtre source et inclura notre fenêtre (la cible) dans les données.

XEvent reply = { ClientMessage };
reply.xclient.window = source;
reply.xclient.format = 32;
reply.xclient.data.l[0] = (long) window;
reply.xclient.data.l[1] = 0;
reply.xclient.data.l[2] = None;

Copier après la connexion

La structure de l'événement ClientMessage est accessible via XEvent.xclient.

message_type est un attribut de la structure, il contient le type de message. Nous l'utiliserons pour vérifier si le type de message est un message XDnD.

Nous allons gérer 3 événements XDnD, XdndEnter, XdndPosition et XdndDrop.

Étape 3.1 (XdndEnter)

XdndEnter est envoyé lorsque le drop entre dans la fenêtre cible.

if (E.xclient.message_type == XdndEnter) {

Copier après la connexion

Tout d'abord, RGFW initialise les variables requises.

count: number of formats in the the format list,
formats: the list of supported formats and
real_formats: this is used here to avoid running malloc for each drop

    unsigned long count;
    Atom* formats;
    Atom real_formats[6];

Copier après la connexion

We can also create a bool to check if the supported formats are a list or if there is only one format.

This can be done by using the xclient's data attribute. Data is a list of data about the event.

the first item is the source window.

The second item of the data includes two values, if the format is a list or not and the version of XDnD used.

To get the bool value, you can check the first bit, the version is stored 24 bits after (the final 40 bits).

The format should be set to None for now, also make sure the version is less than or equal to 5. Otherwise, there's probably an issue because 5 is the newest version.

    Bool list = E.xclient.data.l[1] & 1;

    source = E.xclient.data.l[0];
    version = E.xclient.data.l[1] >> 24;
    format = None;

    if (version > 5)
        break;

Copier après la connexion

If the format is a list, we'll have to get the format list from the source window's XDndTypeList value using XGetWindowProperty

    if (list) {
        Atom actualType;
        int32_t actualFormat;
        unsigned long bytesAfter;

        XGetWindowProperty((Display*) display,
            source,
            XdndTypeList,
            0,
            LONG_MAX,
            False,
            4,
            &actualType,
            &actualFormat,
            &count,
            &bytesAfter,
            (unsigned char**) &formats);
    }

Copier après la connexion

Otherwise, the format can be found using the leftover xclient values (2 - 4)

    else {
        count = 0;

        if (E.xclient.data.l[2] != None)
            real_formats[count++] = E.xclient.data.l[2];
        if (E.xclient.data.l[3] != None)
            real_formats[count++] = E.xclient.data.l[3];
        if (E.xclient.data.l[4] != None)
            real_formats[count++] = E.xclient.data.l[4];

        formats = real_formats;
    }

Copier après la connexion

Now that we have the format array, we can check if the format matches any of the formats we're looking for.

The list should also be freed using XFree if it was received using XGetWindowProperty.

    unsigned long i;
    for (i = 0; i < count; i++) {
        if (formats[i] == XtextUriList || formats[i] == XtextPlain) {
            format = formats[i];
            break;
        }
    }

    if (list) {
        XFree(formats);
    }

    break;
}

Copier après la connexion

Step 3.2 (XdndPosition)

XdndPosition is used when the drop position is updated.

Before we handle the event, make sure the version is correct.

if (E.xclient.message_type == XdndPosition && version <= 5)) {

Copier après la connexion

The absolute X and Y can be found using the second item of the data list.

The X = the last 32 bits.
The Y = the first 32 bits.

    const int32_t xabs = (E.xclient.data.l[2] >> 16) & 0xffff;
    const int32_t yabs = (E.xclient.data.l[2]) & 0xffff;

Copier après la connexion

The absolute X and Y can be translated to the actual X and Y coordinates of the drop position using XTranslateCoordinates.

    Window dummy;
    int32_t xpos, ypos;

    XTranslateCoordinates((Display*) display,
        XDefaultRootWindow((Display*) display),
        (Window) window,
        xabs, yabs,
        &xpos, &ypos,
        &dummy);

    printf("File drop starting at %i %i\n", xpos, ypos);

Copier après la connexion

A response must be sent back to the source window. The response uses XdndStatus to tell the window it has received the message.

We should also tell the source the action accepted with the data. (XdndActionCopy)

The message can be sent out via XSendEvent make sure you also send out XFlush to make sure the event is pushed out.

    reply.xclient.message_type = XdndStatus;

    if (format) {
        reply.xclient.data.l[1] = 1;
        if (version >= 2)
            reply.xclient.data.l[4] = XdndActionCopy;
    }

    XSendEvent((Display*) display, source, False, NoEventMask, &reply);
    XFlush((Display*) display);
    break;
}

Copier après la connexion

Step 3.3 (XdndDrop)

Before we handle the event, make sure the version is correct.

XdndDrop occurs when the item has been dropped.

if (E.xclient.message_type = XdndDrop && version <= 5) {

Copier après la connexion

First, we should make sure we registered a valid format earlier.

    if (format) {

Copier après la connexion

We can use XConvertSection to request that the selection be converted to the format.

We will get the result in an SelectionNotify event.

        // newer versions of xDnD require us to tell the source our time 
        Time time = CurrentTime;
        if (version >= 1)
            time = E.xclient.data.l[2];

        XConvertSelection((Display*) display,
            XdndSelection,
            format,
            XdndSelection,
            (Window) window,
            time);
    }

Copier après la connexion

Otherwise, there is no drop data and the drop has ended. XDnD versions 2 and older require the target to tell the source when the drop has ended.

This can be done by sending out a ClientMessage event with the XdndFinished message type.

    else if (version >= 2) {
        reply.xclient.message_type = XdndFinished;

        XSendEvent((Display*) display, source,
            False, NoEventMask, &reply);
        XFlush((Display*) display);
    }
}

Copier après la connexion

Step 4 (Get the XDnD drop data via ClientMessage and end the interaction)

Now we can receive the converted selection from the SlectionNotify event

case SelectionNotify: {

Copier après la connexion

To do this, first, ensure the property is the XdndSelection.

/* this is only for checking for drops */

if (E.xselection.property != XdndSelection)
    break;

Copier après la connexion

XGetWindowpropery can be used to get the selection data.

char* data;
unsigned long result;

Atom actualType;
int32_t actualFormat;
unsigned long bytesAfter;

XGetWindowProperty((Display*) display, E.xselection.requestor, E.xselection.property, \
                                    0, LONG_MAX, False, E.xselection.target, &actualType, 
                                    &actualFormat, &result, &bytesAfter, 
                                    (unsigned char**) &data);

if (result == 0)
    break;

printf("File dropped: %s\n", data);

Copier après la connexion

This is the raw string data for the drop. If there are multiple drops, it will include the files separated by a '\n'. If you'd prefer an array of strings, you'd have to parse the data into an array.

The data should also be freed once you're done using it.

If you want to use the data after the event has been processed, you should allocate a separate buffer and copy the data over.

if (data)
    XFree(data);

Copier après la connexion

the drop has ended and XDnD versions 2 and older require the target to tell the source when the drop has ended.
This can be done by sending out a ClientMessage event with the XdndFinished message type.

It will also include the action we did with the data and the result to tell the source wether or not we actually got the data.

if (version >= 2) {
    reply.xclient.message_type = XdndFinished;
    reply.xclient.data.l[1] = result;
    reply.xclient.data.l[2] = XdndActionCopy;

    XSendEvent((Display*) display, source, False, NoEventMask, &reply);
    XFlush((Display*) display);
}

Copier après la connexion

Full code example

// This compiles with
// gcc example.c -lX11

#include 
#include 

#include 
#include 

int main(void) {
    Display* display = XOpenDisplay(NULL);

    Window window = XCreateSimpleWindow(display, 
                                        RootWindow(display, DefaultScreen(display)), 
                                        10, 10, 200, 200, 1,
                                        BlackPixel(display, DefaultScreen(display)), WhitePixel(display, DefaultScreen(display)));

    XSelectInput(display, window, ExposureMask | KeyPressMask);

    const Atom wm_delete_window = XInternAtom((Display*) display, "WM_DELETE_WINDOW", False);

    /* Xdnd code */

    /* fetching data */
    const Atom XdndTypeList = XInternAtom(display, "XdndTypeList", False);
    const Atom XdndSelection = XInternAtom(display, "XdndSelection", False);

    /* client messages */
    const Atom XdndEnter = XInternAtom(display, "XdndEnter", False);
    const Atom XdndPosition = XInternAtom(display, "XdndPosition", False);
    const Atom XdndStatus = XInternAtom(display, "XdndStatus", False);
    const Atom XdndLeave = XInternAtom(display, "XdndLeave", False);    
    const Atom XdndDrop = XInternAtom(display, "XdndDrop", False);  
    const Atom XdndFinished = XInternAtom(display, "XdndFinished", False);

    /* actions */
    const Atom XdndActionCopy = XInternAtom(display, "XdndActionCopy", False);
    const Atom XdndActionMove = XInternAtom(display, "XdndActionMove", False);
    const Atom XdndActionLink = XInternAtom(display, "XdndActionLink", False);
    const Atom XdndActionAsk = XInternAtom(display, "XdndActionAsk", False);
    const Atom XdndActionPrivate = XInternAtom(display, "XdndActionPrivate", False);

    const Atom XtextUriList = XInternAtom((Display*) display, "text/uri-list", False); 
    const Atom XtextPlain = XInternAtom((Display*) display, "text/plain", False);

    const Atom XdndAware = XInternAtom(display, "XdndAware", False);
    const char myVersion = 5;
    XChangeProperty(display, window, XdndAware, 4, 32, PropModeReplace, &myVersion, 1);

    XMapWindow(display, window);

    XEvent E;
    Bool running = True;

    int64_t source, version;
    int32_t format;

    while (running) {
        XNextEvent(display, &E);

        switch (E.type) {
            case KeyPress: running = False; break;
            case ClientMessage:
                if (E.xclient.data.l[0] == (int64_t) wm_delete_window) {
                    running = False;
                    break;
                }

                XEvent reply = { ClientMessage };
                reply.xclient.window = source;
                reply.xclient.format = 32;
                reply.xclient.data.l[0] = (long) window;
                reply.xclient.data.l[2] = 0;
                reply.xclient.data.l[3] = 0;


                if (E.xclient.message_type == XdndEnter) {
                    unsigned long count;
                    Atom* formats;
                    Atom real_formats[6];

                    Bool list = E.xclient.data.l[1] & 1;

                    source = E.xclient.data.l[0];
                    version = E.xclient.data.l[1] >> 24;
                    format = None;

                    if (version > 5)
                        break;

                    if (list) {
                        Atom actualType;
                        int32_t actualFormat;
                        unsigned long bytesAfter;

                        XGetWindowProperty((Display*) display,
                            source,
                            XdndTypeList,
                            0,
                            LONG_MAX,
                            False,
                            4,
                            &actualType,
                            &actualFormat,
                            &count,
                            &bytesAfter,
                            (unsigned char**) &formats);
                    } else {
                        count = 0;

                        if (E.xclient.data.l[2] != None)
                            real_formats[count++] = E.xclient.data.l[2];
                        if (E.xclient.data.l[3] != None)
                            real_formats[count++] = E.xclient.data.l[3];
                        if (E.xclient.data.l[4] != None)
                            real_formats[count++] = E.xclient.data.l[4];

                        formats = real_formats;
                    }

                    unsigned long i;
                    for (i = 0; i < count; i++) {
                        if (formats[i] == XtextUriList || formats[i] == XtextPlain) {
                            format = formats[i];
                            break;
                        }
                    }

                    if (list) {
                        XFree(formats);
                    }

                    break;
                }
                if (E.xclient.message_type == XdndPosition) {
                    const int32_t xabs = (E.xclient.data.l[2] >> 16) & 0xffff;
                    const int32_t yabs = (E.xclient.data.l[2]) & 0xffff;
                    Window dummy;
                    int32_t xpos, ypos;

                    if (version > 5)
                        break;

                    XTranslateCoordinates((Display*) display,
                        XDefaultRootWindow((Display*) display),
                        (Window) window,
                        xabs, yabs,
                        &xpos, &ypos,
                        &dummy);

                    printf("File drop starting at %i %i\n", xpos, ypos);

                    reply.xclient.message_type = XdndStatus;

                    if (format) {
                        reply.xclient.data.l[1] = 1;
                        if (version >= 2)
                            reply.xclient.data.l[4] = XdndActionCopy;
                    }

                    XSendEvent((Display*) display, source, False, NoEventMask, &reply);
                    XFlush((Display*) display);
                    break;
                }

                if (E.xclient.message_type = XdndDrop && version <= 5) {
                    if (format) {
                        Time time = CurrentTime;

                        if (version >= 1)
                            time = E.xclient.data.l[2];

                        XConvertSelection((Display*) display,
                            XdndSelection,
                            format,
                            XdndSelection,
                            (Window) window,
                            time);
                    } else if (version >= 2) {
                        reply.xclient.message_type = XdndFinished;

                        XSendEvent((Display*) display, source,
                            False, NoEventMask, &reply);
                        XFlush((Display*) display);
                    }
                }
                break;
        case SelectionNotify: {
            /* this is only for checking for drops */
            if (E.xselection.property != XdndSelection)
                break;

            char* data;
            unsigned long result;

            Atom actualType;
            int32_t actualFormat;
            unsigned long bytesAfter;

            XGetWindowProperty((Display*) display, 
                                            E.xselection.requestor, E.xselection.property, 
                                            0, LONG_MAX, False, E.xselection.target, 
                                            &actualType, &actualFormat, &result, &bytesAfter, 
                                            (unsigned char**) &data);

            if (result == 0)
                break;

            printf("File(s) dropped: %s\n", data);

            if (data)
                XFree(data);

            if (version >= 2) {
                reply.xclient.message_type = XdndFinished;
                reply.xclient.data.l[1] = result;
                reply.xclient.data.l[2] = XdndActionCopy;

                XSendEvent((Display*) display, source, False, NoEventMask, &reply);
                XFlush((Display*) display);
            }

            break;
        }

            default: break;
        }
    }

    XCloseDisplay(display);
}

Copier après la connexion

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!