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	/* -- c-basic-offset: 8 --
2	rdesktop: A Remote Desktop Protocol client.
3	User interface services - Generic
4	Copyright (C) Jay Sorg 2004-2005
5
6	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	#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	int g_bitmap_cache_persist_enable = False;
34	int g_bitmap_cache_precache = True;
35	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	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	int main(int c, char** p)
307	{
308	return 0;
309	}