jh163888/xrdp
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

add new painter funcs

Browse Source
This commit is contained in:
jsorg71 2005-08-18 00:32:11 +00:00
parent a4ce4c46c6
commit 9d2ce459da
13 changed files with 803 additions and 403 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

59
vnc/vnc.c
View File

@ -712,7 +712,8 @@ int DEFAULT_CC
lib_mod_start(struct vnc* v, int w, int h, int bpp) lib_mod_start(struct vnc* v, int w, int h, int bpp)
{ {
v->server_begin_update(v); v->server_begin_update(v);
v->server_fill_rect(v, 0, 0, w, h, 0); v->server_set_fgcolor(v, 0);
v->server_fill_rect(v, 0, 0, w, h);
v->server_end_update(v); v->server_end_update(v);
v->server_width = w; v->server_width = w;
v->server_height = h; v->server_height = h;
@ -742,17 +743,17 @@ lib_mod_connect(struct vnc* v)
int ok; int ok;
int display; int display;
v->server_msg(v, "started connecting"); v->server_msg(v, "started connecting", 0);
check_sec_result = 1; check_sec_result = 1;
/* only support 8 and 16 bpp connections from rdp client */ /* only support 8 and 16 bpp connections from rdp client */
if (v->server_bpp != 8 && v->server_bpp != 16) if (v->server_bpp != 8 && v->server_bpp != 16)
{ {
v->server_msg(v, "error - only supporting 8 and 16 bpp rdp connections"); v->server_msg(v, "error - only supporting 8 and 16 bpp rdp connections", 0);
return 1; return 1;
} }
if (g_strcmp(v->ip, "") == 0) if (g_strcmp(v->ip, "") == 0)
{ {
v->server_msg(v, "error - no ip set"); v->server_msg(v, "error - no ip set", 0);
return 1; return 1;
} }
make_stream(s); make_stream(s);
@ -764,7 +765,7 @@ lib_mod_connect(struct vnc* v)
init_stream(s, 8192); init_stream(s, 8192);
v->sck = g_tcp_socket(); v->sck = g_tcp_socket();
v->sck_closed = 0; v->sck_closed = 0;
v->server_msg(v, "connecting to sesman"); v->server_msg(v, "connecting to sesman", 0);
if (g_tcp_connect(v->sck, v->ip, "3350") == 0) if (g_tcp_connect(v->sck, v->ip, "3350") == 0)
{ {
g_tcp_set_non_blocking(v->sck); g_tcp_set_non_blocking(v->sck);
@ -784,12 +785,12 @@ lib_mod_connect(struct vnc* v)
s_pop_layer(s, channel_hdr); s_pop_layer(s, channel_hdr);
out_uint32_be(s, 0); // version out_uint32_be(s, 0); // version
out_uint32_be(s, s->end - s->data); // size out_uint32_be(s, s->end - s->data); // size
v->server_msg(v, "sending login info to sesman"); v->server_msg(v, "sending login info to sesman", 0);
error = lib_send(v, s->data, s->end - s->data); error = lib_send(v, s->data, s->end - s->data);
if (error == 0) if (error == 0)
{ {
init_stream(s, 8192); init_stream(s, 8192);
v->server_msg(v, "receiving sesman header"); v->server_msg(v, "receiving sesman header", 0);
error = lib_recv(v, s->data, 8); error = lib_recv(v, s->data, 8);
} }
if (error == 0) if (error == 0)
@ -797,7 +798,7 @@ lib_mod_connect(struct vnc* v)
in_uint32_be(s, version); in_uint32_be(s, version);
in_uint32_be(s, size); in_uint32_be(s, size);
init_stream(s, 8192); init_stream(s, 8192);
v->server_msg(v, "receiving sesman data"); v->server_msg(v, "receiving sesman data", 0);
error = lib_recv(v, s->data, size - 8); error = lib_recv(v, s->data, size - 8);
} }
if (error == 0) if (error == 0)
@ -815,7 +816,7 @@ lib_mod_connect(struct vnc* v)
else else
{ {
in_uint8s(s, 2); in_uint8s(s, 2);
v->server_msg(v, "error - sesman returned no"); v->server_msg(v, "error - sesman returned no", 0);
} }
} }
} }
@ -823,16 +824,16 @@ lib_mod_connect(struct vnc* v)
} }
else else
{ {
v->server_msg(v, "error - connecting to sesman"); v->server_msg(v, "error - connecting to sesman", 0);
} }
g_tcp_close(v->sck); g_tcp_close(v->sck);
if (error != 0 || display == 0) if (error != 0 || display == 0)
{ {
v->server_msg(v, "error - connection failed"); v->server_msg(v, "error - connection failed", 0);
free_stream(s); free_stream(s);
return 1; return 1;
} }
v->server_msg(v, "sesman started a session"); v->server_msg(v, "sesman started a session", 0);
g_sprintf(con_port, "%d", 5900 + display); g_sprintf(con_port, "%d", 5900 + display);
v->vnc_desktop = display; v->vnc_desktop = display;
} }
@ -844,11 +845,11 @@ lib_mod_connect(struct vnc* v)
v->sck = g_tcp_socket(); v->sck = g_tcp_socket();
v->sck_closed = 0; v->sck_closed = 0;
g_sprintf(text, "connecting to %s %s", v->ip, con_port); g_sprintf(text, "connecting to %s %s", v->ip, con_port);
v->server_msg(v, text); v->server_msg(v, text, 0);
error = g_tcp_connect(v->sck, v->ip, con_port); error = g_tcp_connect(v->sck, v->ip, con_port);
if (error == 0) if (error == 0)
{ {
v->server_msg(v, "tcp connected"); v->server_msg(v, "tcp connected", 0);
g_tcp_set_non_blocking(v->sck); g_tcp_set_non_blocking(v->sck);
g_tcp_set_no_delay(v->sck); g_tcp_set_no_delay(v->sck);
/* protocal version */ /* protocal version */
@ -868,7 +869,7 @@ lib_mod_connect(struct vnc* v)
{ {
in_uint32_be(s, i); in_uint32_be(s, i);
g_sprintf(text, "security level is %d (1 = none, 2 = standard)", i); g_sprintf(text, "security level is %d (1 = none, 2 = standard)", i);
v->server_msg(v, text); v->server_msg(v, text, 0);
if (i == 1) /* none */ if (i == 1) /* none */
{ {
check_sec_result = 0; check_sec_result = 0;
@ -899,25 +900,25 @@ lib_mod_connect(struct vnc* v)
in_uint32_be(s, i); in_uint32_be(s, i);
if (i != 0) if (i != 0)
{ {
v->server_msg(v, "password failed"); v->server_msg(v, "password failed", 0);
error = 2; error = 2;
} }
else else
{ {
v->server_msg(v, "password ok"); v->server_msg(v, "password ok", 0);
} }
} }
} }
if (error == 0) if (error == 0)
{ {
v->server_msg(v, "sending share flag"); v->server_msg(v, "sending share flag", 0);
init_stream(s, 8192); init_stream(s, 8192);
s->data[0] = 1; s->data[0] = 1;
error = lib_send(v, s->data, 1); /* share flag */ error = lib_send(v, s->data, 1); /* share flag */
} }
if (error == 0) if (error == 0)
{ {
v->server_msg(v, "receiving server init"); v->server_msg(v, "receiving server init", 0);
error = lib_recv(v, s->data, 4); /* server init */ error = lib_recv(v, s->data, 4); /* server init */
} }
if (error == 0) if (error == 0)
@ -925,14 +926,14 @@ lib_mod_connect(struct vnc* v)
in_uint16_be(s, v->mod_width); in_uint16_be(s, v->mod_width);
in_uint16_be(s, v->mod_height); in_uint16_be(s, v->mod_height);
init_stream(pixel_format, 8192); init_stream(pixel_format, 8192);
v->server_msg(v, "receiving pixel format"); v->server_msg(v, "receiving pixel format", 0);
error = lib_recv(v, pixel_format->data, 16); error = lib_recv(v, pixel_format->data, 16);
} }
if (error == 0) if (error == 0)
{ {
v->mod_bpp = v->server_bpp; v->mod_bpp = v->server_bpp;
init_stream(s, 8192); init_stream(s, 8192);
v->server_msg(v, "receiving name length"); v->server_msg(v, "receiving name length", 0);
error = lib_recv(v, s->data, 4); /* name len */ error = lib_recv(v, s->data, 4); /* name len */
} }
if (error == 0) if (error == 0)
@ -944,7 +945,7 @@ lib_mod_connect(struct vnc* v)
} }
else else
{ {
v->server_msg(v, "receiving name"); v->server_msg(v, "receiving name", 0);
error = lib_recv(v, v->mod_name, i); error = lib_recv(v, v->mod_name, i);
v->mod_name[i] = 0; v->mod_name[i] = 0;
} }
@ -996,7 +997,7 @@ lib_mod_connect(struct vnc* v)
out_uint8s(pixel_format, 3); /* pad */ out_uint8s(pixel_format, 3); /* pad */
} }
out_uint8a(s, pixel_format->data, 16); out_uint8a(s, pixel_format->data, 16);
v->server_msg(v, "sending pixel format"); v->server_msg(v, "sending pixel format", 0);
error = lib_send(v, s->data, 20); error = lib_send(v, s->data, 20);
} }
if (error == 0) if (error == 0)
@ -1009,7 +1010,7 @@ lib_mod_connect(struct vnc* v)
out_uint32_be(s, 0); /* raw */ out_uint32_be(s, 0); /* raw */
out_uint32_be(s, 1); /* copy rect */ out_uint32_be(s, 1); /* copy rect */
out_uint32_be(s, 0xffffff11); /* cursor */ out_uint32_be(s, 0xffffff11); /* cursor */
v->server_msg(v, "sending encodings"); v->server_msg(v, "sending encodings", 0);
error = lib_send(v, s->data, 4 + 3 * 4); error = lib_send(v, s->data, 4 + 3 * 4);
} }
if (error == 0) if (error == 0)
@ -1022,14 +1023,14 @@ lib_mod_connect(struct vnc* v)
out_uint16_be(s, 0); out_uint16_be(s, 0);
out_uint16_be(s, v->mod_width); out_uint16_be(s, v->mod_width);
out_uint16_be(s, v->mod_height); out_uint16_be(s, v->mod_height);
v->server_msg(v, "sending framebuffer update request"); v->server_msg(v, "sending framebuffer update request", 0);
error = lib_send(v, s->data, 10); error = lib_send(v, s->data, 10);
} }
if (error == 0) if (error == 0)
{ {
if (v->server_bpp != v->mod_bpp) if (v->server_bpp != v->mod_bpp)
{ {
v->server_msg(v, "error - server and client bpp don't match"); v->server_msg(v, "error - server and client bpp don't match", 0);
error = 1; error = 1;
} }
} }
@ -1041,18 +1042,18 @@ lib_mod_connect(struct vnc* v)
g_memset(cursor_data + (32 * (32 * 3) - 2 * 32 * 3), 0xff, 9); g_memset(cursor_data + (32 * (32 * 3) - 2 * 32 * 3), 0xff, 9);
g_memset(cursor_data + (32 * (32 * 3) - 3 * 32 * 3), 0xff, 9); g_memset(cursor_data + (32 * (32 * 3) - 3 * 32 * 3), 0xff, 9);
g_memset(cursor_mask, 0xff, 32 * (32 / 8)); g_memset(cursor_mask, 0xff, 32 * (32 / 8));
v->server_msg(v, "sending cursor"); v->server_msg(v, "sending cursor", 0);
error = v->server_set_cursor(v, 3, 3, cursor_data, cursor_mask); error = v->server_set_cursor(v, 3, 3, cursor_data, cursor_mask);
} }
free_stream(s); free_stream(s);
free_stream(pixel_format); free_stream(pixel_format);
if (error == 0) if (error == 0)
{ {
v->server_msg(v, "connection complete, connected ok"); v->server_msg(v, "connection complete, connected ok", 0);
} }
else else
{ {
v->server_msg(v, "error - problem connecting"); v->server_msg(v, "error - problem connecting", 0);
} }
return error; return error;
} }

