clipboard.c 6.91 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
/*
 * Server-side clipboard management
 *
 * Copyright (C) 2002 Ulrich Czekalla
 *
 * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include "config.h"
#include "wine/port.h"

#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

29 30
#include "ntstatus.h"
#define WIN32_NO_STATUS
31 32 33
#include "request.h"
#include "object.h"
#include "user.h"
34
#include "winuser.h"
35
#include "winternl.h"
36

37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60
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 */
    struct thread *owner_thread;     /* thread id that owns the clipboard */
    user_handle_t  owner_win;        /* window that owns the clipboard data */
    user_handle_t  viewer;           /* first window in clipboard viewer list */
    unsigned int   seqno;            /* clipboard change sequence number */
    time_t         seqno_timestamp;  /* time stamp of last seqno increment */
};

static void clipboard_dump( struct object *obj, int verbose );

static const struct object_ops clipboard_ops =
{
    sizeof(struct clipboard),     /* size */
    clipboard_dump,               /* dump */
    no_add_queue,                 /* add_queue */
    NULL,                         /* remove_queue */
    NULL,                         /* signaled */
    NULL,                         /* satisfied */
    no_signal,                    /* signal */
    no_get_fd,                    /* get_fd */
61
    no_map_access,                /* map_access */
62
    no_lookup_name,               /* lookup_name */
63 64 65
    no_close_handle,              /* close_handle */
    no_destroy                    /* destroy */
};
66 67 68 69


#define MINUPDATELAPSE 2

70 71 72 73 74 75 76 77 78 79 80 81
/* 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=%p owner_thread=%p owner_win=%p viewer=%p seq=%u\n",
             clipboard->open_thread, clipboard->open_win, clipboard->owner_thread,
             clipboard->owner_win, clipboard->viewer, clipboard->seqno );
}

/* retrieve the clipboard info for the current process, allocating it if needed */
static struct clipboard *get_process_clipboard(void)
82
{
83 84 85 86 87
    struct clipboard *clipboard;
    struct winstation *winstation = get_process_winstation( current->process, WINSTA_ACCESSCLIPBOARD );

    if (!winstation) return NULL;

88
    if (!(clipboard = winstation->clipboard))
89
    {
90 91 92 93 94 95 96 97 98
        if ((clipboard = alloc_object( &clipboard_ops )))
        {
            clipboard->open_thread = NULL;
            clipboard->open_win = 0;
            clipboard->owner_thread = NULL;
            clipboard->owner_win = 0;
            clipboard->viewer = 0;
            clipboard->seqno = 0;
            clipboard->seqno_timestamp = 0;
99
            winstation->clipboard = clipboard;
100
        }
101
    }
102 103 104 105 106 107 108 109 110 111 112 113 114
    release_object( winstation );
    return clipboard;
}


/* Called when thread terminates to allow release of clipboard */
void cleanup_clipboard_thread(struct thread *thread)
{
    struct clipboard *clipboard;
    struct winstation *winstation = get_process_winstation( thread->process, WINSTA_ACCESSCLIPBOARD );

    if (!winstation) return;

115
    if ((clipboard = winstation->clipboard))
116
    {
117 118 119 120 121 122 123 124 125 126
        if (thread == clipboard->open_thread)
        {
            clipboard->open_win = 0;
            clipboard->open_thread = NULL;
        }
        if (thread == clipboard->owner_thread)
        {
            clipboard->owner_win = 0;
            clipboard->owner_thread = NULL;
        }
127
    }
128
    release_object( winstation );
129 130
}

131
static int set_clipboard_window( struct clipboard *clipboard, user_handle_t win, int clear )
132
{
133
    if (clipboard->open_thread && clipboard->open_thread != current)
134 135 136 137 138 139
    {
        set_error(STATUS_WAS_LOCKED);
        return 0;
    }
    else if (!clear)
    {
140 141
        clipboard->open_win = win;
        clipboard->open_thread = current;
142 143 144
    }
    else
    {
145 146
        clipboard->open_thread = NULL;
        clipboard->open_win = 0;
147 148 149 150 151
    }
    return 1;
}


152
static int set_clipboard_owner( struct clipboard *clipboard, user_handle_t win, int clear )
153
{
154
    if (clipboard->open_thread && clipboard->open_thread->process != current->process)
155
    {
156 157 158 159 160
        set_error(STATUS_WAS_LOCKED);
        return 0;
    }
    else if (!clear)
    {
161 162
        clipboard->owner_win = win;
        clipboard->owner_thread = current;
163 164 165
    }
    else
    {
166 167
        clipboard->owner_win = 0;
        clipboard->owner_thread = NULL;
168
    }
169
    return 1;
170 171 172
}


173
static int get_seqno( struct clipboard *clipboard )
174 175 176
{
    time_t tm = time(NULL);

177
    if (!clipboard->owner_thread && (tm > (clipboard->seqno_timestamp + MINUPDATELAPSE)))
178
    {
179 180
        clipboard->seqno_timestamp = tm;
        clipboard->seqno++;
181
    }
182
    return clipboard->seqno;
183 184 185 186 187
}


DECL_HANDLER(set_clipboard_info)
{
188 189 190 191 192 193 194
    struct clipboard *clipboard = get_process_clipboard();

    if (!clipboard) return;

    reply->old_clipboard = clipboard->open_win;
    reply->old_owner     = clipboard->owner_win;
    reply->old_viewer    = clipboard->viewer;
195 196 197

    if (req->flags & SET_CB_OPEN)
    {
198
        if (clipboard->open_thread)
199 200 201 202 203 204
        {
            /* clipboard already opened */
            set_error(STATUS_WAS_LOCKED);
            return;
        }

205
        if (!set_clipboard_window( clipboard, req->clipboard, 0 )) return;
206 207 208
    }
    else if (req->flags & SET_CB_CLOSE)
    {
209
        if (clipboard->open_thread != current)
210 211 212 213 214
        {
            set_win32_error(ERROR_CLIPBOARD_NOT_OPEN);
            return;
        }

215
        if (!set_clipboard_window( clipboard, 0, 1 )) return;
216 217 218 219
    }

    if (req->flags & SET_CB_OWNER)
    {
220
        if (!set_clipboard_owner( clipboard, req->owner, 0 )) return;
221 222 223
    }
    else if (req->flags & SET_CB_RELOWNER)
    {
224
        if (!set_clipboard_owner( clipboard, 0, 1 )) return;
225 226
    }

227
    if (req->flags & SET_CB_VIEWER) clipboard->viewer = req->viewer;
228

229
    if (req->flags & SET_CB_SEQNO) clipboard->seqno++;
230

231
    reply->seqno = get_seqno( clipboard );
232

233 234 235
    if (clipboard->open_thread == current) reply->flags |= CB_OPEN;
    if (clipboard->owner_thread == current) reply->flags |= CB_OWNER;
    if (clipboard->owner_thread && clipboard->owner_thread->process == current->process)
236
        reply->flags |= CB_PROCESS;
237
}