xproto.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
void	xclip_handle_SelectionNotify (RDPCLIENT *This, XSelectionEvent *event)
void	xclip_handle_SelectionRequest (RDPCLIENT *This, XSelectionRequestEvent *xevent)
void	xclip_handle_SelectionClear (RDPCLIENT *This)
void	xclip_handle_PropertyNotify (RDPCLIENT *This, XPropertyEvent *xev)
int	ewmh_get_window_state (RDPCLIENT *This, Window w)
int	ewmh_change_state (RDPCLIENT *This, Window wnd, int state)
int	ewmh_move_to_desktop (RDPCLIENT *This, Window wnd, unsigned int desktop)
int	ewmh_get_window_desktop (RDPCLIENT *This, Window wnd)
void	ewmh_set_wm_name (RDPCLIENT *This, Window wnd, const char *title)
int	ewmh_set_window_popup (RDPCLIENT *This, Window wnd)
int	ewmh_set_window_modal (RDPCLIENT *This, Window wnd)

Function Documentation

ewmh_change_state()

int ewmh_change_state	(	RDPCLIENT *	This,
		Window	wnd,
		int	state
	)

Definition at line 321 of file ewmhints.c.

{
    /*
     * Deal with the max atoms
     */
    if (state == SEAMLESSRDP_MAXIMIZED)
    {
        if (ewmh_modify_state
            (This, wnd, 1, This->ewmhints.state_maximized_vert_atom,
             This->ewmhints.state_maximized_horz_atom) < 0)
            return -1;
    }
    else
    {
        if (ewmh_modify_state
            (This, wnd, 0, This->ewmhints.state_maximized_vert_atom,
             This->ewmhints.state_maximized_horz_atom) < 0)
            return -1;
    }

    return 0;
}

Referenced by ui_seamless_setstate().

ewmh_get_window_desktop()

int ewmh_get_window_desktop	(	RDPCLIENT *	This,
		Window	wnd
	)

Definition at line 346 of file ewmhints.c.

{
    unsigned long nitems_return;
    unsigned char *prop_return;
    int desktop;

    if (get_property_value(This, wnd, "_NET_WM_DESKTOP", 1, &nitems_return, &prop_return, 0) < 0)
        return (-1);

    if (nitems_return != 1)
    {
        fprintf(stderr, "_NET_WM_DESKTOP has bad length\n");
        return (-1);
    }

    desktop = *prop_return;
    XFree(prop_return);
    return desktop;
}

Referenced by xwin_process_events().

ewmh_get_window_state()

int ewmh_get_window_state	(	RDPCLIENT *	This,
		Window	w
	)

Definition at line 191 of file ewmhints.c.

{
    unsigned long nitems_return;
    unsigned char *prop_return;
    uint32 *return_words;
    unsigned long item;
    BOOL maximized_vert, maximized_horz, hidden;

    maximized_vert = maximized_horz = hidden = False;

    if (get_property_value(This, w, "_NET_WM_STATE", 64, &nitems_return, &prop_return, 0) < 0)
        return SEAMLESSRDP_NORMAL;

    return_words = (uint32 *) prop_return;

    for (item = 0; item < nitems_return; item++)
    {
        if (return_words[item] == This->ewmhints.state_maximized_vert_atom)
            maximized_vert = True;
        if (return_words[item] == This->ewmhints.state_maximized_horz_atom)
            maximized_horz = True;
        if (return_words[item] == This->ewmhints.state_hidden_atom)
            hidden = True;
    }

    XFree(prop_return);

    if (maximized_vert && maximized_horz)
        return SEAMLESSRDP_MAXIMIZED;
    else if (hidden)
        return SEAMLESSRDP_MINIMIZED;
    else
        return SEAMLESSRDP_NORMAL;
}

Referenced by xwin_process_events().

ewmh_move_to_desktop()

int ewmh_move_to_desktop	(	RDPCLIENT *	This,
		Window	wnd,
		unsigned int	desktop
	)

Definition at line 368 of file ewmhints.c.