23
vnc/vnc.h
View File

@ -40,18 +40,35 @@ struct vnc
/* server functions */ /* server functions */
int (*server_begin_update)(struct vnc* v); int (*server_begin_update)(struct vnc* v);
int (*server_end_update)(struct vnc* v); int (*server_end_update)(struct vnc* v);
int (*server_fill_rect)(struct vnc* v, int x, int y, int cx, int cy, int (*server_fill_rect)(struct vnc* v, int x, int y, int cx, int cy);
int color);
int (*server_screen_blt)(struct vnc* v, int x, int y, int cx, int cy, int (*server_screen_blt)(struct vnc* v, int x, int y, int cx, int cy,
int srcx, int srcy); int srcx, int srcy);
int (*server_paint_rect)(struct vnc* v, int x, int y, int cx, int cy, int (*server_paint_rect)(struct vnc* v, int x, int y, int cx, int cy,
char* data); char* data);
int (*server_set_cursor)(struct vnc* v, int x, int y, char* data, char* mask); int (*server_set_cursor)(struct vnc* v, int x, int y, char* data, char* mask);
int (*server_palette)(struct vnc* v, int* palette); int (*server_palette)(struct vnc* v, int* palette);
int (*server_msg)(struct vnc* v, char* msg); int (*server_msg)(struct vnc* v, char* msg, int code);
int (*server_is_term)(struct vnc* v); int (*server_is_term)(struct vnc* v);
int (*server_set_clip)(struct vnc* v, int x, int y, int cx, int cy); int (*server_set_clip)(struct vnc* v, int x, int y, int cx, int cy);
int (*server_reset_clip)(struct vnc* v); int (*server_reset_clip)(struct vnc* v);
int (*server_set_fgcolor)(struct vnc* v, int fgcolor);
int (*server_set_bgcolor)(struct vnc* v, int bgcolor);
int (*server_set_opcode)(struct vnc* v, int opcode);
int (*server_set_mixmode)(struct vnc* v, int mixmode);
int (*server_set_brush)(struct vnc* v, int x_orgin, int y_orgin,
int style, char* pattern);
int (*server_set_pen)(struct vnc* v, int style,
int width);
int (*server_draw_line)(struct vnc* v, int x1, int y1, int x2, int y2);
int (*server_add_char)(struct vnc* v, int font, int charactor,
int offset, int baseline,
int width, int height, char* data);
int (*server_draw_text)(struct vnc* v, int font,
int flags, int mixmode, int clip_left, int clip_top,
int clip_right, int clip_bottom,
int box_left, int box_top,
int box_right, int box_bottom,
int x, int y, char* data, int data_len);
/* common */ /* common */
long handle; /* pointer to self as long */ long handle; /* pointer to self as long */
long wm; long wm;

17
xrdp/funcs.c
View File

@ -83,6 +83,23 @@ rect_intersect(struct xrdp_rect* in1, struct xrdp_rect* in2,
return rv; return rv;
} }
/*****************************************************************************/
/* returns boolean */
int APP_CC
rect_contained_by(struct xrdp_rect* in1, int left, int top,
int right, int bottom)
{
if (left < in1->left || top < in1->top ||
right > in1->right || bottom > in1->bottom)
{
return 0;
}
else
{
return 1;
}
}
/*****************************************************************************/ /*****************************************************************************/
/* adjust the bounds to fit in the bitmap */ /* adjust the bounds to fit in the bitmap */
/* return false if there is nothing to draw else return true */ /* return false if there is nothing to draw else return true */

113
xrdp/xrdp.c
View File

