Edit

IABSD.fr/xenocara/xserver/present/present_event.c

Branch :

  • Show log

    Commit

  • Author : matthieu
    Date : 2023-10-29 16:45:32
    Hash : f9c3f64c
    Message : Update to xserver 21.1.9. All the security patches have already been committed. Udated autoconf to 2.71 explains the large build infrastructure diff.

  • xserver/present/present_event.c
  • /*
     * Copyright © 2013 Keith Packard
     *
     * Permission to use, copy, modify, distribute, and sell this software and its
     * documentation for any purpose is hereby granted without fee, provided that
     * the above copyright notice appear in all copies and that both that copyright
     * notice and this permission notice appear in supporting documentation, and
     * that the name of the copyright holders not be used in advertising or
     * publicity pertaining to distribution of the software without specific,
     * written prior permission.  The copyright holders make no representations
     * about the suitability of this software for any purpose.  It is provided "as
     * is" without express or implied warranty.
     *
     * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
     * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
     * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
     * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
     * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
     * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
     * OF THIS SOFTWARE.
     */
    
    #include "present_priv.h"
    
    static RESTYPE present_event_type;
    
    static int
    present_free_event(void *data, XID id)
    {
        present_event_ptr present_event = (present_event_ptr) data;
        present_window_priv_ptr window_priv = present_window_priv(present_event->window);
        present_event_ptr *previous, current;
    
        for (previous = &window_priv->events; (current = *previous); previous = &current->next) {
            if (current == present_event) {
                *previous = present_event->next;
                break;
            }
        }
        free((void *) present_event);
        return 1;
    
    }
    
    void
    present_free_events(WindowPtr window)
    {
        present_window_priv_ptr window_priv = present_window_priv(window);
        present_event_ptr event;
    
        if (!window_priv)
            return;
    
        while ((event = window_priv->events))
            FreeResource(event->id, RT_NONE);
    }
    
    static void
    present_event_swap(xGenericEvent *from, xGenericEvent *to)
    {
        *to = *from;
        swaps(&to->sequenceNumber);
        swapl(&to->length);
        swaps(&to->evtype);
        switch (from->evtype) {
        case PresentConfigureNotify: {
            xPresentConfigureNotify *c = (xPresentConfigureNotify *) to;
    
            swapl(&c->eid);
            swapl(&c->window);
            swaps(&c->x);
            swaps(&c->y);
            swaps(&c->width);
            swaps(&c->height);
            swaps(&c->off_x);
            swaps(&c->off_y);
            swaps(&c->pixmap_width);
            swaps(&c->pixmap_height);
            swapl(&c->pixmap_flags);
            break;
        }
        case PresentCompleteNotify:
        {
            xPresentCompleteNotify *c = (xPresentCompleteNotify *) to;
            swapl(&c->eid);
            swapl(&c->window);
            swapl(&c->serial);
            swapll(&c->ust);
            swapll(&c->msc);
            break;
        }
        case PresentIdleNotify:
        {
            xPresentIdleNotify *c = (xPresentIdleNotify *) to;
            swapl(&c->eid);
            swapl(&c->window);
            swapl(&c->serial);
            swapl(&c->idle_fence);
            break;
        }
        }
    }
    
    void
    present_send_config_notify(WindowPtr window, int x, int y, int w, int h,
                               int bw, WindowPtr sibling, CARD32 flags)
    {
        present_window_priv_ptr window_priv = present_window_priv(window);
    
        if (window_priv) {
            xPresentConfigureNotify cn = {
                .type = GenericEvent,
                .extension = present_request,
                .length = (sizeof(xPresentConfigureNotify) - 32) >> 2,
                .evtype = PresentConfigureNotify,
                .eid = 0,
                .window = window->drawable.id,
                .x = x,
                .y = y,
                .width = w,
                .height = h,
                .off_x = 0,
                .off_y = 0,
                .pixmap_width = w,
                .pixmap_height = h,
                .pixmap_flags = flags
            };
            present_event_ptr event;
    
            for (event = window_priv->events; event; event = event->next) {
                if (event->mask & (1 << PresentConfigureNotify)) {
                    cn.eid = event->id;
                    WriteEventsToClient(event->client, 1, (xEvent *) &cn);
                }
            }
        }
    }
    
    static present_complete_notify_proc complete_notify;
    
    void
    present_register_complete_notify(present_complete_notify_proc proc)
    {
        complete_notify = proc;
    }
    
    void
    present_send_complete_notify(WindowPtr window, CARD8 kind, CARD8 mode, CARD32 serial, uint64_t ust, uint64_t msc)
    {
        present_window_priv_ptr window_priv = present_window_priv(window);
    
        if (window_priv) {
            xPresentCompleteNotify cn = {
                .type = GenericEvent,
                .extension = present_request,
                .length = (sizeof(xPresentCompleteNotify) - 32) >> 2,
                .evtype = PresentCompleteNotify,
                .kind = kind,
                .mode = mode,
                .eid = 0,
                .window = window->drawable.id,
                .serial = serial,
                .ust = ust,
                .msc = msc,
            };
            present_event_ptr event;
    
            for (event = window_priv->events; event; event = event->next) {
                if (event->mask & PresentCompleteNotifyMask) {
                    cn.eid = event->id;
                    WriteEventsToClient(event->client, 1, (xEvent *) &cn);
                }
            }
        }
        if (complete_notify)
            (*complete_notify)(window, kind, mode, serial, ust, msc);
    }
    
    void
    present_send_idle_notify(WindowPtr window, CARD32 serial, PixmapPtr pixmap, struct present_fence *idle_fence)
    {
        present_window_priv_ptr window_priv = present_window_priv(window);
    
        if (window_priv) {
            xPresentIdleNotify in = {
                .type = GenericEvent,
                .extension = present_request,
                .length = (sizeof(xPresentIdleNotify) - 32) >> 2,
                .evtype = PresentIdleNotify,
                .eid = 0,
                .window = window->drawable.id,
                .serial = serial,
                .pixmap = pixmap->drawable.id,
                .idle_fence = present_fence_id(idle_fence)
            };
            present_event_ptr event;
    
            for (event = window_priv->events; event; event = event->next) {
                if (event->mask & PresentIdleNotifyMask) {
                    in.eid = event->id;
                    WriteEventsToClient(event->client, 1, (xEvent *) &in);
                }
            }
        }
    }
    
    int
    present_select_input(ClientPtr client, XID eid, WindowPtr window, CARD32 mask)
    {
        present_window_priv_ptr window_priv;
        present_event_ptr event;
        int ret;
    
        /* Check to see if we're modifying an existing event selection */
        ret = dixLookupResourceByType((void **) &event, eid, present_event_type,
                                     client, DixWriteAccess);
        if (ret == Success) {
            /* Match error for the wrong window; also don't modify some other
             * client's event selection
             */
            if (event->window != window || event->client != client)
                return BadMatch;
    
            if (mask)
                event->mask = mask;
            else
                FreeResource(eid, RT_NONE);
            return Success;
        }
        if (ret != BadValue)
            return ret;
    
        if (mask == 0)
            return Success;
    
        LEGAL_NEW_RESOURCE(eid, client);
    
        window_priv = present_get_window_priv(window, TRUE);
        if (!window_priv)
            return BadAlloc;
    
        event = calloc (1, sizeof (present_event_rec));
        if (!event)
            return BadAlloc;
    
        event->client = client;
        event->window = window;
        event->id = eid;
        event->mask = mask;
    
        event->next = window_priv->events;
        window_priv->events = event;
    
        if (!AddResource(event->id, present_event_type, (void *) event))
            return BadAlloc;
    
        return Success;
    }
    
    Bool
    present_event_init(void)
    {
        present_event_type = CreateNewResourceType(present_free_event, "PresentEvent");
        if (!present_event_type)
            return FALSE;
    
        GERegisterExtension(present_request, present_event_swap);
        return TRUE;
    }