{
    Status status;
    XEvent xevent;

    xevent.type = ClientMessage;
    xevent.xclient.window = wnd;
    xevent.xclient.message_type = This->net_wm_desktop_atom;
    xevent.xclient.format = 32;
    xevent.xclient.data.l[0] = desktop;
    xevent.xclient.data.l[1] = 0;
    xevent.xclient.data.l[2] = 0;
    xevent.xclient.data.l[3] = 0;
    xevent.xclient.data.l[4] = 0;
    status = XSendEvent(This->display, DefaultRootWindow(This->display), False,
                SubstructureNotifyMask | SubstructureRedirectMask, &xevent);
    if (!status)
        return -1;

    return 0;
}

Referenced by sw_all_to_desktop().

ewmh_set_window_modal()

int ewmh_set_window_modal	(	RDPCLIENT *	This,
		Window	wnd
	)

Definition at line 411 of file ewmhints.c.

{
    if (ewmh_modify_state(This, wnd, 1, This->ewmhints.state_modal_atom, 0) < 0)
        return -1;
    return 0;
}

Referenced by ui_seamless_create_window().

ewmh_set_window_popup()

int ewmh_set_window_popup	(	RDPCLIENT *	This,
		Window	wnd
	)

Definition at line 402 of file ewmhints.c.

{
    if (ewmh_modify_state
        (This, wnd, 1, This->ewmhints.state_skip_taskbar_atom, This->ewmhints.state_skip_pager_atom) < 0)
        return -1;
    return 0;
}

Referenced by ui_seamless_create_window().

ewmh_set_wm_name()

void ewmh_set_wm_name	(	RDPCLIENT *	This,
		Window	wnd,
		const char *	title
	)

Definition at line 391 of file ewmhints.c.

{
    int len;

    len = strlen(title);
    XChangeProperty(This->display, wnd, This->ewmhints.name_atom, This->ewmhints.utf8_string_atom,
            8, PropModeReplace, (unsigned char *) title, len);
}

Referenced by ui_seamless_create_window(), and ui_seamless_settitle().

xclip_handle_PropertyNotify()

void xclip_handle_PropertyNotify	(	RDPCLIENT *	This,
		XPropertyEvent *	xev
	)

Definition at line 779 of file xclip.c.

{
    unsigned long nitems;
    unsigned long offset = 0;
    unsigned long bytes_left = 1;
    int format;
    XWindowAttributes wa;
    uint8 *data;
    Atom type;

    if (event->state == PropertyNewValue && This->xclip.waiting_for_INCR)
    {
        DEBUG_CLIPBOARD(("x_clip_handle_PropertyNotify: This->xclip.waiting_for_INCR != 0\n"));

        while (bytes_left > 0)
        {
            /* Unlike the specification, we don't set the 'delete' arugment to True
               since we slurp the INCR's chunks in even-smaller chunks of 4096 bytes. */
            if ((XGetWindowProperty
                 (This->display, This->wnd, This->xclip.rdesktop_clipboard_target_atom, offset, 4096L,
                  False, AnyPropertyType, &type, &format, &nitems, &bytes_left,
                  &data) != Success))
            {
                XFree(data);
                return;
            }

            if (nitems == 0)
            {
                /* INCR transfer finished */
                XGetWindowAttributes(This->display, This->wnd, &wa);
                XSelectInput(This->display, This->wnd,
                         (wa.your_event_mask ^ PropertyChangeMask));
                XFree(data);
                This->xclip.waiting_for_INCR = 0;

                if (This->xclip.clip_buflen > 0)
                {
                    if (!xclip_send_data_with_convert
                        (This, This->xclip.clip_buffer, This->xclip.clip_buflen, This->xclip.incr_target))
                    {
                        helper_cliprdr_send_empty_response(This);
                    }
                    xfree(This->xclip.clip_buffer);
                    This->xclip.clip_buffer = NULL;
                    This->xclip.clip_buflen = 0;
                }
            }
            else
            {
                /* Another chunk in the INCR transfer */
                offset += (nitems / 4); /* offset at which to begin the next slurp */
                This->xclip.clip_buffer = xrealloc(This->xclip.clip_buffer, This->xclip.clip_buflen + nitems);
                memcpy(This->xclip.clip_buffer + This->xclip.clip_buflen, data, nitems);
                This->xclip.clip_buflen += nitems;

                XFree(data);
            }
        }
        XDeleteProperty(This->display, This->wnd, This->xclip.rdesktop_clipboard_target_atom);
        return;
    }

    if ((event->atom == This->xclip.rdesktop_selection_notify_atom) &&
        (event->window == DefaultRootWindow(This->display)))
        xclip_probe_selections(This);
}

