rdesktop/uiports/xxxwin.c

/* -*- c-basic-offset: 8 -*-
   rdesktop: A Remote Desktop Protocol client.
   User interface services - Generic
   Copyright (C) Jay Sorg 2004-2005

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program 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 General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#include "../rdesktop.h"

extern int g_tcp_port_rdp;
int g_use_rdp5 = 0;
char g_hostname[16];
char g_username[64];
int g_height = 600;
int g_width = 800;
int g_server_bpp = 8;
int g_encryption = 1;
int g_desktop_save = 1;
int g_polygon_ellipse_orders = 0;
int g_bitmap_cache = 1;
int g_bitmap_cache_persist_enable = False;
int g_bitmap_cache_precache = True;
int g_bitmap_compression = 1;
int g_rdp5_performanceflags = 0;
int g_console_session = 0;
int g_keylayout = 0x409; /* Defaults to US keyboard layout */
int g_keyboard_type = 0x4; /* Defaults to US keyboard layout */
int g_keyboard_subtype = 0x0; /* Defaults to US keyboard layout */
int g_keyboard_functionkeys = 0xc; /* Defaults to US keyboard layout */
/* Session Directory redirection */
BOOL g_redirect = False;
char g_redirect_server[64];
char g_redirect_domain[16];
char g_redirect_password[64];
char g_redirect_username[64];
char g_redirect_cookie[128];
uint32 g_redirect_flags = 0;

/*****************************************************************************/
void ui_bell(void)
{
}

/*****************************************************************************/
int ui_select(int in)
{
  return 1;
}

/*****************************************************************************/
void ui_destroy_cursor(void* cursor)
{
}

/*****************************************************************************/
void* ui_create_glyph(int width, int height, uint8* data)
{
  return 0;
}

/*****************************************************************************/
void ui_destroy_glyph(void* glyph)
{
}

/*****************************************************************************/
void ui_destroy_bitmap(void* bmp)
{
}

/*****************************************************************************/
void ui_reset_clip(void)
{
}

/*****************************************************************************/
void ui_set_clip(int x, int y, int cx, int cy)
{
}

/*****************************************************************************/
void* ui_create_colourmap(COLOURMAP * colours)
{
  return 0;
}

/*****************************************************************************/
void ui_set_colourmap(void* map)
{
}

/*****************************************************************************/
HBITMAP ui_create_bitmap(int width, int height, uint8* data)
{
  return 0;
}

/*****************************************************************************/
void ui_draw_text(uint8 font, uint8 flags, uint8 opcode, int mixmode,
                  int x, int y,
                  int clipx, int clipy, int clipcx, int clipcy,
                  int boxx, int boxy, int boxcx, int boxcy, BRUSH * brush,
                  int bgcolour, int fgcolour, uint8* text, uint8 length)
{
}

/*****************************************************************************/
void ui_line(uint8 opcode, int startx, int starty, int endx, int endy,
             PEN * pen)
{
}

/*****************************************************************************/
void ui_triblt(uint8 opcode, int x, int y, int cx, int cy,
               HBITMAP src, int srcx, int srcy,
               BRUSH* brush, int bgcolour, int fgcolour)
{
}

/*****************************************************************************/
void ui_memblt(uint8 opcode, int x, int y, int cx, int cy,
               HBITMAP src, int srcx, int srcy)
{
}

/*****************************************************************************/
void ui_desktop_restore(uint32 offset, int x, int y, int cx, int cy)
{
}

/*****************************************************************************/
void ui_desktop_save(uint32 offset, int x, int y, int cx, int cy)
{
}

/*****************************************************************************/
void ui_rect(int x, int y, int cx, int cy, int colour)
{
}

/*****************************************************************************/
void ui_screenblt(uint8 opcode, int x, int y, int cx, int cy,
                  int srcx, int srcy)
{
}

/*****************************************************************************/
void ui_patblt(uint8 opcode, int x, int y, int cx, int cy,
               BRUSH * brush, int bgcolour, int fgcolour)
{
}

/*****************************************************************************/
void ui_destblt(uint8 opcode, int x, int y, int cx, int cy)
{
}

/*****************************************************************************/
void ui_move_pointer(int x, int y)
{
}

/*****************************************************************************/
void ui_set_null_cursor(void)
{
}

/*****************************************************************************/
void ui_paint_bitmap(int x, int y, int cx, int cy,
                     int width, int height, uint8* data)
{
}

