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

added early keyboard work and some other fixes

Browse Source
This commit is contained in:
jsorg71 2004-10-11 02:58:27 +00:00
parent 82eb62e0cc
commit 330a4ffb98
9 changed files with 417 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
xrdp/constants.h
View File

@ -410,3 +410,8 @@
/* button states */
#define BUTTON_STATE_UP 0
#define BUTTON_STATE_DOWN 1
/* messages */
#define WM_PAINT 3
#define WM_KEYDOWN 15
#define WM_KEYUP 16

195
xrdp/funcs.c
View File

@ -1,4 +1,3 @@
/*
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
@ -61,21 +60,6 @@ int rect_intersect(struct xrdp_rect* in1, struct xrdp_rect* in2,
return rv;
}
/*****************************************************************************/
int color16(int r, int g, int b)
{
r = r >> 3;
g = g >> 2;
b = b >> 3;
return (r << 11) | (g << 5) | b;
}
/*****************************************************************************/
int color24(int r, int g, int b)
{
return r | (g << 8) | (b << 16);
}
/*****************************************************************************/
/* adjust the bounds to fit in the bitmap */
/* return false if there is nothing to draw else return true */
@ -105,3 +89,182 @@ int check_bounds(struct xrdp_bitmap* b, int* x, int* y, int* cx, int* cy)
*cy = b->height - *y;
return 1;
}
/* scan codes
1 esc
2 1 or ?
3 2 or @
4 3 or #
5 4 or $
6 5 or %
7 6 or ^
8 7 or &
9 8 or *
10 9 or (
11 10 or )
12 11 or _
13 12 or +
14 backspace
15 tab
16 q or Q
17 w or W
18 e or E
19 r or R
20 t or T
21 y or Y
22 u or U
23 i or I
24 o or O
25 p or P
26 [ or {
27 ] or }
28 enter, keypad if ext
29 left or right ctrl, ext flag is right
30 a or A
31 s or S
32 d or D
33 f or F
34 g or G
35 h or H
36 j or J
37 k or K
38 l or L
39 ; or :
40 ' or "
41 ~
42 left shift
43 \
44 z or Z
45 x or X
46 c or C
47 v or V
48 b or B
49 n or N
50 m or M
51 , or <
52 . or >
53 / can be / on keypad, ext flag is keypad
54 right shift
55 * on keypad or print screen if ext
56 left or right alt, ext flag is right
57 space
58 caps lock
59 F1
60 F2
61 F3
62 F4
63 F5
64 F6
65 F7
66 F8
67 F9
68 F10
69 num lock
70 scroll lock
71 7 or home on keypad, ext flag is not keypad
72 8 or arrow up on keypad, ext flag is not keypad
73 9 or page up
74 -(minus) on keypad
75 4 or arrow left on keypad, ext flag is not keypad
76 middle(5 key) of keypad
77 6 or arrow right, can be on keypad, ext flag in not keypad
78 + on keypad
79 1 or end
80 2 or arrow down, can be on keypad, ext flag in not keypad
81 3 or page down
82 0 or insert on keypad, ext flag is not keypad
83 . or delete on keypad, ext flag is not keypad
87 F11
88 F12
91 left win key ext always on
92 right win key ext always on
93 menu key ext always on
*/
/* non shift chars */
char chars1[] = {'\0', '\0', '1', '2', '3', '4', '5', '6',
'7', '8', '9', '0', '-', '=', '\0', '\0',
'q', 'w', 'e', 'r', 't', 'y', 'u', 'i',
'o', 'p', '[', ']', '\0', '\0', 'a', 's',
'd', 'f', 'g', 'h', 'j', 'k', 'l', ';',
'\'', '`', '\0', '\\', 'z', 'x', 'c', 'v',
'b', 'n', 'm', ',', '.', '/', '\0', '*',
'\0', ' ', '\0', '\0', '\0', '\0', '\0', '\0',
'\0', '\0', '\0', '\0', '\0', '\0', '\0', '7',
'8', '9', '-', '4', '5', '6', '+', '1',
'2', '3', '0', '.', '\0', '\0', '\0', '\0',
'\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
'\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
'\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
'\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
'\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0'};
/* shift chars */
char chars2[] = {'\0', '\0', '!', '@', '#', '$', '%', '^',
'&', '*', '(', ')', '_', '+', '\0', '\0',
'Q', 'W', 'E', 'R', 'T', 'Y', 'U', 'I',
'O', 'P', '{', '}', '\0', '\0', 'A', 'S',
'D', 'F', 'G', 'H', 'J', 'K', 'L', ':',
'"', '~', '\0', '|', 'Z', 'X', 'C', 'V',
'B', 'N', 'M', '<', '>', '?', '\0', '*',
'\0', ' ', '\0', '\0', '\0', '\0', '\0', '\0',
'\0', '\0', '\0', '\0', '\0', '\0', '\0', '7',
'8', '9', '-', '4', '5', '6', '+', '1',
'2', '3', '0', '.', '\0', '\0', '\0', '\0',
'\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
'\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
'\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
'\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
'\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0'};
/*****************************************************************************/
char get_char_from_scan_code(int device_flags, int scan_code, int* keys,
int caps_lock, int num_lock, int scroll_lock)
{
char rv;
int shift;
int ext;
shift = keys[42] || keys[54];
ext = device_flags & 0x0100;
rv = 0;
if (scan_code >= 128)
{
scan_code = scan_code % 128;
num_lock = 0;
}
if (!num_lock)
{
switch (scan_code)
{
case 71: /* 7 */
case 72: /* 8 */
case 73: /* 9 */
case 75: /* 4 */
case 76: /* 5 */
case 77: /* 6 */
case 79: /* 1 */
case 80: /* 2 */
case 81: /* 3 */
case 82: /* 0 */
case 83: /* . */
return rv;
}
}
if (ext)
{
if (scan_code == 53)
rv = '/';
}
else
{
if (shift)
rv = chars2[scan_code];
else
rv = chars1[scan_code];
if (rv >= 'a' && rv <= 'z' && caps_lock)
rv = rv - ('a' - 'A');
else if (rv >= 'A' && rv <= 'Z' && caps_lock)
rv = rv + ('a' - 'A');
}
return rv;
}