Referenced by xwin_process_events().

xclip_handle_SelectionClear()

void xclip_handle_SelectionClear

(

RDPCLIENT *

This

)

Definition at line 770 of file xclip.c.

{
    DEBUG_CLIPBOARD(("xclip_handle_SelectionClear\n"));
    xclip_notify_change(This);
    xclip_probe_selections(This);
}

Referenced by xwin_process_events().

xclip_handle_SelectionNotify()

void xclip_handle_SelectionNotify	(	RDPCLIENT *	This,
		XSelectionEvent *	event
	)

Definition at line 417 of file xclip.c.

{
    unsigned long nitems, bytes_left;
    XWindowAttributes wa;
    Atom type;
    Atom *supported_targets;
    int res, i, format;
    uint8 *data = NULL;

    if (event->property == None)
        goto fail;

    DEBUG_CLIPBOARD(("xclip_handle_SelectionNotify: selection=%s, target=%s, property=%s\n",
             XGetAtomName(This->display, event->selection),
             XGetAtomName(This->display, event->target),
             XGetAtomName(This->display, event->property)));

    if (event->target == This->xclip.timestamp_atom)
    {
        if (event->selection == This->xclip.primary_atom)
        {
            res = XGetWindowProperty(This->display, This->wnd,
                         This->xclip.rdesktop_primary_timestamp_target_atom, 0,
                         XMaxRequestSize(This->display), False, AnyPropertyType,
                         &type, &format, &nitems, &bytes_left, &data);
        }
        else
        {
            res = XGetWindowProperty(This->display, This->wnd,
                         This->xclip.rdesktop_clipboard_timestamp_target_atom, 0,
                         XMaxRequestSize(This->display), False, AnyPropertyType,
                         &type, &format, &nitems, &bytes_left, &data);
        }


        if ((res != Success) || (nitems != 1) || (format != 32))
        {
            DEBUG_CLIPBOARD(("XGetWindowProperty failed!\n"));
            goto fail;
        }

        if (event->selection == This->xclip.primary_atom)
        {
            This->xclip.primary_timestamp = *(Time *) data;
            if (This->xclip.primary_timestamp == 0)
                This->xclip.primary_timestamp++;
            XDeleteProperty(This->display, This->wnd, This->xclip.rdesktop_primary_timestamp_target_atom);
            DEBUG_CLIPBOARD(("Got PRIMARY timestamp: %u\n",
                     (unsigned) This->xclip.primary_timestamp));
        }
        else
        {
            This->xclip.clipboard_timestamp = *(Time *) data;
            if (This->xclip.clipboard_timestamp == 0)
                This->xclip.clipboard_timestamp++;
            XDeleteProperty(This->display, This->wnd, This->xclip.rdesktop_clipboard_timestamp_target_atom);
            DEBUG_CLIPBOARD(("Got CLIPBOARD timestamp: %u\n",
                     (unsigned) This->xclip.clipboard_timestamp));
        }

        XFree(data);

        if (This->xclip.primary_timestamp && This->xclip.clipboard_timestamp)
        {
            if (This->xclip.primary_timestamp > This->xclip.clipboard_timestamp)
            {
                DEBUG_CLIPBOARD(("PRIMARY is most recent selection.\n"));
                XConvertSelection(This->display, This->xclip.primary_atom, This->xclip.targets_atom,
                          This->xclip.rdesktop_clipboard_target_atom, This->wnd,
                          event->time);
            }
            else
            {
                DEBUG_CLIPBOARD(("CLIPBOARD is most recent selection.\n"));
                XConvertSelection(This->display, This->xclip.clipboard_atom, This->xclip.targets_atom,
                          This->xclip.rdesktop_clipboard_target_atom, This->wnd,
                          event->time);
            }
        }

        return;
    }

    if (This->xclip.probing_selections && This->xclip.reprobe_selections)
    {
        This->xclip.probing_selections = False;
        xclip_probe_selections(This);
        return;
    }

    res = XGetWindowProperty(This->display, This->wnd, This->xclip.rdesktop_clipboard_target_atom,
                 0, XMaxRequestSize(This->display), False, AnyPropertyType,
                 &type, &format, &nitems, &bytes_left, &data);

    xclip_clear_target_props(This);

    if (res != Success)
    {
        DEBUG_CLIPBOARD(("XGetWindowProperty failed!\n"));
        goto fail;
    }

    if (type == This->xclip.incr_atom)
    {
        DEBUG_CLIPBOARD(("Received INCR.\n"));

        XGetWindowAttributes(This->display, This->wnd, &wa);
        if ((wa.your_event_mask | PropertyChangeMask) != wa.your_event_mask)
        {
            XSelectInput(This->display, This->wnd, (wa.your_event_mask | PropertyChangeMask));
        }
        XFree(data);
        This->xclip.incr_target = event->target;
        This->xclip.waiting_for_INCR = 1;
        goto end;
    }

    /* Negotiate target format */
    if (event->target == This->xclip.targets_atom)
    {
        /* Determine the best of text This->xclip.targets that we have available:
           Prefer UTF8_STRING > text/unicode (unspecified encoding) > STRING
           (ignore TEXT and COMPOUND_TEXT because we don't have code to handle them)
         */
        int text_target_satisfaction = 0;
        Atom best_text_target = 0;  /* measures how much we're satisfied with what we found */
        if (type != None)
        {
            supported_targets = (Atom *) data;
            for (i = 0; i < nitems; i++)
            {
                DEBUG_CLIPBOARD(("Target %d: %s\n", i,
                         XGetAtomName(This->display, supported_targets[i])));
                if (supported_targets[i] == This->xclip.format_string_atom)
                {
                    if (text_target_satisfaction < 1)
                    {
                        DEBUG_CLIPBOARD(("Other party supports STRING, choosing that as best_target\n"));
                        best_text_target = supported_targets[i];
                        text_target_satisfaction = 1;
                    }
                }
#ifdef USE_UNICODE_CLIPBOARD
                else if (supported_targets[i] == This->xclip.format_unicode_atom)
                {
                    if (text_target_satisfaction < 2)
                    {
                        DEBUG_CLIPBOARD(("Other party supports text/unicode, choosing that as best_target\n"));
                        best_text_target = supported_targets[i];
                        text_target_satisfaction = 2;
                    }
                }
                else if (supported_targets[i] == This->xclip.format_utf8_string_atom)
                {
                    if (text_target_satisfaction < 3)
                    {
                        DEBUG_CLIPBOARD(("Other party supports UTF8_STRING, choosing that as best_target\n"));
                        best_text_target = supported_targets[i];
                        text_target_satisfaction = 3;
                    }
                }
#endif
                else if (supported_targets[i] == This->xclip.rdesktop_clipboard_formats_atom)
                {
                    if (This->xclip.probing_selections && (text_target_satisfaction < 4))
                    {
                        DEBUG_CLIPBOARD(("Other party supports native formats, choosing that as best_target\n"));
                        best_text_target = supported_targets[i];
                        text_target_satisfaction = 4;
                    }
                }
            }
        }

        /* Kickstarting the next step in the process of satisfying RDP's
           clipboard request -- specifically, requesting the actual clipboard data.
         */
        if ((best_text_target != 0)
            && (!This->xclip.probing_selections
            || (best_text_target == This->xclip.rdesktop_clipboard_formats_atom)))
        {
            XConvertSelection(This->display, event->selection, best_text_target,
                      This->xclip.rdesktop_clipboard_target_atom, This->wnd, event->time);
            goto end;
        }
        else
        {
            DEBUG_CLIPBOARD(("Unable to find a textual target to satisfy RDP clipboard text request\n"));
            goto fail;
        }
    }
    else
    {
        if (This->xclip.probing_selections)
        {
            Window primary_owner, clipboard_owner;

            /* FIXME:
               Without XFIXES, we must make sure that the other
               rdesktop owns all relevant selections or we might try
               to get a native format from non-rdesktop window later
               on. */

            clipboard_owner = XGetSelectionOwner(This->display, This->xclip.clipboard_atom);

            if (This->xclip.auto_mode)
                primary_owner = XGetSelectionOwner(This->display, This->xclip.primary_atom);
            else
                primary_owner = clipboard_owner;

            if (primary_owner != clipboard_owner)
                goto fail;

            DEBUG_CLIPBOARD(("Got fellow rdesktop formats\n"));
            This->xclip.probing_selections = False;
            This->xclip.rdesktop_is_selection_owner = True;
            cliprdr_send_native_format_announce(This, data, nitems);
        }
        else if (!xclip_send_data_with_convert(This, data, nitems, event->target))
        {
            goto fail;
        }
    }

      end:
    if (data)
        XFree(data);

    return;

      fail:
    xclip_clear_target_props(This);
    if (This->xclip.probing_selections)
    {
        DEBUG_CLIPBOARD(("Unable to find suitable target. Using default text format.\n"));
        This->xclip.probing_selections = False;
        This->xclip.rdesktop_is_selection_owner = False;

        /* FIXME:
           Without XFIXES, we cannot reliably know the formats offered by an
           upcoming selection owner, so we just lie about him offering
           RDP_CF_TEXT. */
        cliprdr_send_simple_native_format_announce(This, RDP_CF_TEXT);
    }
    else
    {
        helper_cliprdr_send_empty_response(This);
    }
    goto end;
}