/*****************************************************************************/
void ui_set_cursor(HCURSOR cursor)
{
}

/*****************************************************************************/
HCURSOR ui_create_cursor(unsigned int x, unsigned int y,
                         int width, int height,
                         uint8* andmask, uint8* xormask)
{
  return 0;
}

/*****************************************************************************/
uint16 ui_get_numlock_state(unsigned int state)
{
  return 0;
}

/*****************************************************************************/
unsigned int read_keyboard_state(void)
{
  return 0;
}

/*****************************************************************************/
void ui_resize_window(void)
{
}

/*****************************************************************************/
void ui_begin_update(void)
{
}

/*****************************************************************************/
void ui_end_update(void)
{
}

/*****************************************************************************/
void ui_polygon(uint8 opcode, uint8 fillmode, POINT * point, int npoints,
                BRUSH * brush, int bgcolour, int fgcolour)
{
}

/*****************************************************************************/
/* todo, use qt function for this (QPainter::drawPolyline) */
void ui_polyline(uint8 opcode, POINT * points, int npoints, PEN * pen)
{
  int i, x, y, dx, dy;
  if (npoints > 0)
  {
    x = points[0].x;
    y = points[0].y;
    for (i = 1; i < npoints; i++)
    {
      dx = points[i].x;
      dy = points[i].y;
      ui_line(opcode, x, y, x + dx, y + dy, pen);
      x = x + dx;
      y = y + dy;
    }
  }
}

/*****************************************************************************/
void ui_ellipse(uint8 opcode, uint8 fillmode,
                int x, int y, int cx, int cy,
                BRUSH * brush, int bgcolour, int fgcolour)
{
}

/*****************************************************************************/
void generate_random(uint8* random)
{
}

/*****************************************************************************/
void save_licence(uint8* data, int length)
{
}

/*****************************************************************************/
int load_licence(uint8** data)
{
  return 0;
}

/*****************************************************************************/
void* xrealloc(void* in, int size)
{
  return 0;
}

/*****************************************************************************/
void* xmalloc(int size)
{
  return 0;
}

/*****************************************************************************/
void xfree(void* in)
{
}

/*****************************************************************************/
char * xstrdup(const char * s)
{
  char * mem = strdup(s);
  if (mem == NULL)
  {
    perror("strdup");
    exit(1);
  }
  return mem;
}
/*****************************************************************************/
void warning(char* format, ...)
{
}

/*****************************************************************************/
void unimpl(char* format, ...)
{
}

/*****************************************************************************/
void error(char* format, ...)
{
}

/*****************************************************************************/
BOOL rd_pstcache_mkdir(void)
{
  return 0;
}

/*****************************************************************************/
int rd_open_file(char *filename)
{
  return 0;
}

/*****************************************************************************/
void rd_close_file(int fd)
{
  return;
}

/*****************************************************************************/
int rd_read_file(int fd, void *ptr, int len)
{
  return 0;
}

/*****************************************************************************/
int rd_write_file(int fd, void* ptr, int len)
{
  return 0;
}

/*****************************************************************************/
int rd_lseek_file(int fd, int offset)
{
  return 0;
}

/*****************************************************************************/
BOOL rd_lock_file(int fd, int start, int len)
{
  return False;
}