6
xrdp/os_calls.c
View File

@ -536,3 +536,9 @@ char* g_strcpy(char* dest, char* src)
{
return strcpy(dest, src);
}
/*****************************************************************************/
char* g_strcat(char* dest, char* src)
{
return strcat(dest, src);
}

7
xrdp/xrdp.h
View File

@ -120,6 +120,7 @@ int g_file_seek(int fd, int offset);
int g_file_lock(int fd, int start, int len);
int g_strlen(char* text);
char* g_strcpy(char* dest, char* src);
char* g_strcat(char* dest, char* src);
/* xrdp_tcp.c */
struct xrdp_tcp* xrdp_tcp_create(struct xrdp_iso* owner);
@ -234,6 +235,8 @@ int xrdp_wm_get_vis_region(struct xrdp_wm* self, struct xrdp_bitmap* bitmap,
struct xrdp_region* region);
int xrdp_wm_mouse_move(struct xrdp_wm* self, int x, int y);
int xrdp_wm_mouse_click(struct xrdp_wm* self, int x, int y, int but, int down);
int xrdp_wm_key(struct xrdp_wm* self, int device_flags, int scan_code);
int xrdp_wm_key_sync(struct xrdp_wm* self, int device_flags, int key_flags);
/* xrdp_process.c */
struct xrdp_process* xrdp_process_create(struct xrdp_listen* owner);
@ -269,6 +272,8 @@ int xrdp_bitmap_copy_box(struct xrdp_bitmap* self, struct xrdp_bitmap* dest,
int x, int y, int cx, int cy);
int xrdp_bitmap_compare(struct xrdp_bitmap* self, struct xrdp_bitmap* b);
int xrdp_bitmap_invalidate(struct xrdp_bitmap* self, struct xrdp_rect* rect);
int xrdp_bitmap_def_proc(struct xrdp_bitmap* self, int msg,
int param1, int param2);
/* xrdp_painter.c */
struct xrdp_painter* xrdp_painter_create(struct xrdp_wm* wn);
@ -315,3 +320,5 @@ int rect_contains_pt(struct xrdp_rect* in, int x, int y);
int rect_intersect(struct xrdp_rect* in1, struct xrdp_rect* in2,
struct xrdp_rect* out);
int check_bounds(struct xrdp_bitmap* b, int* x, int* y, int* cx, int* cy);
char get_char_from_scan_code(int device_flags, int scan_code, int* keys,
int caps_lock, int num_lock, int scroll_lock);

