wined3d: Use "gl_info" in some more places in context_create().
[wine] / 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, 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 "process.h"
34 #include "user.h"
35 #include "winuser.h"
36 #include "winternl.h"
37
38 struct clipboard
39 {
40     struct object  obj;              /* object header */
41     struct thread *open_thread;      /* thread id that has clipboard open */
42     user_handle_t  open_win;         /* window that has clipboard open */
43     struct thread *owner_thread;     /* thread id that owns the clipboard */
44     user_handle_t  owner_win;        /* window that owns the clipboard data */
45     user_handle_t  viewer;           /* first window in clipboard viewer list */
46     unsigned int   seqno;            /* clipboard change sequence number */
47     time_t         seqno_timestamp;  /* time stamp of last seqno increment */
48 };
49
50 static void clipboard_dump( struct object *obj, int verbose );
51
52 static const struct object_ops clipboard_ops =
53 {
54     sizeof(struct clipboard),     /* size */
55     clipboard_dump,               /* dump */
56     no_get_type,                  /* get_type */
57     no_add_queue,                 /* add_queue */
58     NULL,                         /* remove_queue */
59     NULL,                         /* signaled */
60     NULL,                         /* satisfied */
61     no_signal,                    /* signal */
62     no_get_fd,                    /* get_fd */
63     no_map_access,                /* map_access */
64     default_get_sd,               /* get_sd */
65     default_set_sd,               /* set_sd */
66     no_lookup_name,               /* lookup_name */
67     no_open_file,                 /* open_file */
68     no_close_handle,              /* close_handle */
69     no_destroy                    /* destroy */
70 };
71
72
73 #define MINUPDATELAPSE 2
74
75 /* dump a clipboard object */
76 static void clipboard_dump( struct object *obj, int verbose )
77 {
78     struct clipboard *clipboard = (struct clipboard *)obj;
79
80     fprintf( stderr, "Clipboard open_thread=%p open_win=%08x owner_thread=%p owner_win=%08x viewer=%08x seq=%u\n",
81              clipboard->open_thread, clipboard->open_win, clipboard->owner_thread,
82              clipboard->owner_win, clipboard->viewer, clipboard->seqno );
83 }
84
85 /* retrieve the clipboard info for the current process, allocating it if needed */
86 static struct clipboard *get_process_clipboard(void)
87 {
88     struct clipboard *clipboard;
89     struct winstation *winstation = get_process_winstation( current->process, WINSTA_ACCESSCLIPBOARD );
90
91     if (!winstation) return NULL;
92
93     if (!(clipboard = winstation->clipboard))
94     {
95         if ((clipboard = alloc_object( &clipboard_ops )))
96         {
97             clipboard->open_thread = NULL;
98             clipboard->open_win = 0;
99             clipboard->owner_thread = NULL;
100             clipboard->owner_win = 0;
101             clipboard->viewer = 0;
102             clipboard->seqno = 0;
103             clipboard->seqno_timestamp = 0;
104             winstation->clipboard = clipboard;
105         }
106     }
107     release_object( winstation );
108     return clipboard;
109 }
110
111
112 /* Called when thread terminates to allow release of clipboard */
113 void cleanup_clipboard_thread(struct thread *thread)
114 {
115     struct clipboard *clipboard;
116     struct winstation *winstation;
117
118     if (!thread->process->winstation) return;
119     if (!(winstation = get_process_winstation( thread->process, WINSTA_ACCESSCLIPBOARD ))) return;
120
121     if ((clipboard = winstation->clipboard))
122     {
123         if (thread == clipboard->open_thread)
124         {
125             clipboard->open_win = 0;
126             clipboard->open_thread = NULL;
127         }
128         if (thread == clipboard->owner_thread)
129         {
130             clipboard->owner_win = 0;
131             clipboard->owner_thread = NULL;
132         }
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         set_error(STATUS_WAS_LOCKED);
142         return 0;
143     }
144     else if (!clear)
145     {
146         clipboard->open_win = win;
147         clipboard->open_thread = current;
148     }
149     else
150     {
151         clipboard->open_thread = NULL;
152         clipboard->open_win = 0;
153     }
154     return 1;
155 }
156
157
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         set_error(STATUS_WAS_LOCKED);
163         return 0;
164     }
165     else if (!clear)
166     {
167         clipboard->owner_win = win;
168         clipboard->owner_thread = current;
169     }
170     else
171     {
172         clipboard->owner_win = 0;
173         clipboard->owner_thread = NULL;
174     }
175     return 1;
176 }
177
178
179 static int get_seqno( struct clipboard *clipboard )
180 {
181     time_t tm = time(NULL);
182
183     if (!clipboard->owner_thread && (tm > (clipboard->seqno_timestamp + MINUPDATELAPSE)))
184     {
185         clipboard->seqno_timestamp = tm;
186         clipboard->seqno++;
187     }
188     return clipboard->seqno;
189 }
190
191
192 DECL_HANDLER(set_clipboard_info)
193 {
194     struct clipboard *clipboard = get_process_clipboard();
195
196     if (!clipboard) return;
197
198     reply->old_clipboard = clipboard->open_win;
199     reply->old_owner     = clipboard->owner_win;
200     reply->old_viewer    = clipboard->viewer;
201
202     if (req->flags & SET_CB_OPEN)
203     {
204         if (clipboard->open_thread)
205         {
206             /* clipboard already opened */
207             set_error(STATUS_WAS_LOCKED);
208             return;
209         }
210
211         if (!set_clipboard_window( clipboard, req->clipboard, 0 )) return;
212     }
213     else if (req->flags & SET_CB_CLOSE)
214     {
215         if (clipboard->open_thread != current)
216         {
217             set_win32_error(ERROR_CLIPBOARD_NOT_OPEN);
218             return;
219         }
220
221         if (!set_clipboard_window( clipboard, 0, 1 )) return;
222     }
223
224     if (req->flags & SET_CB_OWNER)
225     {
226         if (!set_clipboard_owner( clipboard, req->owner, 0 )) return;
227     }
228     else if (req->flags & SET_CB_RELOWNER)
229     {
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     if (clipboard->open_thread == current) reply->flags |= CB_OPEN;
240     if (clipboard->owner_thread == current) reply->flags |= CB_OWNER;
241     if (clipboard->owner_thread && clipboard->owner_thread->process == current->process)
242         reply->flags |= CB_PROCESS;
243 }