Contents of /trunk/tigervnc/patches/tigervnc-1.0.1-xserver19.patch
Parent Directory | Revision Log
Revision 1252 -
(show annotations)
(download)
Fri Jan 21 20:12:00 2011 UTC (13 years, 8 months ago) by niro
File size: 44479 byte(s)
Fri Jan 21 20:12:00 2011 UTC (13 years, 8 months ago) by niro
File size: 44479 byte(s)
added r3993 to fix compilation
1 | diff -Naur tigervnc-1.0.1/unix/xserver/hw/vnc/Input.cc tigervnc-1.0.1-magellan/unix/xserver/hw/vnc/Input.cc |
2 | --- tigervnc-1.0.1/unix/xserver/hw/vnc/Input.cc 2011-01-21 20:43:03.000000000 +0100 |
3 | +++ tigervnc-1.0.1-magellan/unix/xserver/hw/vnc/Input.cc 2011-01-21 20:52:21.000000000 +0100 |
4 | @@ -679,6 +679,8 @@ |
5 | action = down ? KeyPress : KeyRelease; |
6 | n = GetKeyboardEvents(eventq, keyboardDev, action, kc); |
7 | enqueueEvents(keyboardDev, n); |
8 | + |
9 | + FREE_MAPS; |
10 | |
11 | /* |
12 | * When faking a modifier we are putting a keycode (which can |
13 | diff -Naur tigervnc-1.0.1/unix/xserver/hw/vnc/vncHooks.cc tigervnc-1.0.1-magellan/unix/xserver/hw/vnc/vncHooks.cc |
14 | --- tigervnc-1.0.1/unix/xserver/hw/vnc/vncHooks.cc 2011-01-21 20:42:01.000000000 +0100 |
15 | +++ tigervnc-1.0.1-magellan/unix/xserver/hw/vnc/vncHooks.cc 2011-01-21 20:46:08.000000000 +0100 |
16 | @@ -93,11 +93,16 @@ |
17 | #if XORG == 15 |
18 | static DevPrivateKey vncHooksScreenPrivateKey = &vncHooksScreenPrivateKey; |
19 | static DevPrivateKey vncHooksGCPrivateKey = &vncHooksGCPrivateKey; |
20 | -#else |
21 | +#elif XORG < 19 |
22 | static int vncHooksScreenPrivateKeyIndex; |
23 | static int vncHooksGCPrivateKeyIndex; |
24 | static DevPrivateKey vncHooksScreenPrivateKey = &vncHooksScreenPrivateKeyIndex; |
25 | static DevPrivateKey vncHooksGCPrivateKey = &vncHooksGCPrivateKeyIndex; |
26 | +#else |
27 | +static DevPrivateKeyRec vncHooksScreenKeyRec; |
28 | +static DevPrivateKeyRec vncHooksGCKeyRec; |
29 | +#define vncHooksScreenPrivateKey (&vncHooksScreenKeyRec) |
30 | +#define vncHooksGCPrivateKey (&vncHooksGCKeyRec) |
31 | #endif |
32 | |
33 | #define vncHooksScreenPrivate(pScreen) \ |
34 | @@ -223,6 +228,7 @@ |
35 | { |
36 | vncHooksScreenPtr vncHooksScreen; |
37 | |
38 | +#if XORG < 19 |
39 | if (!dixRequestPrivate(vncHooksScreenPrivateKey, sizeof(vncHooksScreenRec))) { |
40 | ErrorF("vncHooksInit: Allocation of vncHooksScreen failed\n"); |
41 | return FALSE; |
42 | @@ -232,6 +238,20 @@ |
43 | return FALSE; |
44 | } |
45 | |
46 | +#else |
47 | + if (!dixRegisterPrivateKey(&vncHooksScreenKeyRec, PRIVATE_SCREEN, |
48 | + sizeof(vncHooksScreenRec))) { |
49 | + ErrorF("vncHooksInit: Allocation of vncHooksScreen failed\n"); |
50 | + return FALSE; |
51 | + } |
52 | + if (!dixRegisterPrivateKey(&vncHooksGCKeyRec, PRIVATE_GC, |
53 | + sizeof(vncHooksGCRec))) { |
54 | + ErrorF("vncHooksInit: Allocation of vncHooksGCRec failed\n"); |
55 | + return FALSE; |
56 | + } |
57 | + |
58 | +#endif |
59 | + |
60 | vncHooksScreen = vncHooksScreenPrivate(pScreen); |
61 | |
62 | vncHooksScreen->desktop = desktop; |
63 | @@ -344,7 +364,7 @@ |
64 | static Bool vncHooksCreateGC(GCPtr pGC) |
65 | { |
66 | SCREEN_UNWRAP(pGC->pScreen, CreateGC); |
67 | - |
68 | + |
69 | vncHooksGCPtr vncHooksGC = vncHooksGCPrivate(pGC); |
70 | |
71 | Bool ret = (*pScreen->CreateGC) (pGC); |
72 | diff -Naur tigervnc-1.0.1/unix/xserver/hw/vnc/xorg-version.h tigervnc-1.0.1-magellan/unix/xserver/hw/vnc/xorg-version.h |
73 | --- tigervnc-1.0.1/unix/xserver/hw/vnc/xorg-version.h 2011-01-21 20:42:27.000000000 +0100 |
74 | +++ tigervnc-1.0.1-magellan/unix/xserver/hw/vnc/xorg-version.h 2011-01-21 20:44:22.000000000 +0100 |
75 | @@ -30,8 +30,12 @@ |
76 | #define XORG 16 |
77 | #elif XORG_VERSION_CURRENT < ((1 * 10000000) + (7 * 100000) + (99 * 1000)) |
78 | #define XORG 17 |
79 | +#elif XORG_VERSION_CURRENT < ((1 * 10000000) + (8 * 100000) + (99 * 1000)) |
80 | +#define XORG 18 |
81 | +#elif XORG_VERSION_CURRENT < ((1 * 10000000) + (9 * 100000) + (99 * 1000)) |
82 | +#define XORG 19 |
83 | #else |
84 | -#error "X.Org newer than 1.7 is not supported" |
85 | +#error "X.Org newer than 1.9 is not supported" |
86 | #endif |
87 | |
88 | #endif |
89 | diff -Naur tigervnc-1.0.1/unix/xserver/hw/vnc/XserverDesktop.cc tigervnc-1.0.1-magellan/unix/xserver/hw/vnc/XserverDesktop.cc |
90 | --- tigervnc-1.0.1/unix/xserver/hw/vnc/XserverDesktop.cc 2011-01-21 20:43:00.000000000 +0100 |
91 | +++ tigervnc-1.0.1-magellan/unix/xserver/hw/vnc/XserverDesktop.cc 2011-01-21 20:47:41.000000000 +0100 |
92 | @@ -768,8 +768,14 @@ |
93 | region.get_rects(&rects); |
94 | for (i = rects.begin(); i != rects.end(); i++) { |
95 | for (int y = i->tl.y; y < i->br.y; y++) { |
96 | - (*pScreen->GetImage) ((DrawablePtr)WindowTable[pScreen->myNum], |
97 | - i->tl.x, y, i->width(), 1, |
98 | + DrawablePtr pDrawable; |
99 | +#if XORG < 19 |
100 | + pDrawable = (DrawablePtr) WindowTable[pScreen->myNum]; |
101 | +#else |
102 | + pDrawable = (DrawablePtr) pScreen->root; |
103 | +#endif |
104 | + |
105 | + (*pScreen->GetImage) (pDrawable, i->tl.x, y, i->width(), 1, |
106 | ZPixmap, (unsigned long)~0L, |
107 | ((char*)data |
108 | + y * bytesPerRow + i->tl.x * bytesPerPixel)); |
109 | diff -Naur tigervnc-1.0.1/unix/xserver/hw/vnc/XserverDesktop.cc.orig tigervnc-1.0.1-magellan/unix/xserver/hw/vnc/XserverDesktop.cc.orig |
110 | --- tigervnc-1.0.1/unix/xserver/hw/vnc/XserverDesktop.cc.orig 2011-01-21 20:42:27.000000000 +0100 |
111 | +++ tigervnc-1.0.1-magellan/unix/xserver/hw/vnc/XserverDesktop.cc.orig 2011-01-21 20:40:33.000000000 +0100 |
112 | @@ -167,8 +167,7 @@ |
113 | if (httpListener) |
114 | httpServer = new FileHTTPServer(this); |
115 | |
116 | - pointerDevice = new PointerDevice(server); |
117 | - keyboardDevice = new KeyboardDevice(); |
118 | + inputDevice = new InputDevice(server); |
119 | } |
120 | |
121 | XserverDesktop::~XserverDesktop() |
122 | @@ -177,8 +176,7 @@ |
123 | delete [] data; |
124 | TimerFree(deferredUpdateTimer); |
125 | TimerFree(dummyTimer); |
126 | - delete pointerDevice; |
127 | - delete keyboardDevice; |
128 | + delete inputDevice; |
129 | delete httpServer; |
130 | delete server; |
131 | } |
132 | @@ -589,7 +587,7 @@ |
133 | } |
134 | } |
135 | |
136 | - pointerDevice->Sync(); |
137 | + inputDevice->PointerSync(); |
138 | } |
139 | |
140 | int timeout = server->checkTimeouts(); |
141 | @@ -648,8 +646,8 @@ |
142 | |
143 | void XserverDesktop::pointerEvent(const Point& pos, int buttonMask) |
144 | { |
145 | - pointerDevice->Move(pos); |
146 | - pointerDevice->ButtonAction(buttonMask); |
147 | + inputDevice->PointerMove(pos); |
148 | + inputDevice->PointerButtonAction(buttonMask); |
149 | } |
150 | |
151 | void XserverDesktop::clientCutText(const char* str, int len) |
152 | @@ -810,7 +808,7 @@ |
153 | void XserverDesktop::keyEvent(rdr::U32 keysym, bool down) |
154 | { |
155 | if (down) |
156 | - keyboardDevice->Press(keysym); |
157 | + inputDevice->KeyboardPress(keysym); |
158 | else |
159 | - keyboardDevice->Release(keysym); |
160 | + inputDevice->KeyboardRelease(keysym); |
161 | } |
162 | diff -Naur tigervnc-1.0.1/unix/xserver/hw/vnc/xvnc.cc tigervnc-1.0.1-magellan/unix/xserver/hw/vnc/xvnc.cc |
163 | --- tigervnc-1.0.1/unix/xserver/hw/vnc/xvnc.cc 2011-01-21 20:42:27.000000000 +0100 |
164 | +++ tigervnc-1.0.1-magellan/unix/xserver/hw/vnc/xvnc.cc 2011-01-21 21:25:03.000000000 +0100 |
165 | @@ -609,7 +609,11 @@ |
166 | |
167 | for (i = 0; i < entries; i++) ppix[i] = i; |
168 | /* XXX truecolor */ |
169 | +#if XORG < 19 |
170 | QueryColors(pmap, entries, ppix, prgb); |
171 | +#else |
172 | + QueryColors(pmap, entries, ppix, prgb, serverClient); |
173 | +#endif |
174 | |
175 | for (i = 0; i < entries; i++) { /* convert xrgbs to xColorItems */ |
176 | defs[i].pixel = ppix[i] & 0xff; /* change pixel to index */ |
177 | @@ -857,7 +861,11 @@ |
178 | static void |
179 | xf86SetRootClip (ScreenPtr pScreen, Bool enable) |
180 | { |
181 | +#if XORG < 19 |
182 | WindowPtr pWin = WindowTable[pScreen->myNum]; |
183 | +#else |
184 | + WindowPtr pWin = pScreen->root; |
185 | +#endif |
186 | WindowPtr pChild; |
187 | Bool WasViewable = (Bool)(pWin->viewable); |
188 | Bool anyMarked = FALSE; |
189 | @@ -1322,3 +1330,9 @@ |
190 | { |
191 | mieqInit (); |
192 | } |
193 | + |
194 | +#if XORG > 17 |
195 | +void CloseInput(void) |
196 | +{ |
197 | +} |
198 | +#endif |
199 | diff -Naur tigervnc-1.0.1/unix/xserver/hw/vnc/xvnc.cc.orig tigervnc-1.0.1-magellan/unix/xserver/hw/vnc/xvnc.cc.orig |
200 | --- tigervnc-1.0.1/unix/xserver/hw/vnc/xvnc.cc.orig 1970-01-01 01:00:00.000000000 +0100 |
201 | +++ tigervnc-1.0.1-magellan/unix/xserver/hw/vnc/xvnc.cc.orig 2011-01-21 20:49:23.000000000 +0100 |
202 | @@ -0,0 +1,1332 @@ |
203 | +/* Copyright (c) 1993 X Consortium |
204 | + Copyright (C) 2002-2005 RealVNC Ltd. All Rights Reserved. |
205 | + Copyright (C) 2009 Pierre Ossman for Cendio AB |
206 | + |
207 | +Permission is hereby granted, free of charge, to any person obtaining |
208 | +a copy of this software and associated documentation files (the |
209 | +"Software"), to deal in the Software without restriction, including |
210 | +without limitation the rights to use, copy, modify, merge, publish, |
211 | +distribute, sublicense, and/or sell copies of the Software, and to |
212 | +permit persons to whom the Software is furnished to do so, subject to |
213 | +the following conditions: |
214 | + |
215 | +The above copyright notice and this permission notice shall be included |
216 | +in all copies or substantial portions of the Software. |
217 | + |
218 | +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
219 | +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
220 | +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. |
221 | +IN NO EVENT SHALL THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR |
222 | +OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, |
223 | +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR |
224 | +OTHER DEALINGS IN THE SOFTWARE. |
225 | + |
226 | +Except as contained in this notice, the name of the X Consortium shall |
227 | +not be used in advertising or otherwise to promote the sale, use or |
228 | +other dealings in this Software without prior written authorization |
229 | +from the X Consortium. |
230 | + |
231 | +*/ |
232 | + |
233 | +#ifdef HAVE_DIX_CONFIG_H |
234 | +#include <dix-config.h> |
235 | +#endif |
236 | + |
237 | +#include <rfb/Configuration.h> |
238 | +#include <rfb/Logger_stdio.h> |
239 | +#include <rfb/LogWriter.h> |
240 | +#include <network/TcpSocket.h> |
241 | +#include "vncExtInit.h" |
242 | +#include "xorg-version.h" |
243 | + |
244 | +extern "C" { |
245 | +#define class c_class |
246 | +#define public c_public |
247 | +#ifdef WIN32 |
248 | +#include <X11/Xwinsock.h> |
249 | +#endif |
250 | +#include <stdio.h> |
251 | +#include <X11/X.h> |
252 | +#define NEED_EVENTS |
253 | +#include <X11/Xproto.h> |
254 | +#include <X11/Xos.h> |
255 | +#include "scrnintstr.h" |
256 | +#include "servermd.h" |
257 | +#include "fb.h" |
258 | +#include "mi.h" |
259 | +#include "mibstore.h" |
260 | +#include "colormapst.h" |
261 | +#include "gcstruct.h" |
262 | +#include "input.h" |
263 | +#include "mipointer.h" |
264 | +#define new New |
265 | +#include "micmap.h" |
266 | +#undef new |
267 | +#include <sys/types.h> |
268 | +#include <sys/stat.h> |
269 | +#include <errno.h> |
270 | +#ifndef WIN32 |
271 | +#include <sys/param.h> |
272 | +#endif |
273 | +#include <X11/XWDFile.h> |
274 | +#ifdef HAS_SHM |
275 | +#include <sys/ipc.h> |
276 | +#include <sys/shm.h> |
277 | +#endif /* HAS_SHM */ |
278 | +#include "dix.h" |
279 | +#include "miline.h" |
280 | +#include "inputstr.h" |
281 | +#ifdef RANDR |
282 | +#include "randrstr.h" |
283 | +#endif /* RANDR */ |
284 | +#include <X11/keysym.h> |
285 | + extern char buildtime[]; |
286 | +#if XORG >= 17 |
287 | +#undef VENDOR_RELEASE |
288 | +#undef VENDOR_STRING |
289 | +#include "version-config.h" |
290 | +#include "site.h" |
291 | +#endif |
292 | +#undef class |
293 | +#undef public |
294 | +} |
295 | + |
296 | +#define XVNCVERSION "TigerVNC 1.0.1" |
297 | +#define XVNCCOPYRIGHT ("Copyright (C) 2002-2005 RealVNC Ltd.\n" \ |
298 | + "Copyright (C) 2000-2006 Constantin Kaplinsky\n" \ |
299 | + "Copyright (C) 2004-2009 Peter Astrand for Cendio AB\n" \ |
300 | + "See http://www.tigervnc.org for information on TigerVNC.\n") |
301 | + |
302 | + |
303 | +extern char *display; |
304 | +extern int monitorResolution; |
305 | + |
306 | +#define VFB_DEFAULT_WIDTH 1024 |
307 | +#define VFB_DEFAULT_HEIGHT 768 |
308 | +#define VFB_DEFAULT_DEPTH 24 |
309 | +#define VFB_DEFAULT_WHITEPIXEL 0xffffffff |
310 | +#define VFB_DEFAULT_BLACKPIXEL 0 |
311 | +#define VFB_DEFAULT_LINEBIAS 0 |
312 | +#define XWD_WINDOW_NAME_LEN 60 |
313 | + |
314 | +typedef struct |
315 | +{ |
316 | + int width; |
317 | + int height; |
318 | + |
319 | + int depth; |
320 | + |
321 | + /* Computed when allocated */ |
322 | + |
323 | + int paddedBytesWidth; |
324 | + int paddedWidth; |
325 | + |
326 | + int bitsPerPixel; |
327 | + |
328 | + /* Private */ |
329 | + |
330 | + int sizeInBytes; |
331 | + |
332 | + void *pfbMemory; |
333 | + |
334 | +#ifdef HAS_SHM |
335 | + int shmid; |
336 | +#endif |
337 | +} vfbFramebufferInfo, *vfbFramebufferInfoPtr; |
338 | + |
339 | +typedef struct |
340 | +{ |
341 | + int scrnum; |
342 | + |
343 | + Pixel blackPixel; |
344 | + Pixel whitePixel; |
345 | + |
346 | + unsigned int lineBias; |
347 | + |
348 | + CloseScreenProcPtr closeScreen; |
349 | + |
350 | + vfbFramebufferInfo fb; |
351 | + |
352 | + Bool pixelFormatDefined; |
353 | + Bool rgbNotBgr; |
354 | + int redBits, greenBits, blueBits; |
355 | +} vfbScreenInfo, *vfbScreenInfoPtr; |
356 | + |
357 | +static int vfbNumScreens; |
358 | +static vfbScreenInfo vfbScreens[MAXSCREENS]; |
359 | +static Bool vfbPixmapDepths[33]; |
360 | +typedef enum { NORMAL_MEMORY_FB, SHARED_MEMORY_FB } fbMemType; |
361 | +static fbMemType fbmemtype = NORMAL_MEMORY_FB; |
362 | +static int lastScreen = -1; |
363 | +static Bool Render = TRUE; |
364 | + |
365 | +static bool displaySpecified = false; |
366 | +static bool wellKnownSocketsCreated = false; |
367 | +static char displayNumStr[16]; |
368 | + |
369 | + |
370 | +static void |
371 | +vfbInitializePixmapDepths(void) |
372 | +{ |
373 | + int i; |
374 | + vfbPixmapDepths[1] = TRUE; /* always need bitmaps */ |
375 | + for (i = 2; i <= 32; i++) |
376 | + vfbPixmapDepths[i] = FALSE; |
377 | +} |
378 | + |
379 | +static void |
380 | +vfbInitializeDefaultScreens(void) |
381 | +{ |
382 | + int i; |
383 | + |
384 | + for (i = 0; i < MAXSCREENS; i++) |
385 | + { |
386 | + vfbScreens[i].scrnum = i; |
387 | + vfbScreens[i].blackPixel = VFB_DEFAULT_BLACKPIXEL; |
388 | + vfbScreens[i].whitePixel = VFB_DEFAULT_WHITEPIXEL; |
389 | + vfbScreens[i].lineBias = VFB_DEFAULT_LINEBIAS; |
390 | + vfbScreens[i].fb.width = VFB_DEFAULT_WIDTH; |
391 | + vfbScreens[i].fb.height = VFB_DEFAULT_HEIGHT; |
392 | + vfbScreens[i].fb.pfbMemory = NULL; |
393 | + vfbScreens[i].fb.depth = VFB_DEFAULT_DEPTH; |
394 | + vfbScreens[i].pixelFormatDefined = FALSE; |
395 | + } |
396 | + vfbNumScreens = 1; |
397 | +} |
398 | + |
399 | +static int |
400 | +vfbBitsPerPixel(int depth) |
401 | +{ |
402 | + if (depth == 1) return 1; |
403 | + else if (depth <= 8) return 8; |
404 | + else if (depth <= 16) return 16; |
405 | + else return 32; |
406 | +} |
407 | + |
408 | +static void vfbFreeFramebufferMemory(vfbFramebufferInfoPtr pfb); |
409 | + |
410 | +extern "C" { |
411 | + |
412 | +void ddxGiveUp() |
413 | +{ |
414 | + int i; |
415 | + |
416 | + /* clean up the framebuffers */ |
417 | + for (i = 0; i < vfbNumScreens; i++) |
418 | + vfbFreeFramebufferMemory(&vfbScreens[i].fb); |
419 | +} |
420 | + |
421 | +void |
422 | +AbortDDX() |
423 | +{ |
424 | + ddxGiveUp(); |
425 | +} |
426 | + |
427 | +#ifdef __DARWIN__ |
428 | +void |
429 | +DarwinHandleGUI(int argc, char *argv[]) |
430 | +{ |
431 | +} |
432 | + |
433 | +void GlxExtensionInit(); |
434 | +void GlxWrapInitVisuals(void *procPtr); |
435 | + |
436 | +void |
437 | +DarwinGlxExtensionInit() |
438 | +{ |
439 | + GlxExtensionInit(); |
440 | +} |
441 | + |
442 | +void |
443 | +DarwinGlxWrapInitVisuals( |
444 | + void *procPtr) |
445 | +{ |
446 | + GlxWrapInitVisuals(procPtr); |
447 | +} |
448 | +#endif |
449 | + |
450 | +void |
451 | +OsVendorInit() |
452 | +{ |
453 | +} |
454 | + |
455 | +void |
456 | +OsVendorFatalError() |
457 | +{ |
458 | +} |
459 | + |
460 | +void ddxBeforeReset(void) |
461 | +{ |
462 | + return; |
463 | +} |
464 | + |
465 | +void |
466 | +ddxUseMsg() |
467 | +{ |
468 | + ErrorF("\nXvnc %s - built %s\n%s", XVNCVERSION, buildtime, XVNCCOPYRIGHT); |
469 | + ErrorF("Underlying X server release %d, %s\n\n", VENDOR_RELEASE, |
470 | + VENDOR_STRING); |
471 | + ErrorF("-screen scrn WxHxD set screen's width, height, depth\n"); |
472 | + ErrorF("-pixdepths list-of-int support given pixmap depths\n"); |
473 | +#ifdef RENDER |
474 | + ErrorF("+/-render turn on/off RENDER extension support" |
475 | + "(default on)\n"); |
476 | +#endif |
477 | + ErrorF("-linebias n adjust thin line pixelization\n"); |
478 | + ErrorF("-blackpixel n pixel value for black\n"); |
479 | + ErrorF("-whitepixel n pixel value for white\n"); |
480 | + |
481 | +#ifdef HAS_SHM |
482 | + ErrorF("-shmem put framebuffers in shared memory\n"); |
483 | +#endif |
484 | + |
485 | + ErrorF("-geometry WxH set screen 0's width, height\n"); |
486 | + ErrorF("-depth D set screen 0's depth\n"); |
487 | + ErrorF("-pixelformat fmt set pixel format (rgbNNN or bgrNNN)\n"); |
488 | + ErrorF("-inetd has been launched from inetd\n"); |
489 | + ErrorF("\nVNC parameters:\n"); |
490 | + |
491 | + fprintf(stderr,"\n" |
492 | + "Parameters can be turned on with -<param> or off with -<param>=0\n" |
493 | + "Parameters which take a value can be specified as " |
494 | + "-<param> <value>\n" |
495 | + "Other valid forms are <param>=<value> -<param>=<value> " |
496 | + "--<param>=<value>\n" |
497 | + "Parameter names are case-insensitive. The parameters are:\n\n"); |
498 | + rfb::Configuration::listParams(79, 14); |
499 | + } |
500 | +} |
501 | + |
502 | +/* ddxInitGlobals - called by |InitGlobals| from os/util.c */ |
503 | +void ddxInitGlobals(void) |
504 | +{ |
505 | +} |
506 | + |
507 | +static |
508 | +bool displayNumFree(int num) |
509 | +{ |
510 | + try { |
511 | + network::TcpListener l(6000+num); |
512 | + } catch (rdr::Exception& e) { |
513 | + return false; |
514 | + } |
515 | + char file[256]; |
516 | + sprintf(file, "/tmp/.X%d-lock", num); |
517 | + if (access(file, F_OK) == 0) return false; |
518 | + sprintf(file, "/tmp/.X11-unix/X%d", num); |
519 | + if (access(file, F_OK) == 0) return false; |
520 | + sprintf(file, "/usr/spool/sockets/X11/%d", num); |
521 | + if (access(file, F_OK) == 0) return false; |
522 | + return true; |
523 | +} |
524 | + |
525 | +int |
526 | +ddxProcessArgument(int argc, char *argv[], int i) |
527 | +{ |
528 | + static Bool firstTime = TRUE; |
529 | + |
530 | + if (firstTime) |
531 | + { |
532 | + vfbInitializeDefaultScreens(); |
533 | + vfbInitializePixmapDepths(); |
534 | + firstTime = FALSE; |
535 | + rfb::initStdIOLoggers(); |
536 | + rfb::LogWriter::setLogParams("*:stderr:30"); |
537 | + } |
538 | + |
539 | + if (argv[i][0] == ':') |
540 | + displaySpecified = true; |
541 | + |
542 | + if (strcmp (argv[i], "-screen") == 0) /* -screen n WxHxD */ |
543 | + { |
544 | + int screenNum; |
545 | + if (i + 2 >= argc) UseMsg(); |
546 | + screenNum = atoi(argv[i+1]); |
547 | + if (screenNum < 0 || screenNum >= MAXSCREENS) |
548 | + { |
549 | + ErrorF("Invalid screen number %d\n", screenNum); |
550 | + UseMsg(); |
551 | + } |
552 | + if (3 != sscanf(argv[i+2], "%dx%dx%d", |
553 | + &vfbScreens[screenNum].fb.width, |
554 | + &vfbScreens[screenNum].fb.height, |
555 | + &vfbScreens[screenNum].fb.depth)) |
556 | + { |
557 | + ErrorF("Invalid screen configuration %s\n", argv[i+2]); |
558 | + UseMsg(); |
559 | + } |
560 | + |
561 | + if (screenNum >= vfbNumScreens) |
562 | + vfbNumScreens = screenNum + 1; |
563 | + lastScreen = screenNum; |
564 | + return 3; |
565 | + } |
566 | + |
567 | + if (strcmp (argv[i], "-pixdepths") == 0) /* -pixdepths list-of-depth */ |
568 | + { |
569 | + int depth, ret = 1; |
570 | + |
571 | + if (++i >= argc) UseMsg(); |
572 | + while ((i < argc) && (depth = atoi(argv[i++])) != 0) |
573 | + { |
574 | + if (depth < 0 || depth > 32) |
575 | + { |
576 | + ErrorF("Invalid pixmap depth %d\n", depth); |
577 | + UseMsg(); |
578 | + } |
579 | + vfbPixmapDepths[depth] = TRUE; |
580 | + ret++; |
581 | + } |
582 | + return ret; |
583 | + } |
584 | + |
585 | + if (strcmp (argv[i], "+render") == 0) /* +render */ |
586 | + { |
587 | + Render = TRUE; |
588 | + return 1; |
589 | + } |
590 | + |
591 | + if (strcmp (argv[i], "-render") == 0) /* -render */ |
592 | + { |
593 | + Render = FALSE; |
594 | + return 1; |
595 | + } |
596 | + |
597 | + if (strcmp (argv[i], "-blackpixel") == 0) /* -blackpixel n */ |
598 | + { |
599 | + Pixel pix; |
600 | + if (++i >= argc) UseMsg(); |
601 | + pix = atoi(argv[i]); |
602 | + if (-1 == lastScreen) |
603 | + { |
604 | + int i; |
605 | + for (i = 0; i < MAXSCREENS; i++) |
606 | + { |
607 | + vfbScreens[i].blackPixel = pix; |
608 | + } |
609 | + } |
610 | + else |
611 | + { |
612 | + vfbScreens[lastScreen].blackPixel = pix; |
613 | + } |
614 | + return 2; |
615 | + } |
616 | + |
617 | + if (strcmp (argv[i], "-whitepixel") == 0) /* -whitepixel n */ |
618 | + { |
619 | + Pixel pix; |
620 | + if (++i >= argc) UseMsg(); |
621 | + pix = atoi(argv[i]); |
622 | + if (-1 == lastScreen) |
623 | + { |
624 | + int i; |
625 | + for (i = 0; i < MAXSCREENS; i++) |
626 | + { |
627 | + vfbScreens[i].whitePixel = pix; |
628 | + } |
629 | + } |
630 | + else |
631 | + { |
632 | + vfbScreens[lastScreen].whitePixel = pix; |
633 | + } |
634 | + return 2; |
635 | + } |
636 | + |
637 | + if (strcmp (argv[i], "-linebias") == 0) /* -linebias n */ |
638 | + { |
639 | + unsigned int linebias; |
640 | + if (++i >= argc) UseMsg(); |
641 | + linebias = atoi(argv[i]); |
642 | + if (-1 == lastScreen) |
643 | + { |
644 | + int i; |
645 | + for (i = 0; i < MAXSCREENS; i++) |
646 | + { |
647 | + vfbScreens[i].lineBias = linebias; |
648 | + } |
649 | + } |
650 | + else |
651 | + { |
652 | + vfbScreens[lastScreen].lineBias = linebias; |
653 | + } |
654 | + return 2; |
655 | + } |
656 | + |
657 | +#ifdef HAS_SHM |
658 | + if (strcmp (argv[i], "-shmem") == 0) /* -shmem */ |
659 | + { |
660 | + fbmemtype = SHARED_MEMORY_FB; |
661 | + return 1; |
662 | + } |
663 | +#endif |
664 | + |
665 | + if (strcmp(argv[i], "-geometry") == 0) |
666 | + { |
667 | + if (++i >= argc) UseMsg(); |
668 | + if (sscanf(argv[i],"%dx%d",&vfbScreens[0].fb.width, |
669 | + &vfbScreens[0].fb.height) != 2) { |
670 | + ErrorF("Invalid geometry %s\n", argv[i]); |
671 | + UseMsg(); |
672 | + } |
673 | + return 2; |
674 | + } |
675 | + |
676 | + if (strcmp(argv[i], "-depth") == 0) |
677 | + { |
678 | + if (++i >= argc) UseMsg(); |
679 | + vfbScreens[0].fb.depth = atoi(argv[i]); |
680 | + return 2; |
681 | + } |
682 | + |
683 | + if (strcmp(argv[i], "-pixelformat") == 0) |
684 | + { |
685 | + char rgbbgr[4]; |
686 | + int bits1, bits2, bits3; |
687 | + if (++i >= argc) UseMsg(); |
688 | + if (sscanf(argv[i], "%3s%1d%1d%1d", rgbbgr,&bits1,&bits2,&bits3) < 4) { |
689 | + ErrorF("Invalid pixel format %s\n", argv[i]); |
690 | + UseMsg(); |
691 | + } |
692 | + |
693 | +#define SET_PIXEL_FORMAT(vfbScreen) \ |
694 | + (vfbScreen).pixelFormatDefined = TRUE; \ |
695 | + (vfbScreen).fb.depth = bits1 + bits2 + bits3; \ |
696 | + (vfbScreen).greenBits = bits2; \ |
697 | + if (strcasecmp(rgbbgr, "bgr") == 0) { \ |
698 | + (vfbScreen).rgbNotBgr = FALSE; \ |
699 | + (vfbScreen).redBits = bits3; \ |
700 | + (vfbScreen).blueBits = bits1; \ |
701 | + } else if (strcasecmp(rgbbgr, "rgb") == 0) { \ |
702 | + (vfbScreen).rgbNotBgr = TRUE; \ |
703 | + (vfbScreen).redBits = bits1; \ |
704 | + (vfbScreen).blueBits = bits3; \ |
705 | + } else { \ |
706 | + ErrorF("Invalid pixel format %s\n", argv[i]); \ |
707 | + UseMsg(); \ |
708 | + } |
709 | + |
710 | + if (-1 == lastScreen) |
711 | + { |
712 | + int i; |
713 | + for (i = 0; i < MAXSCREENS; i++) |
714 | + { |
715 | + SET_PIXEL_FORMAT(vfbScreens[i]); |
716 | + } |
717 | + } |
718 | + else |
719 | + { |
720 | + SET_PIXEL_FORMAT(vfbScreens[lastScreen]); |
721 | + } |
722 | + |
723 | + return 2; |
724 | + } |
725 | + |
726 | + if (strcmp(argv[i], "-inetd") == 0) |
727 | + { |
728 | + dup2(0,3); |
729 | + vncInetdSock = 3; |
730 | + close(2); |
731 | + |
732 | + if (!displaySpecified) { |
733 | + int port = network::TcpSocket::getSockPort(vncInetdSock); |
734 | + int displayNum = port - 5900; |
735 | + if (displayNum < 0 || displayNum > 99 || !displayNumFree(displayNum)) { |
736 | + for (displayNum = 1; displayNum < 100; displayNum++) |
737 | + if (displayNumFree(displayNum)) break; |
738 | + |
739 | + if (displayNum == 100) |
740 | + FatalError("Xvnc error: no free display number for -inetd"); |
741 | + } |
742 | + |
743 | + display = displayNumStr; |
744 | + sprintf(displayNumStr, "%d", displayNum); |
745 | + } |
746 | + |
747 | + return 1; |
748 | + } |
749 | + |
750 | + if (rfb::Configuration::setParam(argv[i])) |
751 | + return 1; |
752 | + |
753 | + if (argv[i][0] == '-' && i+1 < argc) { |
754 | + if (rfb::Configuration::setParam(&argv[i][1], argv[i+1])) |
755 | + return 2; |
756 | + } |
757 | + |
758 | + return 0; |
759 | +} |
760 | + |
761 | +#ifdef DDXTIME /* from ServerOSDefines */ |
762 | +CARD32 |
763 | +GetTimeInMillis() |
764 | +{ |
765 | + struct timeval tp; |
766 | + |
767 | + X_GETTIMEOFDAY(&tp); |
768 | + return(tp.tv_sec * 1000) + (tp.tv_usec / 1000); |
769 | +} |
770 | +#endif |
771 | + |
772 | +static ColormapPtr InstalledMaps[MAXSCREENS]; |
773 | + |
774 | +static int |
775 | +vfbListInstalledColormaps(ScreenPtr pScreen, Colormap *pmaps) |
776 | +{ |
777 | + /* By the time we are processing requests, we can guarantee that there |
778 | + * is always a colormap installed */ |
779 | + *pmaps = InstalledMaps[pScreen->myNum]->mid; |
780 | + return (1); |
781 | +} |
782 | + |
783 | + |
784 | +static void |
785 | +vfbInstallColormap(ColormapPtr pmap) |
786 | +{ |
787 | + int index = pmap->pScreen->myNum; |
788 | + ColormapPtr oldpmap = InstalledMaps[index]; |
789 | + |
790 | + if (pmap != oldpmap) |
791 | + { |
792 | + int entries; |
793 | + VisualPtr pVisual; |
794 | + Pixel * ppix; |
795 | + xrgb * prgb; |
796 | + xColorItem *defs; |
797 | + int i; |
798 | + |
799 | + if(oldpmap != (ColormapPtr)None) |
800 | + WalkTree(pmap->pScreen, TellLostMap, (char *)&oldpmap->mid); |
801 | + /* Install pmap */ |
802 | + InstalledMaps[index] = pmap; |
803 | + WalkTree(pmap->pScreen, TellGainedMap, (char *)&pmap->mid); |
804 | + |
805 | + entries = pmap->pVisual->ColormapEntries; |
806 | + pVisual = pmap->pVisual; |
807 | + |
808 | + ppix = (Pixel *)xalloc(entries * sizeof(Pixel)); |
809 | + prgb = (xrgb *)xalloc(entries * sizeof(xrgb)); |
810 | + defs = (xColorItem *)xalloc(entries * sizeof(xColorItem)); |
811 | + |
812 | + for (i = 0; i < entries; i++) ppix[i] = i; |
813 | + /* XXX truecolor */ |
814 | +#if XORG < 19 |
815 | + QueryColors(pmap, entries, ppix, prgb); |
816 | +#else |
817 | + QueryColors(pmap, entries, ppix, prgb, serverClient); |
818 | +#endif |
819 | + |
820 | + for (i = 0; i < entries; i++) { /* convert xrgbs to xColorItems */ |
821 | + defs[i].pixel = ppix[i] & 0xff; /* change pixel to index */ |
822 | + defs[i].red = prgb[i].red; |
823 | + defs[i].green = prgb[i].green; |
824 | + defs[i].blue = prgb[i].blue; |
825 | + defs[i].flags = DoRed|DoGreen|DoBlue; |
826 | + } |
827 | + (*pmap->pScreen->StoreColors)(pmap, entries, defs); |
828 | + |
829 | + xfree(ppix); |
830 | + xfree(prgb); |
831 | + xfree(defs); |
832 | + } |
833 | +} |
834 | + |
835 | +static void |
836 | +vfbUninstallColormap(ColormapPtr pmap) |
837 | +{ |
838 | + ColormapPtr curpmap = InstalledMaps[pmap->pScreen->myNum]; |
839 | + |
840 | + if(pmap == curpmap) |
841 | + { |
842 | + if (pmap->mid != pmap->pScreen->defColormap) |
843 | + { |
844 | + curpmap = (ColormapPtr) LookupIDByType(pmap->pScreen->defColormap, |
845 | + RT_COLORMAP); |
846 | + (*pmap->pScreen->InstallColormap)(curpmap); |
847 | + } |
848 | + } |
849 | +} |
850 | + |
851 | +static Bool |
852 | +vfbSaveScreen(ScreenPtr pScreen, int on) |
853 | +{ |
854 | + return TRUE; |
855 | +} |
856 | + |
857 | +#ifdef HAS_SHM |
858 | +static void |
859 | +vfbAllocateSharedMemoryFramebuffer(vfbFramebufferInfoPtr pfb) |
860 | +{ |
861 | + /* create the shared memory segment */ |
862 | + |
863 | + pfb->shmid = shmget(IPC_PRIVATE, pfb->sizeInBytes, IPC_CREAT|0777); |
864 | + if (pfb->shmid < 0) { |
865 | + perror("shmget"); |
866 | + ErrorF("shmget %d bytes failed, errno %d", pfb->sizeInBytes, errno); |
867 | + return; |
868 | + } |
869 | + |
870 | + /* try to attach it */ |
871 | + |
872 | + pfb->pfbMemory = shmat(pfb->shmid, 0, 0); |
873 | + if (-1 == (long)pfb->pfbMemory) { |
874 | + perror("shmat"); |
875 | + ErrorF("shmat failed, errno %d", errno); |
876 | + pfb->pfbMemory = NULL; |
877 | + return; |
878 | + } |
879 | +} |
880 | +#endif /* HAS_SHM */ |
881 | + |
882 | + |
883 | +static void * |
884 | +vfbAllocateFramebufferMemory(vfbFramebufferInfoPtr pfb) |
885 | +{ |
886 | + if (pfb->pfbMemory != NULL) |
887 | + return pfb->pfbMemory; /* already done */ |
888 | + |
889 | + /* Compute memory layout */ |
890 | + pfb->paddedBytesWidth = PixmapBytePad(pfb->width, pfb->depth); |
891 | + pfb->bitsPerPixel = vfbBitsPerPixel(pfb->depth); |
892 | + pfb->paddedWidth = pfb->paddedBytesWidth * 8 / pfb->bitsPerPixel; |
893 | + pfb->sizeInBytes = pfb->paddedBytesWidth * pfb->height; |
894 | + |
895 | + /* And allocate buffer */ |
896 | + switch (fbmemtype) { |
897 | +#ifdef HAS_SHM |
898 | + case SHARED_MEMORY_FB: |
899 | + vfbAllocateSharedMemoryFramebuffer(pfb); |
900 | + break; |
901 | +#else |
902 | + case SHARED_MEMORY_FB: |
903 | + break; |
904 | +#endif |
905 | + case NORMAL_MEMORY_FB: |
906 | + pfb->pfbMemory = Xalloc(pfb->sizeInBytes); |
907 | + break; |
908 | + } |
909 | + |
910 | + /* This will be NULL if any of the above failed */ |
911 | + return pfb->pfbMemory; |
912 | +} |
913 | + |
914 | +static void |
915 | +vfbFreeFramebufferMemory(vfbFramebufferInfoPtr pfb) |
916 | +{ |
917 | + if ((pfb == NULL) || (pfb->pfbMemory == NULL)) |
918 | + return; |
919 | + |
920 | + switch (fbmemtype) { |
921 | +#ifdef HAS_SHM |
922 | + case SHARED_MEMORY_FB: |
923 | + if (-1 == shmdt(pfb->pfbMemory)) { |
924 | + perror("shmdt"); |
925 | + ErrorF("shmdt failed, errno %d", errno); |
926 | + } |
927 | + break; |
928 | +#else /* HAS_SHM */ |
929 | + case SHARED_MEMORY_FB: |
930 | + break; |
931 | +#endif /* HAS_SHM */ |
932 | + case NORMAL_MEMORY_FB: |
933 | + Xfree(pfb->pfbMemory); |
934 | + break; |
935 | + } |
936 | + |
937 | + pfb->pfbMemory = NULL; |
938 | +} |
939 | + |
940 | +static Bool |
941 | +vfbCursorOffScreen (ScreenPtr *ppScreen, int *x, int *y) |
942 | +{ |
943 | + return FALSE; |
944 | +} |
945 | + |
946 | +static void |
947 | +vfbCrossScreen (ScreenPtr pScreen, Bool entering) |
948 | +{ |
949 | +} |
950 | + |
951 | +static Bool vfbRealizeCursor( |
952 | +#if XORG >= 16 |
953 | + DeviceIntPtr pDev, |
954 | +#endif |
955 | + ScreenPtr pScreen, CursorPtr pCursor) { |
956 | + return TRUE; |
957 | +} |
958 | + |
959 | +static Bool vfbUnrealizeCursor( |
960 | +#if XORG >= 16 |
961 | + DeviceIntPtr pDev, |
962 | +#endif |
963 | + ScreenPtr pScreen, CursorPtr pCursor) { |
964 | + return TRUE; |
965 | +} |
966 | + |
967 | +static void vfbSetCursor( |
968 | +#if XORG >= 16 |
969 | + DeviceIntPtr pDev, |
970 | +#endif |
971 | + ScreenPtr pScreen, CursorPtr pCursor, int x, int y) |
972 | +{ |
973 | +} |
974 | + |
975 | +static void vfbMoveCursor( |
976 | +#if XORG >= 16 |
977 | + DeviceIntPtr pDev, |
978 | +#endif |
979 | + ScreenPtr pScreen, int x, int y) |
980 | +{ |
981 | +} |
982 | + |
983 | +#if XORG >= 16 |
984 | +static Bool |
985 | +vfbDeviceCursorInitialize(DeviceIntPtr pDev, ScreenPtr pScreen) |
986 | +{ |
987 | + return TRUE; |
988 | +} |
989 | + |
990 | +static void |
991 | +vfbDeviceCursorCleanup(DeviceIntPtr pDev, ScreenPtr pScreen) |
992 | +{ |
993 | +} |
994 | +#endif |
995 | + |
996 | +static miPointerSpriteFuncRec vfbPointerSpriteFuncs = { |
997 | + vfbRealizeCursor, |
998 | + vfbUnrealizeCursor, |
999 | + vfbSetCursor, |
1000 | + vfbMoveCursor |
1001 | +#if XORG >= 16 |
1002 | + , vfbDeviceCursorInitialize, |
1003 | + vfbDeviceCursorCleanup |
1004 | +#endif |
1005 | +}; |
1006 | + |
1007 | +static miPointerScreenFuncRec vfbPointerCursorFuncs = { |
1008 | + vfbCursorOffScreen, |
1009 | + vfbCrossScreen, |
1010 | + miPointerWarpCursor |
1011 | +}; |
1012 | + |
1013 | +#ifdef RANDR |
1014 | + |
1015 | +static Bool vncRandRGetInfo (ScreenPtr pScreen, Rotation *rotations) |
1016 | +{ |
1017 | + vfbScreenInfoPtr pvfb = &vfbScreens[pScreen->myNum]; |
1018 | + Bool ret, gotCurrent = FALSE; |
1019 | + int i; |
1020 | + |
1021 | + const int widths[] = { 1920, 1920, 1600, 1680, 1400, 1360, 1280, 1280, 1280, 1280, 1024, 800, 640 }; |
1022 | + const int heights[] = { 1200, 1080, 1200, 1050, 1050, 768, 1024, 960, 800, 720, 768, 600, 480 }; |
1023 | + |
1024 | + for (i = 0;i < sizeof(widths)/sizeof(*widths);i++) { |
1025 | + RRScreenSizePtr pSize; |
1026 | + |
1027 | + pSize = RRRegisterSize(pScreen, widths[i], heights[i], |
1028 | + pScreen->mmWidth, pScreen->mmHeight); |
1029 | + if (!pSize) |
1030 | + return FALSE; |
1031 | + |
1032 | + ret = RRRegisterRate(pScreen, pSize, 60); |
1033 | + if (!ret) |
1034 | + return FALSE; |
1035 | + |
1036 | + if ((widths[i] == pScreen->width) && (heights[i] == pScreen->height)) { |
1037 | + RRSetCurrentConfig(pScreen, RR_Rotate_0, 60, pSize); |
1038 | + gotCurrent = TRUE; |
1039 | + } |
1040 | + } |
1041 | + |
1042 | + if (!gotCurrent) { |
1043 | + RRScreenSizePtr pSize; |
1044 | + |
1045 | + pSize = RRRegisterSize(pScreen, pScreen->width, pScreen->height, |
1046 | + pScreen->mmWidth, pScreen->mmHeight); |
1047 | + if (!pSize) |
1048 | + return FALSE; |
1049 | + |
1050 | + RRRegisterRate(pScreen, pSize, 60); |
1051 | + |
1052 | + RRSetCurrentConfig(pScreen, RR_Rotate_0, 60, pSize); |
1053 | + } |
1054 | + |
1055 | + *rotations = RR_Rotate_0; |
1056 | + |
1057 | + return TRUE; |
1058 | +} |
1059 | + |
1060 | +/* from hw/xfree86/common/xf86Helper.c */ |
1061 | + |
1062 | +#include "mivalidate.h" |
1063 | +static void |
1064 | +xf86SetRootClip (ScreenPtr pScreen, Bool enable) |
1065 | +{ |
1066 | +#if XORG < 19 |
1067 | + WindowPtr pWin = WindowTable[pScreen->myNum]; |
1068 | +#else |
1069 | + WindowPtr pWin = pScreen->root; |
1070 | +#endif |
1071 | + WindowPtr pChild; |
1072 | + Bool WasViewable = (Bool)(pWin->viewable); |
1073 | + Bool anyMarked = FALSE; |
1074 | + RegionPtr pOldClip = NULL, bsExposed; |
1075 | +#ifdef DO_SAVE_UNDERS |
1076 | + Bool dosave = FALSE; |
1077 | +#endif |
1078 | + WindowPtr pLayerWin; |
1079 | + BoxRec box; |
1080 | + |
1081 | + if (WasViewable) |
1082 | + { |
1083 | + for (pChild = pWin->firstChild; pChild; pChild = pChild->nextSib) |
1084 | + { |
1085 | + (void) (*pScreen->MarkOverlappedWindows)(pChild, |
1086 | + pChild, |
1087 | + &pLayerWin); |
1088 | + } |
1089 | + (*pScreen->MarkWindow) (pWin); |
1090 | + anyMarked = TRUE; |
1091 | + if (pWin->valdata) |
1092 | + { |
1093 | + if (HasBorder (pWin)) |
1094 | + { |
1095 | + RegionPtr borderVisible; |
1096 | + |
1097 | + borderVisible = REGION_CREATE(pScreen, NullBox, 1); |
1098 | + REGION_SUBTRACT(pScreen, borderVisible, |
1099 | + &pWin->borderClip, &pWin->winSize); |
1100 | + pWin->valdata->before.borderVisible = borderVisible; |
1101 | + } |
1102 | + pWin->valdata->before.resized = TRUE; |
1103 | + } |
1104 | + } |
1105 | + |
1106 | + /* |
1107 | + * Use REGION_BREAK to avoid optimizations in ValidateTree |
1108 | + * that assume the root borderClip can't change well, normally |
1109 | + * it doesn't...) |
1110 | + */ |
1111 | + if (enable) |
1112 | + { |
1113 | + box.x1 = 0; |
1114 | + box.y1 = 0; |
1115 | + box.x2 = pScreen->width; |
1116 | + box.y2 = pScreen->height; |
1117 | + REGION_INIT (pScreen, &pWin->winSize, &box, 1); |
1118 | + REGION_INIT (pScreen, &pWin->borderSize, &box, 1); |
1119 | + if (WasViewable) |
1120 | + REGION_RESET(pScreen, &pWin->borderClip, &box); |
1121 | + pWin->drawable.width = pScreen->width; |
1122 | + pWin->drawable.height = pScreen->height; |
1123 | + REGION_BREAK (pWin->drawable.pScreen, &pWin->clipList); |
1124 | + } |
1125 | + else |
1126 | + { |
1127 | + REGION_EMPTY(pScreen, &pWin->borderClip); |
1128 | + REGION_BREAK (pWin->drawable.pScreen, &pWin->clipList); |
1129 | + } |
1130 | + |
1131 | + ResizeChildrenWinSize (pWin, 0, 0, 0, 0); |
1132 | + |
1133 | + if (WasViewable) |
1134 | + { |
1135 | + if (pWin->backStorage) |
1136 | + { |
1137 | + pOldClip = REGION_CREATE(pScreen, NullBox, 1); |
1138 | + REGION_COPY(pScreen, pOldClip, &pWin->clipList); |
1139 | + } |
1140 | + |
1141 | + if (pWin->firstChild) |
1142 | + { |
1143 | + anyMarked |= (*pScreen->MarkOverlappedWindows)(pWin->firstChild, |
1144 | + pWin->firstChild, |
1145 | + (WindowPtr *)NULL); |
1146 | + } |
1147 | + else |
1148 | + { |
1149 | + (*pScreen->MarkWindow) (pWin); |
1150 | + anyMarked = TRUE; |
1151 | + } |
1152 | + |
1153 | +#ifdef DO_SAVE_UNDERS |
1154 | + if (DO_SAVE_UNDERS(pWin)) |
1155 | + { |
1156 | + dosave = (*pScreen->ChangeSaveUnder)(pLayerWin, pLayerWin); |
1157 | + } |
1158 | +#endif /* DO_SAVE_UNDERS */ |
1159 | + |
1160 | + if (anyMarked) |
1161 | + (*pScreen->ValidateTree)(pWin, NullWindow, VTOther); |
1162 | + } |
1163 | + |
1164 | + if (pWin->backStorage && |
1165 | + ((pWin->backingStore == Always) || WasViewable)) |
1166 | + { |
1167 | + if (!WasViewable) |
1168 | + pOldClip = &pWin->clipList; /* a convenient empty region */ |
1169 | + bsExposed = (*pScreen->TranslateBackingStore) |
1170 | + (pWin, 0, 0, pOldClip, |
1171 | + pWin->drawable.x, pWin->drawable.y); |
1172 | + if (WasViewable) |
1173 | + REGION_DESTROY(pScreen, pOldClip); |
1174 | + if (bsExposed) |
1175 | + { |
1176 | + RegionPtr valExposed = NullRegion; |
1177 | + |
1178 | + if (pWin->valdata) |
1179 | + valExposed = &pWin->valdata->after.exposed; |
1180 | + (*pScreen->WindowExposures) (pWin, valExposed, bsExposed); |
1181 | + if (valExposed) |
1182 | + REGION_EMPTY(pScreen, valExposed); |
1183 | + REGION_DESTROY(pScreen, bsExposed); |
1184 | + } |
1185 | + } |
1186 | + if (WasViewable) |
1187 | + { |
1188 | + if (anyMarked) |
1189 | + (*pScreen->HandleExposures)(pWin); |
1190 | +#ifdef DO_SAVE_UNDERS |
1191 | + if (dosave) |
1192 | + (*pScreen->PostChangeSaveUnder)(pLayerWin, pLayerWin); |
1193 | +#endif /* DO_SAVE_UNDERS */ |
1194 | + if (anyMarked && pScreen->PostValidateTree) |
1195 | + (*pScreen->PostValidateTree)(pWin, NullWindow, VTOther); |
1196 | + } |
1197 | + if (pWin->realized) |
1198 | + WindowsRestructured (); |
1199 | + FlushAllOutput (); |
1200 | +} |
1201 | + |
1202 | +static Bool vncRandRSetConfig (ScreenPtr pScreen, Rotation rotation, |
1203 | + int rate, RRScreenSizePtr pSize) |
1204 | +{ |
1205 | + vfbScreenInfoPtr pvfb = &vfbScreens[pScreen->myNum]; |
1206 | + vfbFramebufferInfo fb; |
1207 | + PixmapPtr rootPixmap = pScreen->GetScreenPixmap(pScreen); |
1208 | + void *pbits; |
1209 | + Bool ret; |
1210 | + int oldwidth, oldheight, oldmmWidth, oldmmHeight; |
1211 | + int dpix, dpiy; |
1212 | + |
1213 | + /* Prevent updates while we fiddle */ |
1214 | + xf86SetRootClip(pScreen, FALSE); |
1215 | + |
1216 | + /* Store current state in case we fail */ |
1217 | + oldwidth = pScreen->width; |
1218 | + oldheight = pScreen->height; |
1219 | + oldmmWidth = pScreen->mmWidth; |
1220 | + oldmmHeight = pScreen->mmHeight; |
1221 | + |
1222 | + /* Compute the current DPI (for use later) */ |
1223 | + dpix = (pScreen->width * 254 + pScreen->mmWidth * 5) / (pScreen->mmWidth * 10); |
1224 | + dpiy = (pScreen->height * 254 + pScreen->mmHeight * 5) / (pScreen->mmHeight * 10); |
1225 | + |
1226 | + /* Then set the new dimensions */ |
1227 | + pScreen->width = pSize->width; |
1228 | + pScreen->height = pSize->height; |
1229 | + |
1230 | + /* Try to keep the same DPI as we do not have a physical screen */ |
1231 | + pScreen->mmWidth = (pScreen->width * 254 + dpix * 5) / (dpix * 10); |
1232 | + pScreen->mmHeight = (pScreen->height * 254 + dpiy * 5) / (dpiy * 10); |
1233 | + |
1234 | + /* Allocate a new framebuffer */ |
1235 | + memset(&fb, 0, sizeof(vfbFramebufferInfo)); |
1236 | + |
1237 | + fb.width = pScreen->width; |
1238 | + fb.height = pScreen->height; |
1239 | + fb.depth = pvfb->fb.depth; |
1240 | + |
1241 | + pbits = vfbAllocateFramebufferMemory(&fb); |
1242 | + if (!pbits) { |
1243 | + /* Allocation failed. Restore old state */ |
1244 | + pScreen->width = oldwidth; |
1245 | + pScreen->height = oldheight; |
1246 | + pScreen->mmWidth = oldmmWidth; |
1247 | + pScreen->mmHeight = oldmmHeight; |
1248 | + |
1249 | + xf86SetRootClip(pScreen, TRUE); |
1250 | + |
1251 | + return FALSE; |
1252 | + } |
1253 | + |
1254 | + /* Update root pixmap with the new dimensions and buffer */ |
1255 | + ret = pScreen->ModifyPixmapHeader(rootPixmap, fb.width, fb.height, |
1256 | + -1, -1, fb.paddedBytesWidth, pbits); |
1257 | + if (!ret) { |
1258 | + /* Update failed. Free the new framebuffer and restore old state */ |
1259 | + vfbFreeFramebufferMemory(&fb); |
1260 | + |
1261 | + pScreen->width = oldwidth; |
1262 | + pScreen->height = oldheight; |
1263 | + pScreen->mmWidth = oldmmWidth; |
1264 | + pScreen->mmHeight = oldmmHeight; |
1265 | + |
1266 | + xf86SetRootClip(pScreen, TRUE); |
1267 | + |
1268 | + return FALSE; |
1269 | + } |
1270 | + |
1271 | + /* Free the old framebuffer and keep the info about the new one */ |
1272 | + vfbFreeFramebufferMemory(&pvfb->fb); |
1273 | + memcpy(&pvfb->fb, &fb, sizeof(vfbFramebufferInfo)); |
1274 | + |
1275 | + /* Let VNC get the new framebuffer (actual update is in vncHooks.cc) */ |
1276 | + vncFbptr[pScreen->myNum] = pbits; |
1277 | + vncFbstride[pScreen->myNum] = fb.paddedWidth; |
1278 | + |
1279 | + /* Restore ability to update screen, now with new dimensions */ |
1280 | + xf86SetRootClip(pScreen, TRUE); |
1281 | + |
1282 | + return TRUE; |
1283 | +} |
1284 | + |
1285 | +#endif |
1286 | + |
1287 | +static Bool |
1288 | +vfbCloseScreen(int index, ScreenPtr pScreen) |
1289 | +{ |
1290 | + vfbScreenInfoPtr pvfb = &vfbScreens[index]; |
1291 | + int i; |
1292 | + |
1293 | + pScreen->CloseScreen = pvfb->closeScreen; |
1294 | + |
1295 | + /* |
1296 | + * XXX probably lots of stuff to clean. For now, |
1297 | + * clear InstalledMaps[] so that server reset works correctly. |
1298 | + */ |
1299 | + for (i = 0; i < MAXSCREENS; i++) |
1300 | + InstalledMaps[i] = NULL; |
1301 | + |
1302 | + return pScreen->CloseScreen(index, pScreen); |
1303 | +} |
1304 | + |
1305 | +static Bool |
1306 | +vfbScreenInit(int index, ScreenPtr pScreen, int argc, char **argv) |
1307 | +{ |
1308 | + vfbScreenInfoPtr pvfb = &vfbScreens[index]; |
1309 | + int dpi = 100; |
1310 | + int ret; |
1311 | + void *pbits; |
1312 | + |
1313 | + if (monitorResolution) dpi = monitorResolution; |
1314 | + |
1315 | + pbits = vfbAllocateFramebufferMemory(&pvfb->fb); |
1316 | + if (!pbits) return FALSE; |
1317 | + vncFbptr[index] = pbits; |
1318 | + vncFbstride[index] = pvfb->fb.paddedWidth; |
1319 | + |
1320 | + miSetPixmapDepths(); |
1321 | + |
1322 | + switch (pvfb->fb.depth) { |
1323 | + case 8: |
1324 | + miSetVisualTypesAndMasks (8, |
1325 | + ((1 << StaticGray) | |
1326 | + (1 << GrayScale) | |
1327 | + (1 << StaticColor) | |
1328 | + (1 << PseudoColor) | |
1329 | + (1 << TrueColor) | |
1330 | + (1 << DirectColor)), |
1331 | + 8, PseudoColor, 0, 0, 0); |
1332 | + break; |
1333 | + case 16: |
1334 | + miSetVisualTypesAndMasks (16, |
1335 | + ((1 << TrueColor) | |
1336 | + (1 << DirectColor)), |
1337 | + 8, TrueColor, 0xf800, 0x07e0, 0x001f); |
1338 | + break; |
1339 | + case 24: |
1340 | + miSetVisualTypesAndMasks (24, |
1341 | + ((1 << TrueColor) | |
1342 | + (1 << DirectColor)), |
1343 | + 8, TrueColor, 0xff0000, 0x00ff00, 0x0000ff); |
1344 | + break; |
1345 | + case 32: |
1346 | + miSetVisualTypesAndMasks (32, |
1347 | + ((1 << TrueColor) | |
1348 | + (1 << DirectColor)), |
1349 | + 8, TrueColor, 0xff000000, 0x00ff0000, 0x0000ff00); |
1350 | + break; |
1351 | + default: |
1352 | + return FALSE; |
1353 | + } |
1354 | + |
1355 | + ret = fbScreenInit(pScreen, pbits, pvfb->fb.width, pvfb->fb.height, |
1356 | + dpi, dpi, pvfb->fb.paddedWidth, pvfb->fb.bitsPerPixel); |
1357 | + |
1358 | +#ifdef RENDER |
1359 | + if (ret && Render) |
1360 | + ret = fbPictureInit (pScreen, 0, 0); |
1361 | +#endif |
1362 | + |
1363 | + if (!ret) return FALSE; |
1364 | + |
1365 | + miInitializeBackingStore(pScreen); |
1366 | + |
1367 | + /* |
1368 | + * Circumvent the backing store that was just initialised. This amounts |
1369 | + * to a truely bizarre way of initialising SaveDoomedAreas and friends. |
1370 | + */ |
1371 | + |
1372 | + pScreen->InstallColormap = vfbInstallColormap; |
1373 | + pScreen->UninstallColormap = vfbUninstallColormap; |
1374 | + pScreen->ListInstalledColormaps = vfbListInstalledColormaps; |
1375 | + |
1376 | + pScreen->SaveScreen = vfbSaveScreen; |
1377 | + |
1378 | + miPointerInitialize(pScreen, &vfbPointerSpriteFuncs, &vfbPointerCursorFuncs, |
1379 | + FALSE); |
1380 | + |
1381 | + pScreen->blackPixel = pvfb->blackPixel; |
1382 | + pScreen->whitePixel = pvfb->whitePixel; |
1383 | + |
1384 | + if (!pvfb->pixelFormatDefined && pvfb->fb.depth == 16) { |
1385 | + pvfb->pixelFormatDefined = TRUE; |
1386 | + pvfb->rgbNotBgr = TRUE; |
1387 | + pvfb->blueBits = pvfb->redBits = 5; |
1388 | + pvfb->greenBits = 6; |
1389 | + } |
1390 | + |
1391 | + if (pvfb->pixelFormatDefined) { |
1392 | + VisualPtr vis = pScreen->visuals; |
1393 | + for (int i = 0; i < pScreen->numVisuals; i++) { |
1394 | + if (pvfb->rgbNotBgr) { |
1395 | + vis->offsetBlue = 0; |
1396 | + vis->blueMask = (1 << pvfb->blueBits) - 1; |
1397 | + vis->offsetGreen = pvfb->blueBits; |
1398 | + vis->greenMask = ((1 << pvfb->greenBits) - 1) << vis->offsetGreen; |
1399 | + vis->offsetRed = vis->offsetGreen + pvfb->greenBits; |
1400 | + vis->redMask = ((1 << pvfb->redBits) - 1) << vis->offsetRed; |
1401 | + } else { |
1402 | + vis->offsetRed = 0; |
1403 | + vis->redMask = (1 << pvfb->redBits) - 1; |
1404 | + vis->offsetGreen = pvfb->redBits; |
1405 | + vis->greenMask = ((1 << pvfb->greenBits) - 1) << vis->offsetGreen; |
1406 | + vis->offsetBlue = vis->offsetGreen + pvfb->greenBits; |
1407 | + vis->blueMask = ((1 << pvfb->blueBits) - 1) << vis->offsetBlue; |
1408 | + } |
1409 | + vis++; |
1410 | + } |
1411 | + } |
1412 | + |
1413 | + ret = fbCreateDefColormap(pScreen); |
1414 | + if (!ret) return FALSE; |
1415 | + |
1416 | + miSetZeroLineBias(pScreen, pvfb->lineBias); |
1417 | + |
1418 | + pvfb->closeScreen = pScreen->CloseScreen; |
1419 | + pScreen->CloseScreen = vfbCloseScreen; |
1420 | + |
1421 | +#ifdef RANDR |
1422 | + rrScrPrivPtr rp; |
1423 | + |
1424 | + ret = RRScreenInit(pScreen); |
1425 | + if (!ret) return FALSE; |
1426 | + |
1427 | + rp = rrGetScrPriv(pScreen); |
1428 | + rp->rrGetInfo = vncRandRGetInfo; |
1429 | + rp->rrSetConfig = vncRandRSetConfig; |
1430 | +#endif |
1431 | + |
1432 | + |
1433 | + return TRUE; |
1434 | + |
1435 | +} /* end vfbScreenInit */ |
1436 | + |
1437 | + |
1438 | +static void vfbClientStateChange(CallbackListPtr*, pointer, pointer) { |
1439 | + dispatchException &= ~DE_RESET; |
1440 | +} |
1441 | + |
1442 | +void |
1443 | +InitOutput(ScreenInfo *screenInfo, int argc, char **argv) |
1444 | +{ |
1445 | + ErrorF("\nXvnc %s - built %s\n%s", XVNCVERSION, buildtime, XVNCCOPYRIGHT); |
1446 | + ErrorF("Underlying X server release %d, %s\n\n", VENDOR_RELEASE, |
1447 | + VENDOR_STRING); |
1448 | + int i; |
1449 | + int NumFormats = 0; |
1450 | + |
1451 | + /* initialize pixmap formats */ |
1452 | + |
1453 | + /* must have a pixmap depth to match every screen depth */ |
1454 | + for (i = 0; i < vfbNumScreens; i++) |
1455 | + { |
1456 | + vfbPixmapDepths[vfbScreens[i].fb.depth] = TRUE; |
1457 | + } |
1458 | + |
1459 | + /* RENDER needs a good set of pixmaps. */ |
1460 | + if (Render) { |
1461 | + vfbPixmapDepths[1] = TRUE; |
1462 | + vfbPixmapDepths[4] = TRUE; |
1463 | + vfbPixmapDepths[8] = TRUE; |
1464 | +/* vfbPixmapDepths[15] = TRUE; */ |
1465 | + vfbPixmapDepths[16] = TRUE; |
1466 | + vfbPixmapDepths[24] = TRUE; |
1467 | + vfbPixmapDepths[32] = TRUE; |
1468 | + } |
1469 | + |
1470 | + for (i = 1; i <= 32; i++) |
1471 | + { |
1472 | + if (vfbPixmapDepths[i]) |
1473 | + { |
1474 | + if (NumFormats >= MAXFORMATS) |
1475 | + FatalError ("MAXFORMATS is too small for this server\n"); |
1476 | + screenInfo->formats[NumFormats].depth = i; |
1477 | + screenInfo->formats[NumFormats].bitsPerPixel = vfbBitsPerPixel(i); |
1478 | + screenInfo->formats[NumFormats].scanlinePad = BITMAP_SCANLINE_PAD; |
1479 | + NumFormats++; |
1480 | + } |
1481 | + } |
1482 | + |
1483 | + screenInfo->imageByteOrder = IMAGE_BYTE_ORDER; |
1484 | + screenInfo->bitmapScanlineUnit = BITMAP_SCANLINE_UNIT; |
1485 | + screenInfo->bitmapScanlinePad = BITMAP_SCANLINE_PAD; |
1486 | + screenInfo->bitmapBitOrder = BITMAP_BIT_ORDER; |
1487 | + screenInfo->numPixmapFormats = NumFormats; |
1488 | + |
1489 | + /* initialize screens */ |
1490 | + |
1491 | + for (i = 0; i < vfbNumScreens; i++) |
1492 | + { |
1493 | + if (-1 == AddScreen(vfbScreenInit, argc, argv)) |
1494 | + { |
1495 | + FatalError("Couldn't add screen %d", i); |
1496 | + } |
1497 | + } |
1498 | + |
1499 | + if (!AddCallback(&ClientStateCallback, vfbClientStateChange, 0)) { |
1500 | + FatalError("AddCallback failed\n"); |
1501 | + } |
1502 | +} /* end InitOutput */ |
1503 | + |
1504 | +/* this is just to get the server to link on AIX */ |
1505 | +#ifdef AIXV3 |
1506 | +int SelectWaitTime = 10000; /* usec */ |
1507 | +#endif |
1508 | + |
1509 | +void DDXRingBell(int percent, int pitch, int duration) |
1510 | +{ |
1511 | + if (percent > 0) |
1512 | + vncBell(); |
1513 | +} |
1514 | + |
1515 | +Bool LegalModifier(unsigned int key, DeviceIntPtr pDev) |
1516 | +{ |
1517 | + return TRUE; |
1518 | +} |
1519 | + |
1520 | +void ProcessInputEvents() |
1521 | +{ |
1522 | + mieqProcessInputEvents(); |
1523 | +#if XORG == 15 |
1524 | + miPointerUpdate(); |
1525 | +#endif |
1526 | +} |
1527 | + |
1528 | +// InitInput is called after InitExtensions, so we're guaranteed that |
1529 | +// vncExtensionInit() has already been called. |
1530 | + |
1531 | +void InitInput(int argc, char *argv[]) |
1532 | +{ |
1533 | + mieqInit (); |
1534 | +} |
1535 | diff -Naur tigervnc-1.0.1/unix/xserver19.patch tigervnc-1.0.1-magellan/unix/xserver19.patch |
1536 | --- tigervnc-1.0.1/unix/xserver19.patch 1970-01-01 01:00:00.000000000 +0100 |
1537 | +++ tigervnc-1.0.1-magellan/unix/xserver19.patch 2011-01-21 20:41:21.000000000 +0100 |
1538 | @@ -0,0 +1,86 @@ |
1539 | +diff -up xserver/configure.ac.vnc xserver/configure.ac |
1540 | +--- xserver/configure.ac.vnc 2010-07-20 11:34:55.086181932 +0200 |
1541 | ++++ xserver/configure.ac 2010-07-20 11:35:02.196706133 +0200 |
1542 | +@@ -30,7 +30,6 @@ AC_INIT([xorg-server], 1.8.99.905, [http |
1543 | + RELEASE_DATE="2010-07-14" |
1544 | + AC_CONFIG_SRCDIR([Makefile.am]) |
1545 | + AM_INIT_AUTOMAKE([foreign dist-bzip2]) |
1546 | +-AM_MAINTAINER_MODE |
1547 | + |
1548 | + # Require xorg-macros: XORG_DEFAULT_OPTIONS |
1549 | + m4_ifndef([XORG_MACROS_VERSION], |
1550 | +@@ -64,6 +63,7 @@ dnl forcing an entire recompile.x |
1551 | + AC_CONFIG_HEADERS(include/version-config.h) |
1552 | + |
1553 | + AC_PROG_CC |
1554 | ++AC_PROG_CXX |
1555 | + AM_PROG_AS |
1556 | + AC_PROG_INSTALL |
1557 | + AC_PROG_LN_S |
1558 | +@@ -1512,6 +1512,9 @@ if test "x$XVFB" = xyes; then |
1559 | + AC_SUBST([XVFB_SYS_LIBS]) |
1560 | + fi |
1561 | + |
1562 | ++dnl Xvnc DDX |
1563 | ++AC_SUBST([XVNC_CPPFLAGS], ["-DHAVE_DIX_CONFIG_H $XEXT_INC $FB_INC $MI_INC $RENDER_INC $RANDR_INC"]) |
1564 | ++AC_SUBST([XVNC_LIBS], ["$FB_LIB $FIXES_LIB $XEXT_LIB $CONFIG_LIB $DBE_LIB $RECORD_LIB $GLX_LIBS $RANDR_LIB $RENDER_LIB $DAMAGE_LIB $MIEXT_DAMAGE_LIB $MIEXT_SHADOW_LIB $XI_LIB $XKB_LIB $XKB_STUB_LIB $COMPOSITE_LIB $MAIN_LIB"]) |
1565 | + |
1566 | + dnl Xnest DDX |
1567 | + |
1568 | +@@ -1550,6 +1553,8 @@ xorg_bus_linuxpci=no |
1569 | + xorg_bus_bsdpci=no |
1570 | + xorg_bus_sparc=no |
1571 | + |
1572 | ++AC_DEFINE_UNQUOTED(XORG_VERSION_CURRENT, [$VENDOR_RELEASE], [Current Xorg version]) |
1573 | ++ |
1574 | + if test "x$XORG" = xyes; then |
1575 | + XORG_DDXINCS='-I$(top_srcdir)/hw/xfree86 -I$(top_srcdir)/hw/xfree86/include -I$(top_srcdir)/hw/xfree86/common' |
1576 | + XORG_OSINCS='-I$(top_srcdir)/hw/xfree86/os-support -I$(top_srcdir)/hw/xfree86/os-support/bus -I$(top_srcdir)/os' |
1577 | +@@ -1796,7 +1801,6 @@ if test "x$XORG" = xyes; then |
1578 | + AC_DEFINE(XORGSERVER, 1, [Building Xorg server]) |
1579 | + AC_DEFINE(XFree86Server, 1, [Building XFree86 server]) |
1580 | + AC_DEFINE(XFree86LOADER, 1, [Building loadable XFree86 server]) |
1581 | +- AC_DEFINE_UNQUOTED(XORG_VERSION_CURRENT, [$VENDOR_RELEASE], [Current Xorg version]) |
1582 | + AC_DEFINE(NEED_XF86_TYPES, 1, [Need XFree86 typedefs]) |
1583 | + AC_DEFINE(NEED_XF86_PROTOTYPES, 1, [Need XFree86 helper functions]) |
1584 | + AC_DEFINE(__XSERVERNAME__, "Xorg", [Name of X server]) |
1585 | +@@ -2246,6 +2250,7 @@ hw/dmx/input/Makefile |
1586 | + hw/dmx/glxProxy/Makefile |
1587 | + hw/dmx/Makefile |
1588 | + hw/vfb/Makefile |
1589 | ++hw/vnc/Makefile |
1590 | + hw/xnest/Makefile |
1591 | + hw/xwin/Makefile |
1592 | + hw/xwin/glx/Makefile |
1593 | +diff -up xserver/hw/Makefile.am.vnc xserver/hw/Makefile.am |
1594 | +--- xserver/hw/Makefile.am.vnc 2010-07-20 11:34:55.276195912 +0200 |
1595 | ++++ xserver/hw/Makefile.am 2010-07-20 11:35:02.196706133 +0200 |
1596 | +@@ -33,7 +33,8 @@ SUBDIRS = \ |
1597 | + $(XNEST_SUBDIRS) \ |
1598 | + $(DMX_SUBDIRS) \ |
1599 | + $(KDRIVE_SUBDIRS) \ |
1600 | +- $(XQUARTZ_SUBDIRS) |
1601 | ++ $(XQUARTZ_SUBDIRS) \ |
1602 | ++ vnc |
1603 | + |
1604 | + DIST_SUBDIRS = dmx xfree86 vfb xnest xwin xquartz kdrive |
1605 | + |
1606 | +diff -up xserver/mi/miinitext.c.vnc xserver/mi/miinitext.c |
1607 | +--- xserver/mi/miinitext.c.vnc 2010-07-20 11:34:55.286196649 +0200 |
1608 | ++++ xserver/mi/miinitext.c 2010-07-20 11:35:02.196706133 +0200 |
1609 | +@@ -263,6 +263,7 @@ extern void DamageExtensionInit(INITARGS |
1610 | + extern void CompositeExtensionInit(INITARGS); |
1611 | + #endif |
1612 | + extern void GEExtensionInit(INITARGS); |
1613 | ++extern void vncExtensionInit(INITARGS); |
1614 | + |
1615 | + /* The following is only a small first step towards run-time |
1616 | + * configurable extensions. |
1617 | +@@ -435,6 +436,7 @@ InitExtensions(int argc, char *argv[]) |
1618 | + #ifdef XF86BIGFONT |
1619 | + if (!noXFree86BigfontExtension) XFree86BigfontExtensionInit(); |
1620 | + #endif |
1621 | ++ vncExtensionInit(); |
1622 | + #if !defined(NO_HW_ONLY_EXTS) |
1623 | + #if defined(XF86VIDMODE) |
1624 | + if (!noXFree86VidModeExtension) XFree86VidModeExtensionInit(); |