git.oblomov.eu Git - wine/blob - server/clipboard.c

   1 /*
   2  * Server-side clipboard management
   3  *
   4  * Copyright (C) 2002 Ulrich Czekalla
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include <assert.h>
  25 #include <stdlib.h>
  26 #include <stdio.h>
  27 #include <string.h>
  28
  29 #include "ntstatus.h"
  30 #define WIN32_NO_STATUS
  31 #include "request.h"
  32 #include "object.h"
  33 #include "user.h"
  34 #include "winuser.h"
  35 #include "winternl.h"
  36
  37 struct clipboard
  38 {
  39     struct object  obj;              /* object header */
  40     struct thread *open_thread;      /* thread id that has clipboard open */
  41     user_handle_t  open_win;         /* window that has clipboard open */
  42     struct thread *owner_thread;     /* thread id that owns the clipboard */
  43     user_handle_t  owner_win;        /* window that owns the clipboard data */
  44     user_handle_t  viewer;           /* first window in clipboard viewer list */
  45     unsigned int   seqno;            /* clipboard change sequence number */
  46     time_t         seqno_timestamp;  /* time stamp of last seqno increment */
  47 };
  48
  49 static void clipboard_dump( struct object *obj, int verbose );
  50
  51 static const struct object_ops clipboard_ops =
  52 {
  53     sizeof(struct clipboard),     /* size */
  54     clipboard_dump,               /* dump */
  55     no_add_queue,                 /* add_queue */
  56     NULL,                         /* remove_queue */
  57     NULL,                         /* signaled */
  58     NULL,                         /* satisfied */
  59     no_signal,                    /* signal */
  60     no_get_fd,                    /* get_fd */
  61     no_map_access,                /* map_access */
  62     no_lookup_name,               /* lookup_name */
  63     no_close_handle,              /* close_handle */
  64     no_destroy                    /* destroy */
  65 };
  66
  67
  68 #define MINUPDATELAPSE 2
  69
  70 /* dump a clipboard object */
  71 static void clipboard_dump( struct object *obj, int verbose )
  72 {
  73     struct clipboard *clipboard = (struct clipboard *)obj;
  74
  75     fprintf( stderr, "Clipboard open_thread=%p open_win=%p owner_thread=%p owner_win=%p viewer=%p seq=%u\n",
  76              clipboard->open_thread, clipboard->open_win, clipboard->owner_thread,
  77              clipboard->owner_win, clipboard->viewer, clipboard->seqno );
  78 }
  79
  80 /* retrieve the clipboard info for the current process, allocating it if needed */
  81 static struct clipboard *get_process_clipboard(void)
  82 {
  83     struct clipboard *clipboard;
  84     struct winstation *winstation = get_process_winstation( current->process, WINSTA_ACCESSCLIPBOARD );
  85
  86     if (!winstation) return NULL;
  87
  88     if (!(clipboard = winstation->clipboard))
  89     {
  90         if ((clipboard = alloc_object( &clipboard_ops )))
  91         {
  92             clipboard->open_thread = NULL;
  93             clipboard->open_win = 0;
  94             clipboard->owner_thread = NULL;
  95             clipboard->owner_win = 0;
  96             clipboard->viewer = 0;
  97             clipboard->seqno = 0;
  98             clipboard->seqno_timestamp = 0;
  99             winstation->clipboard = clipboard;
 100         }
 101     }
 102     release_object( winstation );
 103     return clipboard;
 104 }
 105
 106
 107 /* Called when thread terminates to allow release of clipboard */
 108 void cleanup_clipboard_thread(struct thread *thread)
 109 {
 110     struct clipboard *clipboard;
 111     struct winstation *winstation = get_process_winstation( thread->process, WINSTA_ACCESSCLIPBOARD );
 112
 113     if (!winstation) return;
 114
 115     if ((clipboard = winstation->clipboard))
 116     {
 117         if (thread == clipboard->open_thread)
 118         {
 119             clipboard->open_win = 0;
 120             clipboard->open_thread = NULL;
 121         }
 122         if (thread == clipboard->owner_thread)
 123         {
 124             clipboard->owner_win = 0;
 125             clipboard->owner_thread = NULL;
 126         }
 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         set_error(STATUS_WAS_LOCKED);
 136         return 0;
 137     }
 138     else if (!clear)
 139     {
 140         clipboard->open_win = win;
 141         clipboard->open_thread = current;
 142     }
 143     else
 144     {
 145         clipboard->open_thread = NULL;
 146         clipboard->open_win = 0;
 147     }
 148     return 1;
 149 }
 150
 151
 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         set_error(STATUS_WAS_LOCKED);
 157         return 0;
 158     }
 159     else if (!clear)
 160     {
 161         clipboard->owner_win = win;
 162         clipboard->owner_thread = current;
 163     }
 164     else
 165     {
 166         clipboard->owner_win = 0;
 167         clipboard->owner_thread = NULL;
 168     }
 169     return 1;
 170 }
 171
 172
 173 static int get_seqno( struct clipboard *clipboard )
 174 {
 175     time_t tm = time(NULL);
 176
 177     if (!clipboard->owner_thread && (tm > (clipboard->seqno_timestamp + MINUPDATELAPSE)))
 178     {
 179         clipboard->seqno_timestamp = tm;
 180         clipboard->seqno++;
 181     }
 182     return clipboard->seqno;
 183 }
 184
 185
 186 DECL_HANDLER(set_clipboard_info)
 187 {
 188     struct clipboard *clipboard = get_process_clipboard();
 189
 190     if (!clipboard) return;
 191
 192     reply->old_clipboard = clipboard->open_win;
 193     reply->old_owner     = clipboard->owner_win;
 194     reply->old_viewer    = clipboard->viewer;
 195
 196     if (req->flags & SET_CB_OPEN)
 197     {
 198         if (clipboard->open_thread)
 199         {
 200             /* clipboard already opened */
 201             set_error(STATUS_WAS_LOCKED);
 202             return;
 203         }
 204
 205         if (!set_clipboard_window( clipboard, req->clipboard, 0 )) return;
 206     }
 207     else if (req->flags & SET_CB_CLOSE)
 208     {
 209         if (clipboard->open_thread != current)
 210         {
 211             set_win32_error(ERROR_CLIPBOARD_NOT_OPEN);
 212             return;
 213         }
 214
 215         if (!set_clipboard_window( clipboard, 0, 1 )) return;
 216     }
 217
 218     if (req->flags & SET_CB_OWNER)
 219     {
 220         if (!set_clipboard_owner( clipboard, req->owner, 0 )) return;
 221     }
 222     else if (req->flags & SET_CB_RELOWNER)
 223     {
 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     if (clipboard->open_thread == current) reply->flags |= CB_OPEN;
 234     if (clipboard->owner_thread == current) reply->flags |= CB_OWNER;
 235     if (clipboard->owner_thread && clipboard->owner_thread->process == current->process)
 236         reply->flags |= CB_PROCESS;
 237 }