rdesktop/uiports/xxxwin.c

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

   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; /* in tcp.c */
RD_BOOL g_use_rdp5 = False;
char g_hostname[16];
char g_username[64];
int g_height = 600;
int g_width = 800;
int g_server_depth = 8;
RD_BOOL g_encryption = True;
RD_BOOL g_desktop_save = True;
RD_BOOL g_polygon_ellipse_orders = False;
RD_BOOL g_bitmap_cache = True;
RD_BOOL g_bitmap_cache_persist_enable = False;
RD_BOOL g_bitmap_cache_precache = True;
RD_BOOL g_bitmap_compression = True;
uint32 g_rdp5_performanceflags = 0;
RD_BOOL g_console_session = False;
uint32 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 */
RD_BOOL g_redirect = False;
RD_BOOL g_numlock_sync = 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;
char g_codepage[16] = "";

/*****************************************************************************/
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)
{
}

/*****************************************************************************/
RD_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,
               RD_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,
               RD_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(RD_HCURSOR cursor)
{
}

/*****************************************************************************/
RD_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, RD_POINT * point, int npoints,
                BRUSH * brush, int bgcolour, int fgcolour)
{
}

/*****************************************************************************/
/* todo, use qt function for this (QPainter::drawPolyline) */
void ui_polyline(uint8 opcode, RD_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, ...)
{
}

/*****************************************************************************/
RD_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;
}

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