@ -32,13 +32,59 @@ static int g_threadid = 0; /* main threadid */
#if defined(_WIN32) #if defined(_WIN32)
static CRITICAL_SECTION g_term_mutex; static CRITICAL_SECTION g_term_mutex;
static CRITICAL_SECTION g_sync_mutex;
static CRITICAL_SECTION g_sync1_mutex;
#else #else
static pthread_mutex_t g_term_mutex = PTHREAD_MUTEX_INITIALIZER; static pthread_mutex_t g_term_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t g_sync_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t g_sync1_mutex = PTHREAD_MUTEX_INITIALIZER;
#endif #endif
static int g_term = 0; static int g_term = 0;
/* syncronize stuff */
static int g_sync_command = 0;
static long g_sync_result = 0;
static long g_sync_param1 = 0;
static long g_sync_param2 = 0;
static long (*g_sync_func)(long param1, long param2);
/*****************************************************************************/ /*****************************************************************************/
void long APP_CC
g_xrdp_sync(long (*sync_func)(long param1, long param2), long sync_param1,
long sync_param2)
{
long sync_result;
int sync_command;
#if defined(_WIN32)
EnterCriticalSection(&g_sync1_mutex);
#else
pthread_mutex_lock(&g_sync1_mutex);
#endif
g_lock();
g_sync_param1 = sync_param1;
g_sync_param2 = sync_param2;
g_sync_func = sync_func;
g_sync_command = 100;
g_unlock();
do
{
g_sleep(100);
g_lock();
sync_command = g_sync_command;
sync_result = g_sync_result;
g_unlock();
}
while (sync_command != 0);
#if defined(_WIN32)
LeaveCriticalSection(&g_sync1_mutex);
#else
pthread_mutex_unlock(&g_sync1_mutex);
#endif
return sync_result;
}
/*****************************************************************************/
void DEFAULT_CC
xrdp_shutdown(int sig) xrdp_shutdown(int sig)
{ {
struct xrdp_listen* listen; struct xrdp_listen* listen;
@ -56,15 +102,11 @@ xrdp_shutdown(int sig)
g_set_term(1); g_set_term(1);
g_sleep(1000); g_sleep(1000);
xrdp_listen_delete(listen); xrdp_listen_delete(listen);
#if defined(_WIN32)
WSACleanup();
DeleteCriticalSection(&g_term_mutex);
#endif
} }
} }
/*****************************************************************************/ /*****************************************************************************/
int int APP_CC
g_is_term(void) g_is_term(void)
{ {
int rv; int rv;
@ -82,7 +124,29 @@ g_is_term(void)
} }
/*****************************************************************************/ /*****************************************************************************/
void void APP_CC
g_lock(void)
{
#if defined(_WIN32)
EnterCriticalSection(&g_sync_mutex);
#else
pthread_mutex_lock(&g_sync_mutex);
#endif
}
/*****************************************************************************/
void APP_CC
g_unlock(void)
{
#if defined(_WIN32)
LeaveCriticalSection(&g_sync_mutex);
#else
pthread_mutex_unlock(&g_sync_mutex);
#endif
}
/*****************************************************************************/
void APP_CC
g_set_term(int in_val) g_set_term(int in_val)
{ {
#if defined(_WIN32) #if defined(_WIN32)
@ -97,7 +161,7 @@ g_set_term(int in_val)
} }
/*****************************************************************************/ /*****************************************************************************/
void void DEFAULT_CC
pipe_sig(int sig_num) pipe_sig(int sig_num)
{ {
/* do nothing */ /* do nothing */
@ -105,7 +169,26 @@ pipe_sig(int sig_num)
} }
/*****************************************************************************/ /*****************************************************************************/
int void APP_CC
g_loop(void)
{
g_lock();
if (g_sync_command != 0)
{
if (g_sync_func != 0)
{
if (g_sync_command == 100)
{
g_sync_result = g_sync_func(g_sync_param1, g_sync_param2);
}
}
g_sync_command = 0;
}
g_unlock();
}
/*****************************************************************************/
int DEFAULT_CC
main(int argc, char** argv) main(int argc, char** argv)
{ {
int test; int test;
@ -113,7 +196,7 @@ main(int argc, char** argv)
#if defined(_WIN32) #if defined(_WIN32)
WSADATA w; WSADATA w;
#endif #endif
/* check compiled endian with actual edian */ /* check compiled endian with actual edian */
test = 1; test = 1;
host_be = !((int)(*(unsigned char*)(&test))); host_be = !((int)(*(unsigned char*)(&test)));
@ -141,6 +224,8 @@ main(int argc, char** argv)
#if defined(_WIN32) #if defined(_WIN32)
WSAStartup(2, &w); WSAStartup(2, &w);
InitializeCriticalSection(&g_term_mutex); InitializeCriticalSection(&g_term_mutex);
InitializeCriticalSection(&g_sync_mutex);
InitializeCriticalSection(&g_sync1_mutex);
#endif #endif
g_threadid = g_get_threadid(); g_threadid = g_get_threadid();
g_listen = xrdp_listen_create(); g_listen = xrdp_listen_create();
@ -149,5 +234,13 @@ main(int argc, char** argv)
g_signal(13, pipe_sig); /* sig pipe */ g_signal(13, pipe_sig); /* sig pipe */
g_signal(15, xrdp_shutdown); /* SIGTERM */ g_signal(15, xrdp_shutdown); /* SIGTERM */
xrdp_listen_main_loop(g_listen); xrdp_listen_main_loop(g_listen);
#if defined(_WIN32)
/* I don't think it ever gets here */
WSACleanup();
DeleteCriticalSection(&g_term_mutex);
DeleteCriticalSection(&g_sync_mutex);
DeleteCriticalSection(&g_sync1_mutex);
xrdp_listen_delete(g_listen);
#endif
return 0; return 0;
} }

69
xrdp/xrdp.h
View File

