marko10_000
/
wine-wine
forked from Mirrors/wine-wine
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
wine-wine/server/clipboard.c

630 lines
19 KiB
C
Raw Permalink Blame History

/*
* Server-side clipboard management
*
* Copyright 2002 Ulrich Czekalla
* Copyright 2016 Alexandre Julliard
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "config.h"
#include "wine/port.h"
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "ntstatus.h"
#define WIN32_NO_STATUS
#include "request.h"
#include "object.h"
#include "file.h"
#include "process.h"
#include "user.h"
#include "winuser.h"
#include "winternl.h"
struct clip_format
{
struct list entry; /* entry in format list */
unsigned int id; /* format id */
unsigned int from; /* for synthesized data, format to generate it from */
unsigned int seqno; /* sequence number when the data was set */
data_size_t size; /* size of the data block */
void *data; /* data contents, or NULL for delay-rendered */
};
struct clipboard
{
struct object obj; /* object header */
struct thread *open_thread; /* thread id that has clipboard open */
user_handle_t open_win; /* window that has clipboard open */
user_handle_t owner; /* window that owns the clipboard */
user_handle_t viewer; /* first window in clipboard viewer list */
unsigned int lcid; /* locale id to use for synthesizing text formats */
unsigned int seqno; /* clipboard change sequence number */
unsigned int open_seqno; /* sequence number at open time */
unsigned int rendering; /* format rendering recursion counter */
struct list formats; /* list of data formats */
unsigned int format_count; /* count of data formats */
unsigned int format_map; /* existence bitmap for formats < CF_MAX */
unsigned int listen_size; /* size of listeners array */
unsigned int listen_count; /* count of listeners */
user_handle_t *listeners; /* array of listener windows */
};
static void clipboard_dump( struct object *obj, int verbose );
static void clipboard_destroy( struct object *obj );
static const struct object_ops clipboard_ops =
{
sizeof(struct clipboard), /* size */
clipboard_dump, /* dump */
no_get_type, /* get_type */
no_add_queue, /* add_queue */
NULL, /* remove_queue */
NULL, /* signaled */
NULL, /* satisfied */
no_signal, /* signal */
no_get_fd, /* get_fd */
no_map_access, /* map_access */
default_get_sd, /* get_sd */
default_set_sd, /* set_sd */
no_lookup_name, /* lookup_name */
no_link_name, /* link_name */
NULL, /* unlink_name */
no_open_file, /* open_file */
no_kernel_obj_list, /* get_kernel_obj_list */
no_close_handle, /* close_handle */
clipboard_destroy /* destroy */
};
#define HAS_FORMAT(map,id) ((map) & (1 << (id))) /* only for formats < CF_MAX */
/* find a data format in the clipboard */
static struct clip_format *get_format( struct clipboard *clipboard, unsigned int id )
{
struct clip_format *format;
LIST_FOR_EACH_ENTRY( format, &clipboard->formats, struct clip_format, entry )
if (format->id == id) return format;
return NULL;
}
/* add a data format to the clipboard */
static struct clip_format *add_format( struct clipboard *clipboard, unsigned int id )
{
struct clip_format *format;
if (!(format = mem_alloc( sizeof(*format )))) return NULL;
format->id = id;
format->from = 0;
format->size = 0;
format->data = NULL;
list_add_tail( &clipboard->formats, &format->entry );
clipboard->format_count++;
if (id < CF_MAX) clipboard->format_map |= 1 << id;
return format;
}
/* free all clipboard formats */
static void free_clipboard_formats( struct clipboard *clipboard )
{
struct clip_format *format, *next;
LIST_FOR_EACH_ENTRY_SAFE( format, next, &clipboard->formats, struct clip_format, entry )
{
list_remove( &format->entry );
free( format->data );
free( format );
}
clipboard->format_count = 0;
clipboard->format_map = 0;
}
/* dump a clipboard object */
static void clipboard_dump( struct object *obj, int verbose )
{
struct clipboard *clipboard = (struct clipboard *)obj;
fprintf( stderr, "Clipboard open_thread=%p open_win=%08x owner=%08x viewer=%08x seq=%u\n",
clipboard->open_thread, clipboard->open_win,
clipboard->owner, clipboard->viewer, clipboard->seqno );
}
static void clipboard_destroy( struct object *obj )
{
struct clipboard *clipboard = (struct clipboard *)obj;
free( clipboard->listeners );
free_clipboard_formats( clipboard );
}
/* retrieve the clipboard info for the current process, allocating it if needed */
static struct clipboard *get_process_clipboard(void)
{
struct clipboard *clipboard;
struct winstation *winstation = get_process_winstation( current->process, WINSTA_ACCESSCLIPBOARD );
if (!winstation) return NULL;
if (!(clipboard = winstation->clipboard))
{
if ((clipboard = alloc_object( &clipboard_ops )))
{
clipboard->open_thread = NULL;
clipboard->open_win = 0;
clipboard->owner = 0;
clipboard->viewer = 0;
clipboard->seqno = 0;
clipboard->format_count = 0;
clipboard->format_map = 0;
clipboard->listen_size = 0;
clipboard->listen_count = 0;
clipboard->listeners = NULL;
list_init( &clipboard->formats );
winstation->clipboard = clipboard;
}
}
release_object( winstation );
return clipboard;
}
/* add synthesized formats upon clipboard close */
static int synthesize_formats( struct clipboard *clipboard )
{
static const unsigned int formats[][3] =
{
{ CF_TEXT, CF_OEMTEXT, CF_UNICODETEXT },
{ CF_OEMTEXT, CF_UNICODETEXT, CF_TEXT },
{ CF_UNICODETEXT, CF_TEXT, CF_OEMTEXT },
{ CF_METAFILEPICT, CF_ENHMETAFILE },
{ CF_ENHMETAFILE, CF_METAFILEPICT },
{ CF_BITMAP, CF_DIB, CF_DIBV5 },
{ CF_DIB, CF_BITMAP, CF_DIBV5 },
{ CF_DIBV5, CF_BITMAP, CF_DIB }
};
unsigned int i, from, total = 0, map = clipboard->format_map;
struct clip_format *format;
if (!HAS_FORMAT( map, CF_LOCALE ) &&
(HAS_FORMAT( map, CF_TEXT ) || HAS_FORMAT( map, CF_OEMTEXT ) || HAS_FORMAT( map, CF_UNICODETEXT )))
{
void *data = memdup( &clipboard->lcid, sizeof(clipboard->lcid) );
if (data && (format = add_format( clipboard, CF_LOCALE )))
{
format->seqno = clipboard->seqno++;
format->data = data;
format->size = sizeof(clipboard->lcid);
}
else free( data );
}
for (i = 0; i < ARRAY_SIZE( formats ); i++)
{
if (HAS_FORMAT( map, formats[i][0] )) continue;
if (HAS_FORMAT( map, formats[i][1] )) from = formats[i][1];
else if (HAS_FORMAT( map, formats[i][2] )) from = formats[i][2];
else continue;
if (!(format = add_format( clipboard, formats[i][0] ))) continue;
format->from = from;
format->seqno = clipboard->seqno;
total++;
}
return total;
}
/* add a clipboard listener */
static void add_listener( struct clipboard *clipboard, user_handle_t window )
{
unsigned int i;
for (i = 0; i < clipboard->listen_count; i++)
{
if (clipboard->listeners[i] != window) continue;
set_error( STATUS_INVALID_PARAMETER ); /* already set */
return;
}
if (clipboard->listen_size == clipboard->listen_count)
{
unsigned int new_size = max( 8, clipboard->listen_size * 2 );
user_handle_t *new = realloc( clipboard->listeners, new_size * sizeof(*new) );
if (!new)
{
set_error( STATUS_NO_MEMORY );
return;
}
clipboard->listeners = new;
clipboard->listen_size = new_size;
}
clipboard->listeners[clipboard->listen_count++] = window;
}
/* remove a clipboard listener */
static int remove_listener( struct clipboard *clipboard, user_handle_t window )
{
unsigned int i;
for (i = 0; i < clipboard->listen_count; i++)
{
if (clipboard->listeners[i] != window) continue;
memmove( clipboard->listeners + i, clipboard->listeners + i + 1,
(clipboard->listen_count - i - 1) * sizeof(*clipboard->listeners) );
clipboard->listen_count--;
return 1;
}
return 0;
}
/* notify all listeners, and return the viewer window that should be notified if any */
static user_handle_t notify_listeners( struct clipboard *clipboard )
{
unsigned int i;
for (i = 0; i < clipboard->listen_count; i++)
post_message( clipboard->listeners[i], WM_CLIPBOARDUPDATE, 0, 0 );
return clipboard->viewer;
}
/* close the clipboard, and return the viewer window that should be notified if any */
static user_handle_t close_clipboard( struct clipboard *clipboard )
{
clipboard->open_win = 0;
clipboard->open_thread = NULL;
if (clipboard->seqno == clipboard->open_seqno) return 0; /* unchanged */
if (synthesize_formats( clipboard )) clipboard->seqno++;
return notify_listeners( clipboard );
}
/* release the clipboard owner, and return the viewer window that should be notified if any */
static user_handle_t release_clipboard( struct clipboard *clipboard )
{
struct clip_format *format, *next;
int changed = 0;
clipboard->owner = 0;
/* free the delayed-rendered formats, since we no longer have an owner to render them */
LIST_FOR_EACH_ENTRY_SAFE( format, next, &clipboard->formats, struct clip_format, entry )
{
if (format->data || format->from) continue;
list_remove( &format->entry );
if (format->id < CF_MAX) clipboard->format_map &= ~(1 << format->id);
clipboard->format_count--;
free( format );
changed = 1;
}
if (!changed) return 0;
clipboard->seqno++;
return notify_listeners( clipboard );
}
/* cleanup clipboard information upon window destruction */
void cleanup_clipboard_window( struct desktop *desktop, user_handle_t window )
{
struct clipboard *clipboard = desktop->winstation->clipboard;
if (!clipboard) return;
remove_listener( clipboard, window );
if (clipboard->viewer == window) clipboard->viewer = 0;
if (clipboard->owner == window) release_clipboard( clipboard );
if (clipboard->open_win == window)
{
user_handle_t viewer = close_clipboard( clipboard );
if (viewer) send_notify_message( viewer, WM_DRAWCLIPBOARD, clipboard->owner, 0 );
}
}
/* Called when thread terminates to allow release of clipboard */
void cleanup_clipboard_thread(struct thread *thread)
{
struct clipboard *clipboard;
struct winstation *winstation;
if (!thread->process->winstation) return;
if (!(winstation = get_process_winstation( thread->process, WINSTA_ACCESSCLIPBOARD ))) return;
if ((clipboard = winstation->clipboard))
{
if (thread == clipboard->open_thread)
{
user_handle_t viewer = close_clipboard( clipboard );
if (viewer) send_notify_message( viewer, WM_DRAWCLIPBOARD, clipboard->owner, 0 );
}
}
release_object( winstation );
}
/* open the clipboard */
DECL_HANDLER(open_clipboard)
{
struct clipboard *clipboard = get_process_clipboard();
user_handle_t win = 0;
if (!clipboard) return;
if (req->window && !(win = get_valid_window_handle( req->window ))) return;
if (clipboard->open_thread && clipboard->open_win != win)
{
set_error( STATUS_INVALID_LOCK_SEQUENCE );
return;
}
if (!clipboard->open_thread) clipboard->open_seqno = clipboard->seqno; /* first open */
if (clipboard->open_thread != current) clipboard->rendering = 0;
clipboard->open_win = win;
clipboard->open_thread = current;
reply->owner = clipboard->owner;
}
/* close the clipboard */
DECL_HANDLER(close_clipboard)
{
struct clipboard *clipboard = get_process_clipboard();
if (!clipboard) return;
if (clipboard->open_thread != current)
{
set_win32_error( ERROR_CLIPBOARD_NOT_OPEN );
return;
}
reply->viewer = close_clipboard( clipboard );
reply->owner = clipboard->owner;
}
/* add a data format to the clipboard */
DECL_HANDLER(set_clipboard_data)
{
struct clip_format *format;
struct clipboard *clipboard = get_process_clipboard();
void *data = NULL;
if (!clipboard) return;
if (!req->format || !clipboard->open_thread)
{
set_win32_error( ERROR_CLIPBOARD_NOT_OPEN );
return;
}
if (get_req_data_size() && !(data = memdup( get_req_data(), get_req_data_size() ))) return;
if (!(format = get_format( clipboard, req->format )))
{
if (!(format = add_format( clipboard, req->format )))
{
free( data );
return;
}
}
free( format->data );
format->from = 0;
format->seqno = clipboard->seqno;
format->size = get_req_data_size();
format->data = data;
if (!clipboard->rendering) clipboard->seqno++;
if (req->format == CF_TEXT || req->format == CF_OEMTEXT || req->format == CF_UNICODETEXT)
clipboard->lcid = req->lcid;
reply->seqno = format->seqno;
}
/* fetch a data format from the clipboard */
DECL_HANDLER(get_clipboard_data)
{
struct clip_format *format;
struct clipboard *clipboard = get_process_clipboard();
if (!clipboard) return;
if (clipboard->open_thread != current)
{
set_win32_error( ERROR_CLIPBOARD_NOT_OPEN );
return;
}
if (!(format = get_format( clipboard, req->format )))
{
set_error( STATUS_OBJECT_NAME_NOT_FOUND );
goto done;
}
reply->from = format->from;
reply->total = format->size;
reply->seqno = format->seqno;
reply->owner = clipboard->owner;
if (!format->data && req->render) /* try rendering it client-side */
{
if (format->from || clipboard->owner) clipboard->rendering++;
return;
}
if (req->cached && req->seqno == format->seqno) goto done; /* client-side cache still valid */
if (format->size > get_reply_max_size())
{
set_error( STATUS_BUFFER_OVERFLOW );
return;
}
set_reply_data( format->data, format->size );
done:
if (!req->render) clipboard->rendering--;
}
/* retrieve a list of available formats */
DECL_HANDLER(get_clipboard_formats)
{
struct clipboard *clipboard = get_process_clipboard();
if (!clipboard) return;
if (!req->format)
{
struct clip_format *format;
unsigned int i = 0, *ptr;
data_size_t size = clipboard->format_count * sizeof(unsigned int);
reply->count = clipboard->format_count;
if (size <= get_reply_max_size())
{
if ((ptr = mem_alloc( size )))
{
LIST_FOR_EACH_ENTRY( format, &clipboard->formats, struct clip_format, entry )
ptr[i++] = format->id;
assert( i == clipboard->format_count );
set_reply_data_ptr( ptr, size );
}
}
else set_error( STATUS_BUFFER_TOO_SMALL );
}
else reply->count = (get_format( clipboard, req->format ) != NULL); /* query a single format */
}
/* retrieve the next available format */
DECL_HANDLER(enum_clipboard_formats)
{
struct list *ptr;
struct clipboard *clipboard = get_process_clipboard();
if (!clipboard) return;
if (clipboard->open_thread != current)
{
set_win32_error( ERROR_CLIPBOARD_NOT_OPEN );
return;
}
ptr = list_head( &clipboard->formats );
if (req->previous)
{
while (ptr && LIST_ENTRY( ptr, struct clip_format, entry )->id != req->previous)
ptr = list_next( &clipboard->formats, ptr );
if (ptr) ptr = list_next( &clipboard->formats, ptr );
}
if (ptr) reply->format = LIST_ENTRY( ptr, struct clip_format, entry )->id;
}
/* empty the clipboard and grab ownership */
DECL_HANDLER(empty_clipboard)
{
struct clipboard *clipboard = get_process_clipboard();
if (!clipboard) return;
if (clipboard->open_thread != current)
{
set_win32_error( ERROR_CLIPBOARD_NOT_OPEN );
return;
}
free_clipboard_formats( clipboard );
clipboard->owner = clipboard->open_win;
clipboard->seqno++;
}
/* release ownership of the clipboard */
DECL_HANDLER(release_clipboard)
{
struct clipboard *clipboard = get_process_clipboard();
user_handle_t owner;
if (!clipboard) return;
if (!(owner = get_valid_window_handle( req->owner ))) return;
if (clipboard->owner == owner)
{
reply->viewer = release_clipboard( clipboard );
reply->owner = clipboard->owner;
}
else set_error( STATUS_INVALID_OWNER );
}
/* get clipboard information */
DECL_HANDLER(get_clipboard_info)
{
struct clipboard *clipboard = get_process_clipboard();
if (!clipboard) return;
reply->window = clipboard->open_win;
reply->owner = clipboard->owner;
reply->viewer = clipboard->viewer;
reply->seqno = clipboard->seqno;
}
/* set the clipboard viewer window */
DECL_HANDLER(set_clipboard_viewer)
{
struct clipboard *clipboard = get_process_clipboard();
user_handle_t viewer = 0, previous = 0;
if (!clipboard) return;
if (req->viewer && !(viewer = get_valid_window_handle( req->viewer ))) return;
if (req->previous && !(previous = get_valid_window_handle( req->previous ))) return;
reply->old_viewer = clipboard->viewer;
reply->owner = clipboard->owner;
if (!previous || clipboard->viewer == previous)
clipboard->viewer = viewer;
else
set_error( STATUS_PENDING ); /* need to send message instead */
}
/* add a clipboard listener window */
DECL_HANDLER(add_clipboard_listener)
{
struct clipboard *clipboard = get_process_clipboard();
user_handle_t win;
if (!clipboard) return;
if (!(win = get_valid_window_handle( req->window ))) return;
add_listener( clipboard, win );
}
/* remove a clipboard listener window */
DECL_HANDLER(remove_clipboard_listener)
{
struct clipboard *clipboard = get_process_clipboard();
user_handle_t win;
if (!clipboard) return;
if (!(win = get_valid_window_handle( req->window ))) return;
if (!remove_listener( clipboard, win )) set_error( STATUS_INVALID_PARAMETER );
}
Reference in New Issue View Git Blame Copy Permalink