131
xrdp/xrdp_bitmap.c
View File

@ -56,6 +56,11 @@ void xrdp_bitmap_delete(struct xrdp_bitmap* self)
return;
if (self->wm != 0)
{
if (self->wm->focused_window != 0)
{
if (self->wm->focused_window->focused_control == self)
self->wm->focused_window->focused_control = 0;
}
if (self->wm->focused_window == self)
self->wm->focused_window = 0;
if (self->wm->dragging_window == self)
@ -98,7 +103,7 @@ int xrdp_bitmap_set_focus(struct xrdp_bitmap* self, int focused)
xrdp_painter_fill_rect(painter, self, 3, 3, self->width - 5, 18);
painter->font->color = self->wm->black;
}
xrdp_painter_draw_text(painter, self, 4, 4, self->title);
xrdp_painter_draw_text(painter, self, 4, 4, self->caption);
xrdp_painter_end_update(painter);
xrdp_painter_delete(painter);
return 0;
@ -415,7 +420,7 @@ int xrdp_bitmap_invalidate(struct xrdp_bitmap* self, struct xrdp_rect* rect)
xrdp_painter_fill_rect(painter, self, 3, 3, self->width - 5, 18);
painter->font->color = self->wm->black;
}
xrdp_painter_draw_text(painter, self, 4, 4, self->title);
xrdp_painter_draw_text(painter, self, 4, 4, self->caption);
}
else if (self->type == WND_TYPE_SCREEN) /* 2 */
{
@ -449,11 +454,11 @@ int xrdp_bitmap_invalidate(struct xrdp_bitmap* self, struct xrdp_rect* rect)
/* black right line */
painter->fg_color = self->wm->black;
xrdp_painter_fill_rect(painter, self, self->width - 1, 0, 1, self->height);
w = xrdp_painter_text_width(painter, self->title);
h = xrdp_painter_text_height(painter, self->title);
w = xrdp_painter_text_width(painter, self->caption);
h = xrdp_painter_text_height(painter, self->caption);
painter->font->color = self->wm->black;
xrdp_painter_draw_text(painter, self, self->width / 2 - w / 2,
self->height / 2 - h / 2, self->title);
self->height / 2 - h / 2, self->caption);
}
else if (self->state == BUTTON_STATE_DOWN) /* 1 */
{
@ -486,11 +491,11 @@ int xrdp_bitmap_invalidate(struct xrdp_bitmap* self, struct xrdp_rect* rect)
/* black right line */
painter->fg_color = self->wm->black;
xrdp_painter_fill_rect(painter, self, self->width - 1, 0, 1, self->height);
w = xrdp_painter_text_width(painter, self->title);
h = xrdp_painter_text_height(painter, self->title);
w = xrdp_painter_text_width(painter, self->caption);
h = xrdp_painter_text_height(painter, self->caption);
painter->font->color = self->wm->black;
xrdp_painter_draw_text(painter, self, (self->width / 2 - w / 2) + 1,
(self->height / 2 - h / 2) + 1, self->title);
(self->height / 2 - h / 2) + 1, self->caption);
}
}
else if (self->type == WND_TYPE_IMAGE) /* 4 */
@ -525,15 +530,19 @@ int xrdp_bitmap_invalidate(struct xrdp_bitmap* self, struct xrdp_rect* rect)
/* black top line */
painter->fg_color = self->wm->black;
xrdp_painter_fill_rect(painter, self, 1, 1, self->width - 2, 1);
/* draw text */
painter->fg_color = self->wm->black;
xrdp_painter_draw_text(painter, self, 2, 2, self->caption);
// xrdp_painter_draw_text(painter, self, 2, 2, "hi");
}
else if (self->type == WND_TYPE_LABEL) /* 6 */
{
painter->font->color = self->wm->black;
xrdp_painter_draw_text(painter, self, 0, 0, self->title);
xrdp_painter_draw_text(painter, self, 0, 0, self->caption);
}
/* notify */
if (self->notify != 0)
self->notify(self, self, 3, (int)painter, 0);
self->notify(self, self, WM_PAINT, (int)painter, 0); /* 3 */
/* draw any child windows in the area */
for (i = 0; i < self->child_list->count; i++)
{
@ -554,3 +563,105 @@ int xrdp_bitmap_invalidate(struct xrdp_bitmap* self, struct xrdp_rect* rect)
xrdp_painter_delete(painter);
return 0;
}
/*****************************************************************************/
/* returns error */
int xrdp_bitmap_def_proc(struct xrdp_bitmap* self, int msg,
int param1, int param2)
{
char c;
char a[2];
int n;
int i;
int shift;
struct xrdp_bitmap* b;
if (self == 0)
return 0;
if (self->wm == 0)
return 0;
if (self->type == WND_TYPE_WND)
{
if (msg == WM_KEYDOWN)
{
if (param1 == 15) /* tab */
{
/* move to next tab stop */
shift = self->wm->keys[42] || self->wm->keys[54];
i = -1;
if (self->child_list != 0)
i = xrdp_list_index_of(self->child_list, (int)self->focused_control);
if (shift)
{
i--;
if (i < 0)
i = self->child_list->count - 1;
}
else
{
i++;
if (i >= self->child_list->count)
i = 0;
}
n = self->child_list->count;
b = (struct xrdp_bitmap*)xrdp_list_get_item(self->child_list, i);
while (b != self->focused_control && b != 0 && n > 0)
{
n--;
if (b->tab_stop)
{
self->focused_control = b;
break;
}
if (shift)
{
i--;
if (i < 0)
i = self->child_list->count - 1;
}
else
{
i++;
if (i >= self->child_list->count)
i = 0;
}
b = (struct xrdp_bitmap*)xrdp_list_get_item(self->child_list, i);
}
}
}
if (self->focused_control != 0)
{
xrdp_bitmap_def_proc(self->focused_control, msg, param1, param2);
}
}
else if (self->type == WND_TYPE_EDIT)
{
if (msg == WM_KEYDOWN)
{
if (param1 == 14) /* backspace */
{
n = g_strlen(self->caption);
if (n > 0)
{
self->caption[n - 1] = 0;
xrdp_bitmap_invalidate(self, 0);
}
}
else
{
c = get_char_from_scan_code(param2, param1, self->wm->keys,
self->wm->caps_lock,
self->wm->num_lock,
self->wm->scroll_lock);
if (c != 0)
{
a[0] = c;
a[1] = 0;
g_strcat(self->caption, a);
xrdp_bitmap_invalidate(self, 0);
}
}
}
}
return 0;
}