@ -34,10 +34,19 @@
#include "file.h" #include "file.h"
/* xrdp.c */ /* xrdp.c */
int long APP_CC
g_xrdp_sync(long (*sync_func)(long param1, long param2), long sync_param1,
long sync_param2);
int APP_CC
g_is_term(void); g_is_term(void);
void void APP_CC
g_set_term(int in_val); g_set_term(int in_val);
void APP_CC
g_lock(void);
void APP_CC
g_unlock(void);
void APP_CC
g_loop(void);
/* xrdp_cache.c */ /* xrdp_cache.c */
struct xrdp_cache* APP_CC struct xrdp_cache* APP_CC
@ -183,6 +192,11 @@ int APP_CC
xrdp_bitmap_from_screenx(struct xrdp_bitmap* self, int x); xrdp_bitmap_from_screenx(struct xrdp_bitmap* self, int x);
int APP_CC int APP_CC
xrdp_bitmap_from_screeny(struct xrdp_bitmap* self, int y); xrdp_bitmap_from_screeny(struct xrdp_bitmap* self, int y);
int APP_CC
xrdp_bitmap_get_screen_clip(struct xrdp_bitmap* self,
struct xrdp_painter* painter,
struct xrdp_rect* rect,
int* dx, int* dy);
/* xrdp_painter.c */ /* xrdp_painter.c */
struct xrdp_painter* APP_CC struct xrdp_painter* APP_CC
@ -205,10 +219,6 @@ xrdp_painter_fill_rect(struct xrdp_painter* self,
struct xrdp_bitmap* bitmap, struct xrdp_bitmap* bitmap,
int x, int y, int cx, int cy); int x, int y, int cx, int cy);
int APP_CC int APP_CC
xrdp_painter_fill_rect2(struct xrdp_painter* self,
struct xrdp_bitmap* bitmap,
int x, int y, int cx, int cy);
int APP_CC
xrdp_painter_draw_bitmap(struct xrdp_painter* self, xrdp_painter_draw_bitmap(struct xrdp_painter* self,
struct xrdp_bitmap* bitmap, struct xrdp_bitmap* bitmap,
struct xrdp_bitmap* to_draw, struct xrdp_bitmap* to_draw,
@ -222,11 +232,24 @@ xrdp_painter_draw_text(struct xrdp_painter* self,
struct xrdp_bitmap* bitmap, struct xrdp_bitmap* bitmap,
int x, int y, char* text); int x, int y, char* text);
int APP_CC int APP_CC
xrdp_painter_draw_text2(struct xrdp_painter* self,
struct xrdp_bitmap* bitmap,
int font, int flags, int mixmode,
int clip_left, int clip_top,
int clip_right, int clip_bottom,
int box_left, int box_top,
int box_right, int box_bottom,
int x, int y, char* data, int data_len);
int APP_CC
xrdp_painter_copy(struct xrdp_painter* self, xrdp_painter_copy(struct xrdp_painter* self,
struct xrdp_bitmap* src, struct xrdp_bitmap* src,
struct xrdp_bitmap* dst, struct xrdp_bitmap* dst,
int x, int y, int cx, int cy, int x, int y, int cx, int cy,
int srcx, int srcy); int srcx, int srcy);
int APP_CC
xrdp_painter_line(struct xrdp_painter* self,
struct xrdp_bitmap* bitmap,
int x1, int y1, int x2, int y2);
/* xrdp_font.c */ /* xrdp_font.c */
struct xrdp_font* APP_CC struct xrdp_font* APP_CC
@ -244,6 +267,9 @@ int APP_CC
rect_intersect(struct xrdp_rect* in1, struct xrdp_rect* in2, rect_intersect(struct xrdp_rect* in1, struct xrdp_rect* in2,
struct xrdp_rect* out); struct xrdp_rect* out);
int APP_CC int APP_CC
rect_contained_by(struct xrdp_rect* in1, int left, int top,
int right, int bottom);
int APP_CC
check_bounds(struct xrdp_bitmap* b, int* x, int* y, int* cx, int* cy); check_bounds(struct xrdp_bitmap* b, int* x, int* y, int* cx, int* cy);
char APP_CC char APP_CC
get_char_from_scan_code(int device_flags, int scan_code, int* keys, get_char_from_scan_code(int device_flags, int scan_code, int* keys,
@ -271,8 +297,7 @@ server_begin_update(struct xrdp_mod* mod);
int DEFAULT_CC int DEFAULT_CC
server_end_update(struct xrdp_mod* mod); server_end_update(struct xrdp_mod* mod);
int DEFAULT_CC int DEFAULT_CC
server_fill_rect(struct xrdp_mod* mod, int x, int y, int cx, int cy, server_fill_rect(struct xrdp_mod* mod, int x, int y, int cx, int cy);
int color);
int DEFAULT_CC int DEFAULT_CC
server_screen_blt(struct xrdp_mod* mod, int x, int y, int cx, int cy, server_screen_blt(struct xrdp_mod* mod, int x, int y, int cx, int cy,
int srcx, int srcy); int srcx, int srcy);
@ -285,10 +310,36 @@ server_set_pointer(struct xrdp_mod* mod, int x, int y,
int DEFAULT_CC int DEFAULT_CC
server_palette(struct xrdp_mod* mod, int* palette); server_palette(struct xrdp_mod* mod, int* palette);
int DEFAULT_CC int DEFAULT_CC
server_msg(struct xrdp_mod* mod, char* msg); server_msg(struct xrdp_mod* mod, char* msg, int code);
int DEFAULT_CC int DEFAULT_CC
server_is_term(struct xrdp_mod* mod); server_is_term(struct xrdp_mod* mod);
int DEFAULT_CC int DEFAULT_CC
server_set_clip(struct xrdp_mod* mod, int x, int y, int cx, int cy); server_set_clip(struct xrdp_mod* mod, int x, int y, int cx, int cy);
int DEFAULT_CC int DEFAULT_CC
server_reset_clip(struct xrdp_mod* mod); server_reset_clip(struct xrdp_mod* mod);
int DEFAULT_CC
server_set_fgcolor(struct xrdp_mod* mod, int fgcolor);
int DEFAULT_CC
server_set_bgcolor(struct xrdp_mod* mod, int bgcolor);
int DEFAULT_CC
server_set_opcode(struct xrdp_mod* mod, int opcode);
int DEFAULT_CC
server_set_mixmode(struct xrdp_mod* mod, int mixmode);
int DEFAULT_CC
server_set_brush(struct xrdp_mod* mod, int x_orgin, int y_orgin,
int style, char* pattern);
int DEFAULT_CC
server_set_pen(struct xrdp_mod* mod, int style, int width);
int DEFAULT_CC
server_draw_line(struct xrdp_mod* mod, int x1, int y1, int x2, int y2);
int DEFAULT_CC
server_add_char(struct xrdp_mod* mod, int font, int charactor,
int offset, int baseline,
int width, int height, char* data);
int DEFAULT_CC
server_draw_text(struct xrdp_mod* mod, int font,
int flags, int mixmode, int clip_left, int clip_top,
int clip_right, int clip_bottom,
int box_left, int box_top,
int box_right, int box_bottom,
int x, int y, char* data, int data_len);

6
xrdp/xrdp.ini
View File

@ -34,3 +34,9 @@ ip=ask
port=-1 port=-1
username=ask username=ask
password=ask password=ask
[vnc5]
name=rdp-any
lib=../libradop/libradop.so
ip=ask205.5.61.3
port=ask3389

56
xrdp/xrdp_bitmap.c
View File

@ -773,6 +773,7 @@ xrdp_bitmap_draw_focus_box(struct xrdp_bitmap* self,
painter->rop = 0xf0; painter->rop = 0xf0;
xrdp_painter_begin_update(painter); xrdp_painter_begin_update(painter);
painter->use_clip = 0; painter->use_clip = 0;
painter->mix_mode = 1;
painter->brush.pattern[0] = 0xaa; painter->brush.pattern[0] = 0xaa;
painter->brush.pattern[1] = 0x55; painter->brush.pattern[1] = 0x55;
painter->brush.pattern[2] = 0xaa; painter->brush.pattern[2] = 0xaa;
@ -787,15 +788,16 @@ xrdp_bitmap_draw_focus_box(struct xrdp_bitmap* self,
painter->fg_color = self->wm->black; painter->fg_color = self->wm->black;
painter->bg_color = self->parent->bg_color; painter->bg_color = self->parent->bg_color;
/* top */ /* top */
xrdp_painter_fill_rect2(painter, self, x, y, cx, 1); xrdp_painter_fill_rect(painter, self, x, y, cx, 1);
/* bottom */ /* bottom */
xrdp_painter_fill_rect2(painter, self, x, y + (cy - 1), cx, 1); xrdp_painter_fill_rect(painter, self, x, y + (cy - 1), cx, 1);
/* left */ /* left */
xrdp_painter_fill_rect2(painter, self, x, y + 1, 1, cy - 2); xrdp_painter_fill_rect(painter, self, x, y + 1, 1, cy - 2);
/* right */ /* right */
xrdp_painter_fill_rect2(painter, self, x + (cx - 1), y + 1, 1, cy - 2); xrdp_painter_fill_rect(painter, self, x + (cx - 1), y + 1, 1, cy - 2);
xrdp_painter_end_update(painter); xrdp_painter_end_update(painter);
painter->rop = 0xcc; painter->rop = 0xcc;
painter->mix_mode = 0;
return 0; return 0;
} }
@ -905,7 +907,7 @@ xrdp_bitmap_invalidate(struct xrdp_bitmap* self, struct xrdp_rect* rect)
return 0; return 0;
} }
painter->clip = *rect; painter->clip = *rect;
painter->use_clip = 1; painter->use_clip = &painter->clip;
} }
xrdp_painter_begin_update(painter); xrdp_painter_begin_update(painter);
if (self->type == WND_TYPE_WND) /* 1 */ if (self->type == WND_TYPE_WND) /* 1 */
@ -1012,8 +1014,8 @@ xrdp_bitmap_invalidate(struct xrdp_bitmap* self, struct xrdp_rect* rect)
} }
else if (self->type == WND_TYPE_IMAGE) /* 4 */ else if (self->type == WND_TYPE_IMAGE) /* 4 */
{ {
xrdp_painter_draw_bitmap(painter, self, self, 0, 0, self->width, xrdp_painter_copy(painter, self, self, 0, 0, self->width,
self->height); self->height, 0, 0);
} }
else if (self->type == WND_TYPE_EDIT) /* 5 */ else if (self->type == WND_TYPE_EDIT) /* 5 */
{ {
@ -1066,7 +1068,7 @@ xrdp_bitmap_invalidate(struct xrdp_bitmap* self, struct xrdp_rect* rect)
else else
g_strncpy(text, self->caption1, self->edit_pos); g_strncpy(text, self->caption1, self->edit_pos);
w = xrdp_painter_text_width(painter, text); w = xrdp_painter_text_width(painter, text);
painter->fg_color = self->wm->black; painter->fg_color = self->wm->white;
painter->rop = 0x5a; painter->rop = 0x5a;
xrdp_painter_fill_rect(painter, self, 4 + w, 3, 2, self->height - 6); xrdp_painter_fill_rect(painter, self, 4 + w, 3, 2, self->height - 6);
} }
@ -1517,3 +1519,41 @@ xrdp_bitmap_from_screeny(struct xrdp_bitmap* self, int y)
} }
return i; return i;
} }
/*****************************************************************************/
int APP_CC
xrdp_bitmap_get_screen_clip(struct xrdp_bitmap* self,
struct xrdp_painter* painter,
struct xrdp_rect* rect,
int* dx, int* dy)
{
int ldx;
int ldy;
if (painter->use_clip)
{
*rect = painter->clip;
}
else
{
rect->left = 0;
rect->top = 0;
rect->right = self->width;
rect->bottom = self->height;
}
ldx = xrdp_bitmap_to_screenx(self, 0);
ldy = xrdp_bitmap_to_screeny(self, 0);
rect->left += ldx;
rect->top += ldy;
rect->right += ldx;
rect->bottom += ldy;
if (dx != 0)
{
*dx = ldx;
}
if (dy != 0)
{
*dy = ldy;
}
return 0;
}

138
xrdp/xrdp_interface.c
View File

