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_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 */

/*****************************************************************************/
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, int mixmode,
                  int x, int y,
                  int clipx, int clipy, int clipcx, int clipcy,
                  int boxx, int boxy, int boxcx, int boxcy,
                  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 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)
{
}

/*****************************************************************************/
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			int g_desktop_save =1;
32			int g_bitmap_cache = 1;
33	jsorg71	727	int g_bitmap_cache_persist_enable = False;
34			int g_bitmap_cache_precache = True;
35	jsorg71	721	int g_bitmap_compression = 1;
36			int g_rdp5_performanceflags = 0;
37			int g_console_session = 0;
38			int g_keylayout = 0x409; /* Defaults to US keyboard layout */
39
40			/*****************************************************************************/
41			void ui_bell(void)
42			{
43			}
44
45			/*****************************************************************************/
46			int ui_select(int in)
47			{
48			return 1;
49			}
50
51			/*****************************************************************************/
52			void ui_destroy_cursor(void* cursor)
53			{
54			}
55
56			/*****************************************************************************/
57			void* ui_create_glyph(int width, int height, uint8* data)
58			{
59			return 0;
60			}
61
62			/*****************************************************************************/
63			void ui_destroy_glyph(void* glyph)
64			{
65			}
66
67			/*****************************************************************************/
68			void ui_destroy_bitmap(void* bmp)
69			{
70			}
71
72			/*****************************************************************************/
73			void ui_reset_clip(void)
74			{
75			}
76
77			/*****************************************************************************/
78			void ui_set_clip(int x, int y, int cx, int cy)
79			{
80			}
81
82			/*****************************************************************************/
83			void* ui_create_colourmap(COLOURMAP * colours)
84			{
85			return 0;
86			}
87
88			/*****************************************************************************/
89			void ui_set_colourmap(void* map)
90			{
91			}
92
93			/*****************************************************************************/
94			HBITMAP ui_create_bitmap(int width, int height, uint8* data)
95			{
96			return 0;
97			}
98
99			/*****************************************************************************/
100			void ui_draw_text(uint8 font, uint8 flags, int mixmode,
101			int x, int y,
102			int clipx, int clipy, int clipcx, int clipcy,
103			int boxx, int boxy, int boxcx, int boxcy,
104			int bgcolour, int fgcolour, uint8* text, uint8 length)
105			{
106			}
107
108			/*****************************************************************************/
109			void ui_line(uint8 opcode, int startx, int starty, int endx, int endy,
110			PEN * pen)
111			{
112			}
113
114			/*****************************************************************************/
115			void ui_triblt(uint8 opcode, int x, int y, int cx, int cy,
116			HBITMAP src, int srcx, int srcy,
117			BRUSH* brush, int bgcolour, int fgcolour)
118			{
119			}
120
121			/*****************************************************************************/
122			void ui_memblt(uint8 opcode, int x, int y, int cx, int cy,
123			HBITMAP src, int srcx, int srcy)
124			{
125			}
126
127			/*****************************************************************************/
128			void ui_desktop_restore(uint32 offset, int x, int y, int cx, int cy)
129			{
130			}
131
132			/*****************************************************************************/
133			void ui_desktop_save(uint32 offset, int x, int y, int cx, int cy)
134			{
135			}
136
137			/*****************************************************************************/
138			void ui_rect(int x, int y, int cx, int cy, int colour)
139			{
140			}
141
142			/*****************************************************************************/
143			void ui_screenblt(uint8 opcode, int x, int y, int cx, int cy,
144			int srcx, int srcy)
145			{
146			}
147
148			/*****************************************************************************/
149			void ui_patblt(uint8 opcode, int x, int y, int cx, int cy,
150			BRUSH * brush, int bgcolour, int fgcolour)
151			{
152			}
153
154			/*****************************************************************************/
155			void ui_destblt(uint8 opcode, int x, int y, int cx, int cy)
156			{
157			}
158
159			/*****************************************************************************/
160			void ui_move_pointer(int x, int y)
161			{
162			}
163
164			/*****************************************************************************/
165			void ui_set_null_cursor(void)
166			{
167			}
168
169			/*****************************************************************************/
170			void ui_paint_bitmap(int x, int y, int cx, int cy,
171			int width, int height, uint8* data)
172			{
173			}
174
175			/*****************************************************************************/
176			void ui_set_cursor(HCURSOR cursor)
177			{
178			}
179
180			/*****************************************************************************/
181			HCURSOR ui_create_cursor(unsigned int x, unsigned int y,
182			int width, int height,
183			uint8* andmask, uint8* xormask)
184			{
185			return 0;
186			}
187
188			/*****************************************************************************/
189			uint16 ui_get_numlock_state(unsigned int state)
190			{
191			return 0;
192			}
193
194			/*****************************************************************************/
195			unsigned int read_keyboard_state(void)
196			{
197			return 0;
198			}
199
200			/*****************************************************************************/
201			void ui_resize_window(void)
202			{
203			}
204
205			/*****************************************************************************/
206			void ui_begin_update(void)
207			{
208			}
209
210			/*****************************************************************************/
211			void ui_end_update(void)
212			{
213			}
214
215			/*****************************************************************************/
216			void generate_random(uint8* random)
217			{
218			}
219
220			/*****************************************************************************/
221			void save_licence(uint8* data, int length)
222			{
223			}
224
225			/*****************************************************************************/
226			int load_licence(uint8** data)
227			{
228			return 0;
229			}
230
231			/*****************************************************************************/
232			void* xrealloc(void* in, int size)
233			{
234			return 0;
235			}
236
237			/*****************************************************************************/
238			void* xmalloc(int size)
239			{
240			return 0;
241			}
242
243			/*****************************************************************************/
244			void xfree(void* in)
245			{
246			}
247
248			/*****************************************************************************/
249			void warning(char* format, ...)
250			{
251			}
252
253			/*****************************************************************************/
254			void unimpl(char* format, ...)
255			{
256			}
257
258			/*****************************************************************************/
259			void error(char* format, ...)
260			{
261			}
262
263			/*****************************************************************************/
264	jsorg71	727	BOOL rd_pstcache_mkdir(void)
265			{
266			return 0;
267			}
268
269			/*****************************************************************************/
270			int rd_open_file(char *filename)
271			{
272			return 0;
273			}
274
275			/*****************************************************************************/
276			void rd_close_file(int fd)
277			{
278			return;
279			}
280
281			/*****************************************************************************/
282			int rd_read_file(int fd, void *ptr, int len)
283			{
284			return 0;
285			}
286
287			/*****************************************************************************/
288			int rd_write_file(int fd, void* ptr, int len)
289			{
290			return 0;
291			}
292
293			/*****************************************************************************/
294			int rd_lseek_file(int fd, int offset)
295			{
296			return 0;
297			}
298
299			/*****************************************************************************/
300			BOOL rd_lock_file(int fd, int start, int len)
301			{
302			return False;
303			}
304
305			/*****************************************************************************/
306	jsorg71	721	int main(int c, char** p)
307			{
308			return 0;
309			}