Referenced by xwin_process_events().

xclip_handle_SelectionRequest()

void xclip_handle_SelectionRequest	(	RDPCLIENT *	This,
		XSelectionRequestEvent *	xevent
	)

Definition at line 673 of file xclip.c.

{
    unsigned long nitems, bytes_left;
    unsigned char *prop_return;
    int format, res;
    Atom type;

    DEBUG_CLIPBOARD(("xclip_handle_SelectionRequest: selection=%s, target=%s, property=%s\n",
             XGetAtomName(This->display, event->selection),
             XGetAtomName(This->display, event->target),
             XGetAtomName(This->display, event->property)));

    if (event->target == This->xclip.targets_atom)
    {
        xclip_provide_selection(This, event, XA_ATOM, 32, (uint8 *) & This->xclip.targets, This->xclip.num_targets);
        return;
    }
    else if (event->target == This->xclip.timestamp_atom)
    {
        xclip_provide_selection(This, event, XA_INTEGER, 32, (uint8 *) & This->xclip.acquire_time, 1);
        return;
    }
    else if (event->target == This->xclip.rdesktop_clipboard_formats_atom)
    {
        xclip_provide_selection(This, event, XA_STRING, 8, This->xclip.formats_data, This->xclip.formats_data_length);
    }
    else
    {
        /* All the following This->xclip.targets require an async operation with the RDP server
           and currently we don't do X clipboard request queueing so we can only
           handle one such request at a time. */
        if (This->xclip.has_selection_request)
        {
            DEBUG_CLIPBOARD(("Error: Another clipboard request was already sent to the RDP server and not yet responded. Refusing this request.\n"));
            xclip_refuse_selection(This, event);
            return;
        }
        if (event->target == This->xclip.rdesktop_native_atom)
        {
            /* Before the requestor makes a request for the _RDESKTOP_NATIVE target,
               he should declare requestor[property] = CF_SOMETHING. */
            res = XGetWindowProperty(This->display, event->requestor,
                         event->property, 0, 1, True,
                         XA_INTEGER, &type, &format, &nitems, &bytes_left,
                         &prop_return);
            if (res != Success)
            {
                DEBUG_CLIPBOARD(("Requested native format but didn't specifiy which.\n"));
                xclip_refuse_selection(This, event);
                return;
            }

            format = *(uint32 *) prop_return;
            XFree(prop_return);
        }
        else if (event->target == This->xclip.format_string_atom || event->target == XA_STRING)
        {
            /* STRING and XA_STRING are defined to be ISO8859-1 */
            format = CF_TEXT;
        }
        else if (event->target == This->xclip.format_utf8_string_atom)
        {
#ifdef USE_UNICODE_CLIPBOARD
            format = CF_UNICODETEXT;
#else
            DEBUG_CLIPBOARD(("Requested target unavailable due to lack of Unicode support. (It was not in TARGETS, so why did you ask for it?!)\n"));
            xclip_refuse_selection(This, event);
            return;
#endif
        }
        else if (event->target == This->xclip.format_unicode_atom)
        {
            /* Assuming text/unicode to be UTF-16 */
            format = CF_UNICODETEXT;
        }
        else
        {
            DEBUG_CLIPBOARD(("Requested target unavailable. (It was not in TARGETS, so why did you ask for it?!)\n"));
            xclip_refuse_selection(This, event);
            return;
        }

        cliprdr_send_data_request(This, format);
        This->xclip.selection_request = *event;
        This->xclip.has_selection_request = True;
        return;     /* wait for data */
    }
}

Referenced by xwin_process_events().