@ -107,15 +107,13 @@ server_end_update(struct xrdp_mod* mod)
/*****************************************************************************/ /*****************************************************************************/
int DEFAULT_CC int DEFAULT_CC
server_fill_rect(struct xrdp_mod* mod, int x, int y, int cx, int cy, server_fill_rect(struct xrdp_mod* mod, int x, int y, int cx, int cy)
int color)
{ {
struct xrdp_wm* wm; struct xrdp_wm* wm;
struct xrdp_painter* p; struct xrdp_painter* p;
wm = (struct xrdp_wm*)mod->wm; wm = (struct xrdp_wm*)mod->wm;
p = (struct xrdp_painter*)mod->painter; p = (struct xrdp_painter*)mod->painter;
p->fg_color = color;
xrdp_painter_fill_rect(p, wm->screen, x, y, cx, cy); xrdp_painter_fill_rect(p, wm->screen, x, y, cx, cy);
return 0; return 0;
} }
@ -147,7 +145,7 @@ server_paint_rect(struct xrdp_mod* mod, int x, int y, int cx, int cy,
wm = (struct xrdp_wm*)mod->wm; wm = (struct xrdp_wm*)mod->wm;
p = (struct xrdp_painter*)mod->painter; p = (struct xrdp_painter*)mod->painter;
b = xrdp_bitmap_create_with_data(cx, cy, wm->screen->bpp, data, wm); b = xrdp_bitmap_create_with_data(cx, cy, wm->screen->bpp, data, wm);
xrdp_painter_draw_bitmap(p, wm->screen, b, x, y, cx, cy); xrdp_painter_copy(p, b, wm->screen, x, y, cx, cy, 0, 0);
xrdp_bitmap_delete(b); xrdp_bitmap_delete(b);
return 0; return 0;
} }
@ -181,11 +179,17 @@ server_palette(struct xrdp_mod* mod, int* palette)
/*****************************************************************************/ /*****************************************************************************/
int DEFAULT_CC int DEFAULT_CC
server_msg(struct xrdp_mod* mod, char* msg) server_msg(struct xrdp_mod* mod, char* msg, int code)
{ {
struct xrdp_wm* wm; struct xrdp_wm* wm;
struct xrdp_bitmap* but; struct xrdp_bitmap* but;
if (code == 1)
{
g_printf(msg);
g_printf("\n\r");
return 0;
}
wm = (struct xrdp_wm*)mod->wm; wm = (struct xrdp_wm*)mod->wm;
list_add_item(wm->log, (long)g_strdup(msg)); list_add_item(wm->log, (long)g_strdup(msg));
if (wm->log_wnd == 0) if (wm->log_wnd == 0)
@ -244,3 +248,127 @@ server_reset_clip(struct xrdp_mod* mod)
p = (struct xrdp_painter*)mod->painter; p = (struct xrdp_painter*)mod->painter;
return xrdp_painter_clr_clip(p); return xrdp_painter_clr_clip(p);
} }
/*****************************************************************************/
int DEFAULT_CC
server_set_fgcolor(struct xrdp_mod* mod, int fgcolor)
{
struct xrdp_painter* p;
p = (struct xrdp_painter*)mod->painter;
p->fg_color = fgcolor;
p->pen.color = p->fg_color;
return 0;
}
/*****************************************************************************/
int DEFAULT_CC
server_set_bgcolor(struct xrdp_mod* mod, int bgcolor)
{
struct xrdp_painter* p;
p = (struct xrdp_painter*)mod->painter;
p->bg_color = bgcolor;
return 0;
}
/*****************************************************************************/
int DEFAULT_CC
server_set_opcode(struct xrdp_mod* mod, int opcode)
{
struct xrdp_painter* p;
p = (struct xrdp_painter*)mod->painter;
p->rop = opcode;
return 0;
}
/*****************************************************************************/
int DEFAULT_CC
server_set_mixmode(struct xrdp_mod* mod, int mixmode)
{
struct xrdp_painter* p;
p = (struct xrdp_painter*)mod->painter;
p->mix_mode = mixmode;
return 0;
}
/*****************************************************************************/
int DEFAULT_CC
server_set_brush(struct xrdp_mod* mod, int x_orgin, int y_orgin,
int style, char* pattern)
{
struct xrdp_painter* p;
p = (struct xrdp_painter*)mod->painter;
p->brush.x_orgin = x_orgin;
p->brush.y_orgin = y_orgin;
p->brush.style = style;
g_memcpy(p->brush.pattern, pattern, 8);
return 0;
}
/*****************************************************************************/
int DEFAULT_CC
server_set_pen(struct xrdp_mod* mod, int style, int width)
{
struct xrdp_painter* p;
p = (struct xrdp_painter*)mod->painter;
p->pen.style = style;
p->pen.width = width;
return 0;
}
/*****************************************************************************/
int DEFAULT_CC
server_draw_line(struct xrdp_mod* mod, int x1, int y1, int x2, int y2)
{
struct xrdp_wm* wm;
struct xrdp_painter* p;
wm = (struct xrdp_wm*)mod->wm;
p = (struct xrdp_painter*)mod->painter;
return xrdp_painter_line(p, wm->screen, x1, y1, x2, y2);
}
/*****************************************************************************/
int DEFAULT_CC
server_add_char(struct xrdp_mod* mod, int font, int charactor,
int offset, int baseline,
int width, int height, char* data)
{
struct xrdp_font_char fi;
fi.offset = offset;
fi.baseline = baseline;
fi.width = width;
fi.height = height;
fi.incby = 0;
fi.data = data;
return libxrdp_orders_send_font(((struct xrdp_wm*)mod->wm)->session,
&fi, font, charactor);
}
/*****************************************************************************/
int DEFAULT_CC
server_draw_text(struct xrdp_mod* mod, int font,
int flags, int mixmode, int clip_left, int clip_top,
int clip_right, int clip_bottom,
int box_left, int box_top,
int box_right, int box_bottom,
int x, int y, char* data, int data_len)
{
struct xrdp_wm* wm;
struct xrdp_painter* p;
wm = (struct xrdp_wm*)mod->wm;
p = (struct xrdp_painter*)mod->painter;
return xrdp_painter_draw_text2(p, wm->screen, font, flags,
mixmode, clip_left, clip_top,
clip_right, clip_bottom,
box_left, box_top,
box_right, box_bottom,
x, y, data, data_len);
}

2
xrdp/xrdp_listen.c
View File

