clipboard.c 7.17 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
/*
 * 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
18
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 20 21 22 23 24 25 26 27 28
 */

#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
#include "request.h"
#include "object.h"
33
#include "process.h"
34
#include "user.h"
35
#include "winuser.h"
36
#include "winternl.h"
37

38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55
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 */
56
    no_get_type,                  /* get_type */
57 58 59 60 61 62
    no_add_queue,                 /* add_queue */
    NULL,                         /* remove_queue */
    NULL,                         /* signaled */
    NULL,                         /* satisfied */
    no_signal,                    /* signal */
    no_get_fd,                    /* get_fd */
63
    no_map_access,                /* map_access */
64 65
    default_get_sd,               /* get_sd */
    default_set_sd,               /* set_sd */
66
    no_lookup_name,               /* lookup_name */
67
    no_open_file,                 /* open_file */
68 69 70
    no_close_handle,              /* close_handle */
    no_destroy                    /* destroy */
};
71 72 73 74


#define MINUPDATELAPSE 2

75 76 77 78 79
/* dump a clipboard object */
static void clipboard_dump( struct object *obj, int verbose )
{
    struct clipboard *clipboard = (struct clipboard *)obj;

80
    fprintf( stderr, "Clipboard open_thread=%p open_win=%08x owner_thread=%p owner_win=%08x viewer=%08x seq=%u\n",
81 82 83 84 85 86
             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)
87
{
88 89 90 91 92
    struct clipboard *clipboard;
    struct winstation *winstation = get_process_winstation( current->process, WINSTA_ACCESSCLIPBOARD );

    if (!winstation) return NULL;

93
    if (!(clipboard = winstation->clipboard))
94
    {
95 96 97 98 99 100 101 102 103
        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;
104
            winstation->clipboard = clipboard;
105
        }
106
    }
107 108 109 110 111 112 113 114 115
    release_object( winstation );
    return clipboard;
}


/* Called when thread terminates to allow release of clipboard */
void cleanup_clipboard_thread(struct thread *thread)
{
    struct clipboard *clipboard;
116
    struct winstation *winstation;
117

118 119
    if (!thread->process->winstation) return;
    if (!(winstation = get_process_winstation( thread->process, WINSTA_ACCESSCLIPBOARD ))) return;
120

121
    if ((clipboard = winstation->clipboard))
122
    {
123 124 125 126 127 128 129 130 131 132
        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;
        }
133
    }
134
    release_object( winstation );
135 136
}

137
static int set_clipboard_window( struct clipboard *clipboard, user_handle_t win, int clear )
138
{
139
    if (clipboard->open_thread && clipboard->open_thread != current)
140 141 142 143 144 145
    {
        set_error(STATUS_WAS_LOCKED);
        return 0;
    }
    else if (!clear)
    {
146 147
        clipboard->open_win = win;
        clipboard->open_thread = current;
148 149 150
    }
    else
    {
151 152
        clipboard->open_thread = NULL;
        clipboard->open_win = 0;
153 154 155 156 157
    }
    return 1;
}


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


179
static int get_seqno( struct clipboard *clipboard )
180 181 182
{
    time_t tm = time(NULL);

183
    if (!clipboard->owner_thread && (tm > (clipboard->seqno_timestamp + MINUPDATELAPSE)))
184
    {
185 186
        clipboard->seqno_timestamp = tm;
        clipboard->seqno++;
187
    }
188
    return clipboard->seqno;
189 190 191 192 193
}


DECL_HANDLER(set_clipboard_info)
{
194 195 196 197 198 199 200
    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;
201 202 203

    if (req->flags & SET_CB_OPEN)
    {
204
        if (clipboard->open_thread)
205 206 207 208 209 210
        {
            /* clipboard already opened */
            set_error(STATUS_WAS_LOCKED);
            return;
        }

211
        if (!set_clipboard_window( clipboard, req->clipboard, 0 )) return;
212 213 214
    }
    else if (req->flags & SET_CB_CLOSE)
    {
215
        if (clipboard->open_thread != current)
216 217 218 219 220
        {
            set_win32_error(ERROR_CLIPBOARD_NOT_OPEN);
            return;
        }

221
        if (!set_clipboard_window( clipboard, 0, 1 )) return;
222 223 224 225
    }

    if (req->flags & SET_CB_OWNER)
    {
226
        if (!set_clipboard_owner( clipboard, req->owner, 0 )) return;
227 228 229
    }
    else if (req->flags & SET_CB_RELOWNER)
    {
230
        if (!set_clipboard_owner( clipboard, 0, 1 )) return;
231 232
    }

233
    if (req->flags & SET_CB_VIEWER) clipboard->viewer = req->viewer;
234

235
    if (req->flags & SET_CB_SEQNO) clipboard->seqno++;
236

237
    reply->seqno = get_seqno( clipboard );
238

239 240 241
    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)
242
        reply->flags |= CB_PROCESS;
243
}