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 }
244
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.