@ -149,6 +149,7 @@ xrdp_listen_main_loop(struct xrdp_listen* self)
error = g_tcp_bind(self->sck, "3389"); error = g_tcp_bind(self->sck, "3389");
if (error != 0) if (error != 0)
{ {
g_printf("listening on 3390\n\r");
error = g_tcp_bind(self->sck, "3390"); error = g_tcp_bind(self->sck, "3390");
} }
if (error != 0) if (error != 0)
@ -167,6 +168,7 @@ xrdp_listen_main_loop(struct xrdp_listen* self)
if (error == -1 && g_tcp_last_error_would_block(self->sck)) if (error == -1 && g_tcp_last_error_would_block(self->sck))
{ {
g_sleep(100); g_sleep(100);
g_loop();
} }
else if (error == -1) else if (error == -1)
{ {

29
xrdp/xrdp_login_wnd.c
View File

@ -89,6 +89,22 @@ xrdp_wm_popup_notify(struct xrdp_bitmap* wnd,
} }
#endif #endif
/*****************************************************************************/
/* called from main thread */
static long DEFAULT_CC
sync_unload(long param1, long param2)
{
return g_free_library(param1);
}
/*****************************************************************************/
/* called from main thread */
static long DEFAULT_CC
sync_load(long param1, long param2)
{
return g_load_library((char*)param1);
}
/*****************************************************************************/ /*****************************************************************************/
static int APP_CC static int APP_CC
xrdp_wm_setup_mod(struct xrdp_wm* self, xrdp_wm_setup_mod(struct xrdp_wm* self,
@ -102,7 +118,7 @@ xrdp_wm_setup_mod(struct xrdp_wm* self,
} }
if (self->mod_handle == 0) if (self->mod_handle == 0)
{ {
self->mod_handle = g_load_library(mod_data->lib); self->mod_handle = g_xrdp_sync(sync_load, (long)mod_data->lib, 0);
if (self->mod_handle != 0) if (self->mod_handle != 0)
{ {
func = g_get_proc_address(self->mod_handle, "mod_init"); func = g_get_proc_address(self->mod_handle, "mod_init");
@ -136,6 +152,15 @@ xrdp_wm_setup_mod(struct xrdp_wm* self,
self->mod->server_is_term = server_is_term; self->mod->server_is_term = server_is_term;
self->mod->server_set_clip = server_set_clip; self->mod->server_set_clip = server_set_clip;
self->mod->server_reset_clip = server_reset_clip; self->mod->server_reset_clip = server_reset_clip;
self->mod->server_set_fgcolor = server_set_fgcolor;
self->mod->server_set_bgcolor = server_set_bgcolor;
self->mod->server_set_opcode = server_set_opcode;
self->mod->server_set_mixmode = server_set_mixmode;
self->mod->server_set_brush = server_set_brush;
self->mod->server_set_pen = server_set_pen;
self->mod->server_draw_line = server_draw_line;
self->mod->server_add_char = server_add_char;
self->mod->server_draw_text = server_draw_text;
} }
} }
/* id self->mod is null, there must be a problem */ /* id self->mod is null, there must be a problem */
@ -306,7 +331,7 @@ xrdp_wm_ok_clicked(struct xrdp_bitmap* wnd)
{ {
/* totaly free mod */ /* totaly free mod */
wm->mod_exit(wm->mod); wm->mod_exit(wm->mod);
g_free_library(wm->mod_handle); g_xrdp_sync(sync_unload, wm->mod_handle, 0);
wm->mod = 0; wm->mod = 0;
wm->mod_handle = 0; wm->mod_handle = 0;
wm->mod_init = 0; wm->mod_init = 0;

630
xrdp/xrdp_painter.c
View File

@ -132,7 +132,7 @@ int APP_CC
xrdp_painter_set_clip(struct xrdp_painter* self, xrdp_painter_set_clip(struct xrdp_painter* self,
int x, int y, int cx, int cy) int x, int y, int cx, int cy)
{ {
self->use_clip = 1; self->use_clip = &self->clip;
self->clip.left = x; self->clip.left = x;
self->clip.top = y; self->clip.top = y;
self->clip.right = x + cx; self->clip.right = x + cx;
@ -174,275 +174,6 @@ xrdp_painter_rop(int rop, int src, int dst)
return dst; return dst;
} }
/*****************************************************************************/
/* fill in an area of the screen with one color */
int APP_CC
xrdp_painter_fill_rect(struct xrdp_painter* self,
struct xrdp_bitmap* bitmap,
int x, int y, int cx, int cy)
{
int i;
struct xrdp_region* region;
struct xrdp_rect rect;
if (!check_bounds(bitmap, &x, &y, &cx, &cy))
{
return 0;
}
if (!xrdp_painter_clip_adj(self, &x, &y, &cx, &cy))
{
return 0;
}
/* todo data */
if (bitmap->type == WND_TYPE_BITMAP) /* 0 */
{
return 0;
}
region = xrdp_region_create(self->wm);
xrdp_wm_get_vis_region(self->wm, bitmap, x, y, cx, cy, region,
self->clip_children);
i = 0;
while (xrdp_region_get_rect(region, i, &rect) == 0)
{
if (!ISRECTEMPTY(rect))
{
DEBUG(("sending rect order %d %d %d %d\n\r",
rect.left, rect.top,
rect.right, rect.bottom));
libxrdp_orders_rect(self->session, rect.left, rect.top,
rect.right - rect.left,
rect.bottom - rect.top,
self->fg_color, 0);
}
i++;
}
xrdp_region_delete(region);
return 0;
}
/*****************************************************************************/
/* fill in an area of the screen with opcodes and patterns */
/* todo, this needs work */
int APP_CC
xrdp_painter_fill_rect2(struct xrdp_painter* self,
struct xrdp_bitmap* bitmap,
int x, int y, int cx, int cy)
{
int i;
struct xrdp_region* region;
struct xrdp_rect rect;
if (!check_bounds(bitmap, &x, &y, &cx, &cy))
{
return 0;
}
if (!xrdp_painter_clip_adj(self, &x, &y, &cx, &cy))
{
return 0;
}
/* todo data */
if (bitmap->type == WND_TYPE_BITMAP) /* 0 */
{
return 0;
}
region = xrdp_region_create(self->wm);
xrdp_wm_get_vis_region(self->wm, bitmap, x, y, cx, cy, region,
self->clip_children);
i = 0;
while (xrdp_region_get_rect(region, i, &rect) == 0)
{
if (!ISRECTEMPTY(rect))
{
DEBUG(("sending rect2 order %d %d %d %d\n\r",
rect.left, rect.top,
rect.right, rect.bottom));
libxrdp_orders_pat_blt(self->session, rect.left, rect.top,
rect.right - rect.left,
rect.bottom - rect.top,
self->rop, self->bg_color, self->fg_color,
&self->brush, 0);
}
i++;
}
xrdp_region_delete(region);
return 0;
}
#define SSW 64
#define SSH 60
/*****************************************************************************/
int APP_CC
xrdp_painter_draw_bitmap(struct xrdp_painter* self,
struct xrdp_bitmap* bitmap,
struct xrdp_bitmap* to_draw,
int x, int y, int cx, int cy)
{
int i;
int j;
int k;
int w;
int h;
int x1;
int y1;
int ok;
int srcx;
int srcy;
int bitmap_id;
int cache_id;
int cache_idx;
int palette_id;
struct xrdp_region* region;
struct xrdp_rect rect;
struct xrdp_rect rect1;
struct xrdp_rect rect2;
struct xrdp_bitmap* b;
/* todo data */
if (bitmap->type == WND_TYPE_BITMAP)
{
return 0;
}
region = xrdp_region_create(self->wm);
xrdp_wm_get_vis_region(self->wm, bitmap, x, y, cx, cy, region,
self->clip_children);
b = bitmap;
while (b != 0)
{
x = x + b->left;
y = y + b->top;
b = b->parent;
}
if (self->wm->client_info->use_bitmap_cache)
{
/*palette_id = xrdp_cache_add_palette(self->wm->cache, self->wm->palette);*/
palette_id = 0;
j = 0;
while (j < to_draw->height)
{
i = 0;
while (i < to_draw->width)
{
x1 = x + i;
y1 = y + j;
w = MIN(SSW, to_draw->width - i);
h = MIN(SSH, to_draw->height - j);
b = xrdp_bitmap_create(w, h, self->wm->screen->bpp, 0, self->wm);
#ifdef USE_CRC
xrdp_bitmap_copy_box_with_crc(to_draw, b, i, j, w, h);
#else
xrdp_bitmap_copy_box(to_draw, b, i, j, w, h);
#endif
bitmap_id = xrdp_cache_add_bitmap(self->wm->cache, b);
cache_id = HIWORD(bitmap_id);
cache_idx = LOWORD(bitmap_id);
k = 0;
while (xrdp_region_get_rect(region, k, &rect) == 0)
{
if (!ISRECTEMPTY(rect))
{
MAKERECT(rect1, x1, y1, w, h);
if (rect_intersect(&rect, &rect1, &rect2))
{
ok = 1;
if (self->use_clip)
{
rect = self->clip;
RECTOFFSET(rect, x, y);
if (!rect_intersect(&rect2, &rect, &rect1))
{
ok = 0;
}
}
else
{
rect1 = rect2;
}
if (ok)
{
rect1.right--;
rect1.bottom--;
/* check these so ms client don't crash */
if (x1 + w >= self->wm->screen->width)
{
w = self->wm->screen->width - x1;
}
if (y1 + h >= self->wm->screen->height)
{
h = self->wm->screen->height - y1;
}
if (w > 0 && h > 0 && x1 + w > 0 && y1 + h > 0)
{
srcx = 0;
srcy = 0;
if (x1 < 0)
{
w = w + x1;
srcx = srcx - x1;
x1 = 0;
}
if (y1 < 0)
{
h = h + y1;
srcy = srcy - y1;
y1 = 0;
}
//g_printf("%d %d %d %d %d %d\n", x1, y1, w, h, srcx, srcy);
DEBUG(("sending memblt order \n\r\
cache_id %d\n\r\
palette_id %d\n\r\
x %d\n\r\
y %d\n\r\
cx %d\n\r\
cy %d\n\r\
rop %d\n\r\
srcx %d\n\r\
srcy %d\n\r\
cache_idx %d\n\r",
cache_id, palette_id,
x1, y1, w, h, self->rop, srcx, srcy,
cache_idx));
libxrdp_orders_mem_blt(self->session, cache_id, palette_id,
x1, y1, w, h, self->rop, srcx, srcy,
cache_idx, &rect1);
}
}
}
}
k++;
}
i += SSW;
}
j += SSH;
}
}
else /* no bitmap cache */
{
/* make sure there is no waiting orders */
libxrdp_orders_force_send(self->session);
k = 0;
while (xrdp_region_get_rect(region, k, &rect) == 0)
{
x1 = rect.left;
y1 = rect.top;
w = rect.right - rect.left;
h = rect.bottom - rect.top;
b = xrdp_bitmap_create(w, h, self->wm->screen->bpp, 0, self->wm);
xrdp_bitmap_copy_box(to_draw, b, x1 - x, y1 - y, w, h);
xrdp_wm_send_bitmap(self->wm, b, x1, y1, w, h);
xrdp_bitmap_delete(b);
k++;
}
}
xrdp_region_delete(region);
return 0;
}
/*****************************************************************************/ /*****************************************************************************/
int APP_CC int APP_CC
xrdp_painter_text_width(struct xrdp_painter* self, char* text) xrdp_painter_text_width(struct xrdp_painter* self, char* text)
@ -491,6 +222,85 @@ xrdp_painter_text_height(struct xrdp_painter* self, char* text)
return rv; return rv;
} }
/*****************************************************************************/
/* fill in an area of the screen with one color */
int APP_CC
xrdp_painter_fill_rect(struct xrdp_painter* self,
struct xrdp_bitmap* bitmap,
int x, int y, int cx, int cy)
{
struct xrdp_rect clip_rect;
struct xrdp_rect draw_rect;
struct xrdp_rect rect;
struct xrdp_region* region;
int k;
int dx;
int dy;
if (self == 0)
{
return 0;
}
/* todo data */
if (bitmap->type == WND_TYPE_BITMAP) /* 0 */
{
return 0;
}
xrdp_bitmap_get_screen_clip(bitmap, self, &clip_rect, &dx, &dy);
region = xrdp_region_create(self->wm);
xrdp_wm_get_vis_region(self->wm, bitmap, x, y, cx, cy, region,
self->clip_children);
x += dx;
y += dy;
if (self->mix_mode == 0 && self->rop == 0xcc)
{
k = 0;
while (xrdp_region_get_rect(region, k, &rect) == 0)
{
if (rect_intersect(&rect, &clip_rect, &draw_rect))
{
libxrdp_orders_rect(self->session, x, y, cx, cy,
self->fg_color, &draw_rect);
}
k++;
}
}
else if (self->mix_mode == 0 &&
((self->rop & 0xf) == 0x0 || /* black */
(self->rop & 0xf) == 0xf || /* white */
(self->rop & 0xf) == 0x5)) /* DSTINVERT */
{
k = 0;
while (xrdp_region_get_rect(region, k, &rect) == 0)
{
if (rect_intersect(&rect, &clip_rect, &draw_rect))
{
libxrdp_orders_dest_blt(self->session, x, y, cx, cy,
self->rop, &draw_rect);
}
k++;
}
}
else
{
k = 0;
while (xrdp_region_get_rect(region, k, &rect) == 0)
{
if (rect_intersect(&rect, &clip_rect, &draw_rect))
{
libxrdp_orders_pat_blt(self->session, x, y, cx, cy,
self->rop, self->bg_color, self->fg_color,
&self->brush, &draw_rect);
}
k++;
}
}
xrdp_region_delete(region);
return 0;
}
/*****************************************************************************/ /*****************************************************************************/
int APP_CC int APP_CC
xrdp_painter_draw_text(struct xrdp_painter* self, xrdp_painter_draw_text(struct xrdp_painter* self,
@ -508,15 +318,20 @@ xrdp_painter_draw_text(struct xrdp_painter* self,
int index; int index;
int total_width; int total_width;
int total_height; int total_height;
int dx;
int dy;
char* data; char* data;
struct xrdp_region* region; struct xrdp_region* region;
struct xrdp_rect rect; struct xrdp_rect rect;
struct xrdp_rect clip_rect; struct xrdp_rect clip_rect;
struct xrdp_rect draw_rect; struct xrdp_rect draw_rect;
struct xrdp_bitmap* b;
struct xrdp_font* font; struct xrdp_font* font;
struct xrdp_font_char* font_item; struct xrdp_font_char* font_item;
if (self == 0)
{
return 0;
}
len = g_strlen(text); len = g_strlen(text);
if (len < 1) if (len < 1)
{ {
@ -548,65 +363,27 @@ xrdp_painter_draw_text(struct xrdp_painter* self,
total_width += k; total_width += k;
total_height = MAX(total_height, font_item->height); total_height = MAX(total_height, font_item->height);
} }
xrdp_bitmap_get_screen_clip(bitmap, self, &clip_rect, &dx, &dy);
region = xrdp_region_create(self->wm); region = xrdp_region_create(self->wm);
xrdp_wm_get_vis_region(self->wm, bitmap, x, y, total_width, total_height, xrdp_wm_get_vis_region(self->wm, bitmap, x, y, total_width, total_height,
region, self->clip_children); region, self->clip_children);
b = bitmap; x += dx;
while (b != 0) y += dy;
{
x = x + b->left;
y = y + b->top;
b = b->parent;
}
if (self->use_clip)
{
clip_rect = self->clip;
}
else
{
MAKERECT(clip_rect, 0, 0, bitmap->width, bitmap->height);
}
b = bitmap;
while (b != 0)
{
RECTOFFSET(clip_rect, b->left, b->top);
b = b->parent;
}
k = 0; k = 0;
while (xrdp_region_get_rect(region, k, &rect) == 0) while (xrdp_region_get_rect(region, k, &rect) == 0)
{ {
if (!ISRECTEMPTY(rect)) if (rect_intersect(&rect, &clip_rect, &draw_rect))
{ {
if (rect_intersect(&rect, &clip_rect, &draw_rect)) x1 = x;
{ y1 = y + total_height;
x1 = x; draw_rect.right--;
y1 = y + total_height; draw_rect.bottom--;
draw_rect.right--; flags = 0x03; /* 0x03 0x73; TEXT2_IMPLICIT_X and something else */
draw_rect.bottom--; libxrdp_orders_text(self->session, f, flags, 0,
flags = 0x03; /* 0x03 0x73; TEXT2_IMPLICIT_X and something else */ font->color, 0,
DEBUG(("sending text order\n\r\ x - 1, y - 1, x + total_width, y + total_height,
font %d\n\r\ 0, 0, 0, 0,
flags %d\n\r\ x1, y1, data, len * 2, &draw_rect);
mixmode %d\n\r\
color1 %d\n\r\
color2 %d\n\r\
clip box %d %d %d %d\n\r\
box box %d %d %d %d\n\r\
x %d\n\r\
y %d\n\r\
len %d\n\r\
rect %d %d %d %d\n\r",
f, flags, 0, font->color, 0, x, y,
x + total_width, y + total_height,
0, 0, 0, 0, x1, y1, len,
draw_rect.left, draw_rect.top,
draw_rect.right, draw_rect.bottom));
libxrdp_orders_text(self->session, f, flags, 0,
font->color, 0,
x - 1, y - 1, x + total_width, y + total_height,
0, 0, 0, 0,
x1, y1, data, len * 2, &draw_rect);
}
} }
k++; k++;
} }
@ -615,6 +392,77 @@ xrdp_painter_draw_text(struct xrdp_painter* self,
return 0; return 0;
} }
/*****************************************************************************/
int APP_CC
xrdp_painter_draw_text2(struct xrdp_painter* self,
struct xrdp_bitmap* bitmap,
int font, int flags, int mixmode,
int clip_left, int clip_top,
int clip_right, int clip_bottom,
int box_left, int box_top,
int box_right, int box_bottom,
int x, int y, char* data, int data_len)
{
struct xrdp_rect clip_rect;
struct xrdp_rect draw_rect;
struct xrdp_rect rect;
struct xrdp_region* region;
int k;
int dx;
int dy;
if (self == 0)
{
return 0;
}
/* todo data */
if (bitmap->type == WND_TYPE_BITMAP)
{
return 0;
}
xrdp_bitmap_get_screen_clip(bitmap, self, &clip_rect, &dx, &dy);
region = xrdp_region_create(self->wm);
if (box_right - box_left > 1)
{
xrdp_wm_get_vis_region(self->wm, bitmap, box_left, box_top,
box_right - box_left, box_bottom - box_top,
region, self->clip_children);
}
else
{
xrdp_wm_get_vis_region(self->wm, bitmap, clip_left, clip_top,
clip_right - clip_left, clip_bottom - clip_top,
region, self->clip_children);
}
clip_left += dx;
clip_top += dy;
clip_right += dx;
clip_bottom += dy;
box_left += dx;
box_top += dy;
box_right += dx;
box_bottom += dy;
x += dx;
y += dy;
k = 0;
while (xrdp_region_get_rect(region, k, &rect) == 0)
{
if (rect_intersect(&rect, &clip_rect, &draw_rect))
{
libxrdp_orders_text(self->session, font, flags, mixmode,
self->fg_color, self->bg_color,
clip_left, clip_top, clip_right, clip_bottom,
box_left, box_top, box_right, box_bottom,
x, y, data, data_len, &draw_rect);
}
k++;
}
xrdp_region_delete(region);
return 0;
}
/*****************************************************************************/ /*****************************************************************************/
int APP_CC int APP_CC
xrdp_painter_copy(struct xrdp_painter* self, xrdp_painter_copy(struct xrdp_painter* self,
@ -623,6 +471,26 @@ xrdp_painter_copy(struct xrdp_painter* self,
int x, int y, int cx, int cy, int x, int y, int cx, int cy,
int srcx, int srcy) int srcx, int srcy)
{ {
struct xrdp_rect clip_rect;
struct xrdp_rect draw_rect;
struct xrdp_rect rect1;
struct xrdp_rect rect2;
struct xrdp_region* region;
struct xrdp_bitmap* b;
int i;
int j;
int k;
int dx;
int dy;
int palette_id;
int bitmap_id;
int cache_id;
int cache_idx;
int walkx;
int walky;
int w;
int h;
if (self == 0 || src == 0 || dst == 0) if (self == 0 || src == 0 || dst == 0)
{ {
return 0; return 0;
@ -636,8 +504,120 @@ xrdp_painter_copy(struct xrdp_painter* self,
} }
if (src == dst && src->wm->screen == src) if (src == dst && src->wm->screen == src)
{ {
libxrdp_orders_screen_blt(dst->wm->session, x, y, cx, cy, xrdp_bitmap_get_screen_clip(dst, self, &clip_rect, &dx, &dy);
srcx, srcy, self->rop, 0); region = xrdp_region_create(self->wm);
xrdp_wm_get_vis_region(self->wm, dst, x, y, cx, cy,
region, self->clip_children);
x += dx;
y += dy;
srcx += dx;
srcy += dy;
k = 0;
while (xrdp_region_get_rect(region, k, &rect1) == 0)
{
if (rect_intersect(&rect1, &clip_rect, &draw_rect))
{
libxrdp_orders_screen_blt(self->session, x, y, cx, cy,
srcx, srcy, self->rop, &draw_rect);
}
k++;
}
xrdp_region_delete(region);
}
else if (src->data != 0)
/* todo, the non bitmap cache part is gone, it should be put back */
{
xrdp_bitmap_get_screen_clip(dst, self, &clip_rect, &dx, &dy);
region = xrdp_region_create(self->wm);
xrdp_wm_get_vis_region(self->wm, dst, x, y, cx, cy,
region, self->clip_children);
x += dx;
y += dy;
palette_id = 0;
j = srcy;
while (j < src->height)
{
i = srcx;
while (i < src->width)
{
walkx = x + i;
walky = y + j;
w = MIN(64, src->width - i);
h = MIN(64, src->height - j);
b = xrdp_bitmap_create(w, h, self->wm->screen->bpp, 0, self->wm);
xrdp_bitmap_copy_box_with_crc(src, b, i, j, w, h);
bitmap_id = xrdp_cache_add_bitmap(self->wm->cache, b);
cache_id = HIWORD(bitmap_id);
cache_idx = LOWORD(bitmap_id);
k = 0;
while (xrdp_region_get_rect(region, k, &rect1) == 0)
{
if (rect_intersect(&rect1, &clip_rect, &rect2))
{
MAKERECT(rect1, walkx, walky, w, h);
if (rect_intersect(&rect2, &rect1, &draw_rect))
{
libxrdp_orders_mem_blt(self->session, cache_id, palette_id,
walkx, walky, w, h, self->rop, 0, 0,
cache_idx, &draw_rect);
}
}
k++;
}
i += 64;
}
j += 64;
}
xrdp_region_delete(region);
} }
return 0; return 0;
} }
/*****************************************************************************/
int APP_CC
xrdp_painter_line(struct xrdp_painter* self,
struct xrdp_bitmap* bitmap,
int x1, int y1, int x2, int y2)
{
struct xrdp_rect clip_rect;
struct xrdp_rect draw_rect;
struct xrdp_rect rect;
struct xrdp_region* region;
int k;
int dx;
int dy;
if (self == 0)
{
return 0;
}
/* todo data */
if (bitmap->type == WND_TYPE_BITMAP)
{
return 0;
}
xrdp_bitmap_get_screen_clip(bitmap, self, &clip_rect, &dx, &dy);
region = xrdp_region_create(self->wm);
xrdp_wm_get_vis_region(self->wm, bitmap, MIN(x1, x2), MIN(y1, y2),
g_abs(x1 - x2) + 1, g_abs(y1 - y2) + 1,
region, self->clip_children);
x1 += dx;
y1 += dy;
x2 += dx;
y2 += dy;
k = 0;
while (xrdp_region_get_rect(region, k, &rect) == 0)
{
if (rect_intersect(&rect, &clip_rect, &draw_rect))
{
libxrdp_orders_line(self->session, 0, x1, y1, x2, y2,
self->rop, self->bg_color,
&self->pen, &draw_rect);
}
k++;
}
xrdp_region_delete(region);
return 0;
}

27
xrdp/xrdp_types.h
View File

@ -35,18 +35,35 @@ struct xrdp_mod
/* server functions */ /* server functions */
int (*server_begin_update)(struct xrdp_mod* v); int (*server_begin_update)(struct xrdp_mod* v);
int (*server_end_update)(struct xrdp_mod* v); int (*server_end_update)(struct xrdp_mod* v);
int (*server_fill_rect)(struct xrdp_mod* v, int x, int y, int cx, int cy, int (*server_fill_rect)(struct xrdp_mod* v, int x, int y, int cx, int cy);
int color);
int (*server_screen_blt)(struct xrdp_mod* v, int x, int y, int cx, int cy, int (*server_screen_blt)(struct xrdp_mod* v, int x, int y, int cx, int cy,
int srcx, int srcy); int srcx, int srcy);
int (*server_paint_rect)(struct xrdp_mod* v, int x, int y, int cx, int cy, int (*server_paint_rect)(struct xrdp_mod* v, int x, int y, int cx, int cy,
char* data); char* data);
int (*server_set_pointer)(struct xrdp_mod* v, int x, int y, char* data, char* mask); int (*server_set_pointer)(struct xrdp_mod* v, int x, int y, char* data, char* mask);
int (*server_palette)(struct xrdp_mod* v, int* palette); int (*server_palette)(struct xrdp_mod* v, int* palette);
int (*server_msg)(struct xrdp_mod* v, char* msg); int (*server_msg)(struct xrdp_mod* v, char* msg, int code);
int (*server_is_term)(struct xrdp_mod* v); int (*server_is_term)(struct xrdp_mod* v);
int (*server_set_clip)(struct xrdp_mod* v, int x, int y, int cx, int cy); int (*server_set_clip)(struct xrdp_mod* v, int x, int y, int cx, int cy);
int (*server_reset_clip)(struct xrdp_mod* v); int (*server_reset_clip)(struct xrdp_mod* v);
int (*server_set_fgcolor)(struct xrdp_mod* v, int fgcolor);
int (*server_set_bgcolor)(struct xrdp_mod* v, int bgcolor);
int (*server_set_opcode)(struct xrdp_mod* v, int opcode);
int (*server_set_mixmode)(struct xrdp_mod* v, int mixmode);
int (*server_set_brush)(struct xrdp_mod* v, int x_orgin, int y_orgin,
int style, char* pattern);
int (*server_set_pen)(struct xrdp_mod* v, int style,
int width);
int (*server_draw_line)(struct xrdp_mod* v, int x1, int y1, int x2, int y2);
int (*server_add_char)(struct xrdp_mod* v, int font, int charactor,
int offset, int baseline,
int width, int height, char* data);
int (*server_draw_text)(struct xrdp_mod* v, int font,
int flags, int mixmode, int clip_left, int clip_top,
int clip_right, int clip_bottom,
int box_left, int box_top,
int box_right, int box_bottom,
int x, int y, char* data, int data_len);
/* common */ /* common */
long handle; /* pointer to self as int */ long handle; /* pointer to self as int */
long wm; /* struct xrdp_wm* */ long wm; /* struct xrdp_wm* */
@ -217,12 +234,14 @@ struct xrdp_region
struct xrdp_painter struct xrdp_painter
{ {
int rop; int rop;
int use_clip; struct xrdp_rect* use_clip; /* nil if not using clip */
struct xrdp_rect clip; struct xrdp_rect clip;
int clip_children; int clip_children;
int bg_color; int bg_color;
int fg_color; int fg_color;
int mix_mode;
struct xrdp_brush brush; struct xrdp_brush brush;
struct xrdp_pen pen;
struct xrdp_session* session; struct xrdp_session* session;
struct xrdp_wm* wm; /* owner */ struct xrdp_wm* wm; /* owner */
struct xrdp_font* font; struct xrdp_font* font;

37
xrdp/xrdp_wm.c
View File

@ -45,6 +45,15 @@ xrdp_wm_create(struct xrdp_process* owner,
return self; return self;
} }
/*****************************************************************************/
/* called from main thread */
static long DEFAULT_CC
sync_unload(long param1, long param2)
{
g_free_library(param1);
return 0;
}
/*****************************************************************************/ /*****************************************************************************/
void APP_CC void APP_CC
xrdp_wm_delete(struct xrdp_wm* self) xrdp_wm_delete(struct xrdp_wm* self)
@ -66,7 +75,7 @@ xrdp_wm_delete(struct xrdp_wm* self)
} }
if (self->mod_handle != 0) if (self->mod_handle != 0)
{ {
g_free_library(self->mod_handle); g_xrdp_sync(sync_unload, self->mod_handle, 0);
} }
/* free the log */ /* free the log */
list_delete(self->log); list_delete(self->log);
@ -123,7 +132,7 @@ xrdp_wm_set_focused(struct xrdp_wm* self, struct xrdp_bitmap* wnd)
return 0; return 0;
} }
//****************************************************************************** /******************************************************************************/
int APP_CC int APP_CC
xrdp_wm_get_pixel(char* data, int x, int y, int width, int bpp) xrdp_wm_get_pixel(char* data, int x, int y, int width, int bpp)
{ {
@ -429,6 +438,7 @@ xrdp_wm_xor_pat(struct xrdp_wm* self, int x, int y, int cx, int cy)
self->painter->rop = 0x5a; self->painter->rop = 0x5a;
xrdp_painter_begin_update(self->painter); xrdp_painter_begin_update(self->painter);
self->painter->use_clip = 0; self->painter->use_clip = 0;
self->painter->mix_mode = 1;
self->painter->brush.pattern[0] = 0xaa; self->painter->brush.pattern[0] = 0xaa;
self->painter->brush.pattern[1] = 0x55; self->painter->brush.pattern[1] = 0x55;
self->painter->brush.pattern[2] = 0xaa; self->painter->brush.pattern[2] = 0xaa;
@ -443,17 +453,18 @@ xrdp_wm_xor_pat(struct xrdp_wm* self, int x, int y, int cx, int cy)
self->painter->bg_color = self->black; self->painter->bg_color = self->black;
self->painter->fg_color = self->white; self->painter->fg_color = self->white;
/* top */ /* top */
xrdp_painter_fill_rect2(self->painter, self->screen, x, y, cx, 5); xrdp_painter_fill_rect(self->painter, self->screen, x, y, cx, 5);
/* bottom */ /* bottom */
xrdp_painter_fill_rect2(self->painter, self->screen, x, y + (cy - 5), cx, 5); xrdp_painter_fill_rect(self->painter, self->screen, x, y + (cy - 5), cx, 5);
/* left */ /* left */
xrdp_painter_fill_rect2(self->painter, self->screen, x, y + 5, 5, cy - 10); xrdp_painter_fill_rect(self->painter, self->screen, x, y + 5, 5, cy - 10);
/* right */ /* right */
xrdp_painter_fill_rect2(self->painter, self->screen, x + (cx - 5), y + 5, 5, xrdp_painter_fill_rect(self->painter, self->screen, x + (cx - 5), y + 5, 5,
cy - 10); cy - 10);
xrdp_painter_end_update(self->painter); xrdp_painter_end_update(self->painter);
self->painter->rop = 0xcc; self->painter->rop = 0xcc;
self->painter->clip_children = 1; self->painter->clip_children = 1;
self->painter->mix_mode = 0;
return 0; return 0;
} }
@ -949,11 +960,13 @@ xrdp_wm_key(struct xrdp_wm* self, int device_flags, int scan_code)
self->scroll_lock); self->scroll_lock);
if (c != 0) if (c != 0)
{ {
self->mod->mod_event(self->mod, msg, c, 0xffff, 0, 0); self->mod->mod_event(self->mod, msg, c, 0xffff,
scan_code, device_flags);
} }
else else
{ {
self->mod->mod_event(self->mod, msg, scan_code, device_flags, 0, 0); self->mod->mod_event(self->mod, msg, scan_code, device_flags,
scan_code, device_flags);
} }
} }
} }
@ -985,6 +998,14 @@ xrdp_wm_key_sync(struct xrdp_wm* self, int device_flags, int key_flags)
{ {
self->caps_lock = 1; self->caps_lock = 1;
} }
if (self->mod != 0)
{
if (self->mod->mod_event != 0)
{
self->mod->mod_event(self->mod, 17, key_flags, device_flags,
key_flags, device_flags);
}
}
return 0; return 0;
} }