/*****************************************************************************/
int main(int c, char** p)
{
  return 0;
}
1	jsorg71	851	/* -- c-basic-offset: 8 --
2			rdesktop: A Remote Desktop Protocol client.
3			User interface services - Generic
4			Copyright (C) Jay Sorg 2004-2005
5	jsorg71	721
6	jsorg71	851	This program is free software; you can redistribute it and/or modify
7			it under the terms of the GNU General Public License as published by
8			the Free Software Foundation; either version 2 of the License, or
9			(at your option) any later version.
10
11			This program 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
14			GNU General Public License for more details.
15
16			You should have received a copy of the GNU General Public License
17			along with this program; if not, write to the Free Software
18			Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19			*/
20
21	jsorg71	721	#include "../rdesktop.h"
22
23			extern int g_tcp_port_rdp;
24			int g_use_rdp5 = 0;
25			char g_hostname[16];
26			char g_username[64];
27			int g_height = 600;
28			int g_width = 800;
29			int g_server_bpp = 8;
30			int g_encryption = 1;
31	jsorg71	852	int g_desktop_save = 1;
32			int g_polygon_ellipse_orders = 0;
33	jsorg71	721	int g_bitmap_cache = 1;
34	jsorg71	727	int g_bitmap_cache_persist_enable = False;
35			int g_bitmap_cache_precache = True;
36	jsorg71	721	int g_bitmap_compression = 1;
37			int g_rdp5_performanceflags = 0;
38			int g_console_session = 0;
39			int g_keylayout = 0x409; /* Defaults to US keyboard layout */
40	jsorg71	1019	int g_keyboard_type = 0x4; /* Defaults to US keyboard layout */
41			int g_keyboard_subtype = 0x0; /* Defaults to US keyboard layout */
42			int g_keyboard_functionkeys = 0xc; /* Defaults to US keyboard layout */
43			/* Session Directory redirection */
44			BOOL g_redirect = False;
45			char g_redirect_server[64];
46			char g_redirect_domain[16];
47			char g_redirect_password[64];
48			char g_redirect_username[64];
49			char g_redirect_cookie[128];
50			uint32 g_redirect_flags = 0;
51	jsorg71	721
52			/*****************************************************************************/
53			void ui_bell(void)
54			{
55			}
56
57			/*****************************************************************************/
58			int ui_select(int in)
59			{
60			return 1;
61			}
62
63			/*****************************************************************************/
64			void ui_destroy_cursor(void* cursor)
65			{
66			}
67
68			/*****************************************************************************/
69			void* ui_create_glyph(int width, int height, uint8* data)
70			{
71			return 0;
72			}
73
74			/*****************************************************************************/
75			void ui_destroy_glyph(void* glyph)
76			{
77			}
78
79			/*****************************************************************************/
80			void ui_destroy_bitmap(void* bmp)
81			{
82			}
83
84			/*****************************************************************************/
85			void ui_reset_clip(void)
86			{
87			}
88
89			/*****************************************************************************/
90			void ui_set_clip(int x, int y, int cx, int cy)
91			{
92			}
93
94			/*****************************************************************************/
95			void* ui_create_colourmap(COLOURMAP * colours)
96			{
97			return 0;
98			}
99
100			/*****************************************************************************/
101			void ui_set_colourmap(void* map)
102			{
103			}
104
105			/*****************************************************************************/
106			HBITMAP ui_create_bitmap(int width, int height, uint8* data)
107			{
108			return 0;
109			}
110
111			/*****************************************************************************/
112	jsorg71	852	void ui_draw_text(uint8 font, uint8 flags, uint8 opcode, int mixmode,
113	jsorg71	721	int x, int y,
114			int clipx, int clipy, int clipcx, int clipcy,
115	jsorg71	852	int boxx, int boxy, int boxcx, int boxcy, BRUSH * brush,
116	jsorg71	721	int bgcolour, int fgcolour, uint8* text, uint8 length)
117			{
118			}
119
120			/*****************************************************************************/
121			void ui_line(uint8 opcode, int startx, int starty, int endx, int endy,
122			PEN * pen)
123			{
124			}
125
126			/*****************************************************************************/
127			void ui_triblt(uint8 opcode, int x, int y, int cx, int cy,
128			HBITMAP src, int srcx, int srcy,
129			BRUSH* brush, int bgcolour, int fgcolour)
130			{
131			}
132
133			/*****************************************************************************/
134			void ui_memblt(uint8 opcode, int x, int y, int cx, int cy,
135			HBITMAP src, int srcx, int srcy)
136			{
137			}
138
139			/*****************************************************************************/
140			void ui_desktop_restore(uint32 offset, int x, int y, int cx, int cy)
141			{
142			}
143
144			/*****************************************************************************/
145			void ui_desktop_save(uint32 offset, int x, int y, int cx, int cy)
146			{
147			}
148
149			/*****************************************************************************/
150			void ui_rect(int x, int y, int cx, int cy, int colour)
151			{
152			}
153
154			/*****************************************************************************/
155			void ui_screenblt(uint8 opcode, int x, int y, int cx, int cy,
156			int srcx, int srcy)
157			{
158			}
159
160			/*****************************************************************************/
161			void ui_patblt(uint8 opcode, int x, int y, int cx, int cy,
162			BRUSH * brush, int bgcolour, int fgcolour)
163			{
164			}
165
166			/*****************************************************************************/
167			void ui_destblt(uint8 opcode, int x, int y, int cx, int cy)
168			{
169			}
170
171			/*****************************************************************************/
172			void ui_move_pointer(int x, int y)
173			{
174			}
175
176			/*****************************************************************************/
177			void ui_set_null_cursor(void)
178			{
179			}
180
181			/*****************************************************************************/
182			void ui_paint_bitmap(int x, int y, int cx, int cy,
183			int width, int height, uint8* data)
184			{
185			}
186
187			/*****************************************************************************/
188			void ui_set_cursor(HCURSOR cursor)
189			{
190			}
191
192			/*****************************************************************************/
193			HCURSOR ui_create_cursor(unsigned int x, unsigned int y,
194			int width, int height,
195			uint8* andmask, uint8* xormask)
196			{
197			return 0;
198			}
199
200			/*****************************************************************************/
201			uint16 ui_get_numlock_state(unsigned int state)
202			{
203			return 0;
204			}
205
206			/*****************************************************************************/
207			unsigned int read_keyboard_state(void)
208			{
209			return 0;
210			}
211
212			/*****************************************************************************/
213			void ui_resize_window(void)
214			{
215			}
216
217			/*****************************************************************************/
218			void ui_begin_update(void)
219			{
220			}
221
222			/*****************************************************************************/
223			void ui_end_update(void)
224			{
225			}
226
227			/*****************************************************************************/
228	jsorg71	852	void ui_polygon(uint8 opcode, uint8 fillmode, POINT * point, int npoints,
229			BRUSH * brush, int bgcolour, int fgcolour)
230			{
231			}
232
233			/*****************************************************************************/
234			/* todo, use qt function for this (QPainter::drawPolyline) */
235			void ui_polyline(uint8 opcode, POINT * points, int npoints, PEN * pen)
236			{
237			int i, x, y, dx, dy;
238			if (npoints > 0)
239			{
240			x = points[0].x;
241			y = points[0].y;
242			for (i = 1; i < npoints; i++)
243			{
244			dx = points[i].x;
245			dy = points[i].y;
246			ui_line(opcode, x, y, x + dx, y + dy, pen);
247			x = x + dx;
248			y = y + dy;
249			}
250			}
251			}
252
253			/*****************************************************************************/
254			void ui_ellipse(uint8 opcode, uint8 fillmode,
255			int x, int y, int cx, int cy,
256			BRUSH * brush, int bgcolour, int fgcolour)
257			{
258			}
259
260			/*****************************************************************************/
261	jsorg71	721	void generate_random(uint8* random)
262			{
263			}
264
265			/*****************************************************************************/
266			void save_licence(uint8* data, int length)
267			{
268			}
269
270			/*****************************************************************************/
271			int load_licence(uint8** data)
272			{
273			return 0;
274			}
275
276			/*****************************************************************************/
277			void* xrealloc(void* in, int size)
278			{
279			return 0;
280			}
281
282			/*****************************************************************************/
283			void* xmalloc(int size)
284			{
285			return 0;
286			}
287
288			/*****************************************************************************/
289			void xfree(void* in)
290			{
291			}
292
293			/*****************************************************************************/
294	jsorg71	1019	char * xstrdup(const char * s)
295			{
296			char * mem = strdup(s);
297			if (mem == NULL)
298			{
299			perror("strdup");
300			exit(1);
301			}
302			return mem;
303			}
304			/*****************************************************************************/
305	jsorg71	721	void warning(char* format, ...)
306			{
307			}
308
309			/*****************************************************************************/
310			void unimpl(char* format, ...)
311			{
312			}
313
314			/*****************************************************************************/
315			void error(char* format, ...)
316			{
317			}
318
319			/*****************************************************************************/
320	jsorg71	727	BOOL rd_pstcache_mkdir(void)
321			{
322			return 0;
323			}
324
325			/*****************************************************************************/
326			int rd_open_file(char *filename)
327			{
328			return 0;
329			}
330
331			/*****************************************************************************/
332			void rd_close_file(int fd)
333			{
334			return;
335			}
336
337			/*****************************************************************************/
338			int rd_read_file(int fd, void *ptr, int len)
339			{
340			return 0;
341			}
342
343			/*****************************************************************************/
344			int rd_write_file(int fd, void* ptr, int len)
345			{
346			return 0;
347			}
348
349			/*****************************************************************************/
350			int rd_lseek_file(int fd, int offset)
351			{
352			return 0;
353			}
354
355			/*****************************************************************************/
356			BOOL rd_lock_file(int fd, int start, int len)
357			{
358			return False;
359			}
360
361			/*****************************************************************************/
362	jsorg71	721	int main(int c, char** p)
363			{
364			return 0;
365			}