5
xrdp/xrdp_orders.c
View File

@ -104,6 +104,9 @@ int xrdp_orders_force_send(struct xrdp_orders* self)
}
/*****************************************************************************/
/* check if the current order will fix in packet size of 8192, if not */
/* send what we got and init a new one */
/* returns error */
int xrdp_orders_check(struct xrdp_orders* self, int max_size)
{
int size;
@ -127,6 +130,7 @@ int xrdp_orders_check(struct xrdp_orders* self, int max_size)
}
/*****************************************************************************/
/* check if rect is the same as the last one sent */
/* returns boolean */
int xrdp_orders_last_bounds(struct xrdp_orders* self,
struct xrdp_rect* rect)
@ -140,6 +144,7 @@ int xrdp_orders_last_bounds(struct xrdp_orders* self,
}
/*****************************************************************************/
/* check if all coords are withing 256 bytes */
/* returns boolean */
int xrdp_orders_send_delta(struct xrdp_orders* self, int* vals, int count)
{

14
xrdp/xrdp_rdp.c
View File

@ -213,13 +213,13 @@ int xrdp_rdp_parse_client_mcs_data(struct xrdp_rdp* self)
/*****************************************************************************/
int xrdp_rdp_incoming(struct xrdp_rdp* self)
{
DEBUG(("in xrdp_rdp_incoming\n"));
DEBUG(("in xrdp_rdp_incoming\n\r"));
if (xrdp_sec_incoming(self->sec_layer) != 0)
return 1;
self->mcs_channel = self->sec_layer->mcs_layer->userid +
MCS_USERCHANNEL_BASE;
xrdp_rdp_parse_client_mcs_data(self);
DEBUG(("out xrdp_rdp_incoming mcs channel %d\n", self->mcs_channel));
DEBUG(("out xrdp_rdp_incoming mcs channel %d\n\r", self->mcs_channel));
return 0;
}
@ -375,9 +375,10 @@ int xrdp_rdp_process_data_pointer(struct xrdp_rdp* self, struct stream* s)
int xrdp_rdp_process_input_sync(struct xrdp_rdp* self, int device_flags,
int key_flags)
{
DEBUG(("sync event flags %d key %d\n\r", device_flags, key_flags))
DEBUG(("sync event flags %d key %d\n\r", device_flags, key_flags));
if (!self->up_and_running)
return 0;
xrdp_wm_key_sync(self->pro_layer->wm, device_flags, key_flags);
return 0;
}
@ -386,9 +387,10 @@ int xrdp_rdp_process_input_sync(struct xrdp_rdp* self, int device_flags,
int xrdp_rdp_process_input_scancode(struct xrdp_rdp* self, int device_flags,
int scan_code)
{
DEBUG(("key event flags %d scan_code %d\n\r", device_flags, scan_code))
DEBUG(("key event flags %4.4x scan_code %d\n\r", device_flags, scan_code));
if (!self->up_and_running)
return 0;
xrdp_wm_key(self->pro_layer->wm, device_flags, scan_code);
return 0;
}
@ -397,7 +399,7 @@ int xrdp_rdp_process_input_scancode(struct xrdp_rdp* self, int device_flags,
int xrdp_rdp_process_input_mouse(struct xrdp_rdp* self, int device_flags,
int x, int y)
{
DEBUG(("mouse event flags %4.4x x - %d y - %d\n\r", device_flags, x, y));
DEBUG(("mouse event flags %4.4x x %d y %d\n\r", device_flags, x, y));
if (!self->up_and_running)
return 0;
if (device_flags & MOUSE_FLAG_MOVE) /* 0x0800 */
@ -432,7 +434,7 @@ int xrdp_rdp_process_data_input(struct xrdp_rdp* self, struct stream* s)
in_uint16_le(s, num_events);
in_uint8s(s, 2); /* pad */
DEBUG(("xrdp_rdp_process_data_input %d events\n\r", num_events))
DEBUG(("xrdp_rdp_process_data_input %d events\n\r", num_events));
for (index = 0; index < num_events; index++)
{
in_uint8s(s, 4); /* time */

8
xrdp/xrdp_types.h
View File

@ -315,6 +315,10 @@ struct xrdp_wm
struct xrdp_bitmap* focused_window;
/* cursor */
int current_cursor;
int keys[256]; /* key states 0 up 1 down*/
int caps_lock;
int scroll_lock;
int num_lock;
};
/* rdp process */
@ -377,8 +381,10 @@ struct xrdp_bitmap
int bg_color;
int line_size; /* in bytes */
int focused;
char title[256];
int tab_stop;
char caption[256];
struct xrdp_bitmap* modal_dialog;
struct xrdp_bitmap* focused_control;
struct xrdp_bitmap* owner; /* window that created us */
struct xrdp_bitmap* parent; /* window contained in */
struct xrdp_list* child_list;

101
xrdp/xrdp_wm.c
View File

@ -154,7 +154,7 @@ int xrdp_wm_login_help_notify(struct xrdp_bitmap* wnd,
}
}
}
else if (msg == 3) /* paint */
else if (msg == WM_PAINT) /* 3 */
{
p = (struct xrdp_painter*)param1;
if (p != 0)
@ -227,7 +227,7 @@ int xrdp_wm_login_notify(struct xrdp_bitmap* wnd,
help->left = wnd->wm->screen->width / 2 - help->width / 2;
help->top = wnd->wm->screen->height / 2 - help->height / 2;
help->notify = xrdp_wm_login_help_notify;
g_strcpy(help->title, "Logon help");
g_strcpy(help->caption, "Logon help");
/* ok button */
but = xrdp_bitmap_create(60, 25, wnd->wm->screen->bpp, 3);
xrdp_list_insert_item(help->child_list, 0, (int)but);
@ -237,7 +237,7 @@ int xrdp_wm_login_notify(struct xrdp_bitmap* wnd,
but->left = 120;
but->top = 260;
but->id = 1;
g_strcpy(but->title, "OK");
g_strcpy(but->caption, "OK");
/* draw it */
xrdp_bitmap_invalidate(help, 0);
xrdp_wm_set_focused(wnd->wm, help);
@ -457,7 +457,8 @@ int xrdp_wm_init(struct xrdp_wm* self)
self->green = COLOR24(0x00, 0xff, 0x00);
}
/* draw login window */
self->login_window = xrdp_bitmap_create(400, 200, self->screen->bpp, 1);
self->login_window = xrdp_bitmap_create(400, 200, self->screen->bpp,
WND_TYPE_WND);
xrdp_list_add_item(self->screen->child_list, (int)self->login_window);
self->login_window->parent = self->screen;
self->login_window->owner = self->screen;
@ -468,10 +469,10 @@ int xrdp_wm_init(struct xrdp_wm* self)
self->login_window->top = self->screen->height / 2 -
self->login_window->height / 2;
self->login_window->notify = xrdp_wm_login_notify;
strcpy(self->login_window->title, "Logon to xrdp");
strcpy(self->login_window->caption, "Logon to xrdp");
/* image */
but = xrdp_bitmap_create(4, 4, self->screen->bpp, 4);
but = xrdp_bitmap_create(4, 4, self->screen->bpp, WND_TYPE_IMAGE);
xrdp_bitmap_load(but, "xrdp256.bmp", self->palette);
but->parent = self->screen;
but->owner = self->screen;
@ -481,7 +482,7 @@ int xrdp_wm_init(struct xrdp_wm* self)
xrdp_list_add_item(self->screen->child_list, (int)but);
/* image */
but = xrdp_bitmap_create(4, 4, self->screen->bpp, 4);
but = xrdp_bitmap_create(4, 4, self->screen->bpp, WND_TYPE_IMAGE);
xrdp_bitmap_load(but, "ad256.bmp", self->palette);
but->parent = self->login_window;
but->owner = self->login_window;
@ -491,7 +492,7 @@ int xrdp_wm_init(struct xrdp_wm* self)
xrdp_list_add_item(self->login_window->child_list, (int)but);
/* button */
but = xrdp_bitmap_create(60, 25, self->screen->bpp, 3);
but = xrdp_bitmap_create(60, 25, self->screen->bpp, WND_TYPE_BUTTON);
xrdp_list_add_item(self->login_window->child_list, (int)but);
but->parent = self->login_window;
but->owner = self->login_window;
@ -499,10 +500,11 @@ int xrdp_wm_init(struct xrdp_wm* self)
but->left = 320;
but->top = 160;
but->id = 1;
g_strcpy(but->title, "Help");
g_strcpy(but->caption, "Help");
but->tab_stop = 1;
/* button */
but = xrdp_bitmap_create(60, 25, self->screen->bpp, 3);
but = xrdp_bitmap_create(60, 25, self->screen->bpp, WND_TYPE_BUTTON);
xrdp_list_add_item(self->login_window->child_list, (int)but);
but->parent = self->login_window;
but->owner = self->login_window;
@ -510,10 +512,11 @@ int xrdp_wm_init(struct xrdp_wm* self)
but->left = 250;
but->top = 160;
but->id = 2;
g_strcpy(but->title, "Cancel");
g_strcpy(but->caption, "Cancel");
but->tab_stop = 1;
/* button */
but = xrdp_bitmap_create(60, 25, self->screen->bpp, 3);
but = xrdp_bitmap_create(60, 25, self->screen->bpp, WND_TYPE_BUTTON);
xrdp_list_add_item(self->login_window->child_list, (int)but);
but->parent = self->login_window;
but->owner = self->login_window;
@ -521,20 +524,21 @@ int xrdp_wm_init(struct xrdp_wm* self)
but->left = 180;
but->top = 160;
but->id = 3;
g_strcpy(but->title, "OK");
g_strcpy(but->caption, "OK");
but->tab_stop = 1;
/* label */
but = xrdp_bitmap_create(60, 20, self->screen->bpp, 6); /* label */
but = xrdp_bitmap_create(60, 20, self->screen->bpp, WND_TYPE_LABEL);
xrdp_list_add_item(self->login_window->child_list, (int)but);
but->parent = self->login_window;
but->owner = self->login_window;
but->wm = self;
but->left = 155;
but->top = 50;
g_strcpy(but->title, "Username");
g_strcpy(but->caption, "Username");
/* edit */
but = xrdp_bitmap_create(140, 20, self->screen->bpp, 5);
but = xrdp_bitmap_create(140, 20, self->screen->bpp, WND_TYPE_EDIT);
xrdp_list_add_item(self->login_window->child_list, (int)but);
but->parent = self->login_window;
but->owner = self->login_window;
@ -543,19 +547,20 @@ int xrdp_wm_init(struct xrdp_wm* self)
but->top = 50;
but->id = 4;
but->cursor = 1;
but->tab_stop = 1;
/* label */
but = xrdp_bitmap_create(60, 20, self->screen->bpp, 6); /* label */
but = xrdp_bitmap_create(60, 20, self->screen->bpp, WND_TYPE_LABEL);
xrdp_list_add_item(self->login_window->child_list, (int)but);
but->parent = self->login_window;
but->owner = self->login_window;
but->wm = self;
but->left = 155;
but->top = 80;
g_strcpy(but->title, "Password");
g_strcpy(but->caption, "Password");
/* edit */
but = xrdp_bitmap_create(140, 20, self->screen->bpp, 5);
but = xrdp_bitmap_create(140, 20, self->screen->bpp, WND_TYPE_EDIT);
xrdp_list_add_item(self->login_window->child_list, (int)but);
but->parent = self->login_window;
but->owner = self->login_window;
@ -564,6 +569,7 @@ int xrdp_wm_init(struct xrdp_wm* self)
but->top = 80;
but->id = 5;
but->cursor = 1;
but->tab_stop = 1;
/* clear screen */
self->screen->bg_color = self->black;
@ -893,9 +899,15 @@ int xrdp_wm_mouse_click(struct xrdp_wm* self, int x, int y, int but, int down)
if (control != 0)
{
if (wnd != 0)
{
if (control == wnd)
wnd->focused_control = 0;
else
wnd->focused_control = control;
if (wnd->modal_dialog != 0) /* if window has a modal dialog */
return 0;
if (control->type == 3 && but == 1 &&
}
if (control->type == WND_TYPE_BUTTON && but == 1 &&
!down && self->button_down == control)
{ /* if clicking up on a button that was clicked down */
self->button_down = 0;
@ -906,7 +918,7 @@ int xrdp_wm_mouse_click(struct xrdp_wm* self, int x, int y, int but, int down)
/* control can be invalid after this */
control->parent->notify(control->owner, control, 1, x, y);
}
else if (control->type == 3 && but == 1 && down)
else if (control->type == WND_TYPE_BUTTON && but == 1 && down)
{ /* if clicking down on a button */
self->button_down = control;
control->state = 1;
@ -915,7 +927,7 @@ int xrdp_wm_mouse_click(struct xrdp_wm* self, int x, int y, int but, int down)
else if (but == 1 && down)
{
xrdp_wm_set_focused(self, wnd);
if (control->type == 1 && y < (control->top + 21))
if (control->type == WND_TYPE_WND && y < (control->top + 21))
{ /* if dragging */
if (self->dragging) /* rarely happens */
{
@ -947,3 +959,48 @@ int xrdp_wm_mouse_click(struct xrdp_wm* self, int x, int y, int but, int down)
self->button_down = 0;
return 0;
}
/*****************************************************************************/
int xrdp_wm_key(struct xrdp_wm* self, int device_flags, int scan_code)
{
int msg;
if (device_flags & 0x8000) /* key up */
{
self->keys[scan_code % 128] = 0;
msg = WM_KEYUP;
}
else /* key down */
{
self->keys[scan_code % 128] = 1;
msg = WM_KEYDOWN;
switch (scan_code)
{
case 58: self->caps_lock = !self->caps_lock; break; /* caps lock */
case 69: self->num_lock = !self->num_lock; break; /* num lock */
case 70: self->scroll_lock = !self->scroll_lock; break; /* scroll lock */
}
}
if (self->focused_window != 0)
{
xrdp_bitmap_def_proc(self->focused_window,
msg, scan_code, device_flags);
}
return 0;
}
/*****************************************************************************/
/* happens when client gets focus and sends key modifier info */
int xrdp_wm_key_sync(struct xrdp_wm* self, int device_flags, int key_flags)
{
self->num_lock = 0;
self->scroll_lock = 0;
self->caps_lock = 0;
if (key_flags & 1)
self->scroll_lock = 1;
if (key_flags & 2)
self->num_lock = 1;
if (key_flags & 4)
self->caps_lock = 1;
return 0;
}