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	/* -- 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_polygon_ellipse_orders = 0;
33	int g_bitmap_cache = 1;
34	int g_bitmap_cache_persist_enable = False;
35	int g_bitmap_cache_precache = True;
36	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	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
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	void ui_draw_text(uint8 font, uint8 flags, uint8 opcode, int mixmode,
113	int x, int y,
114	int clipx, int clipy, int clipcx, int clipcy,
115	int boxx, int boxy, int boxcx, int boxcy, BRUSH * brush,
116	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	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	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	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	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	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	int main(int c, char** p)
363	{
364	return 0;
365	}