uLab
/
xrdp-proprietary
mirror of https://mirror.git.trinitydesktop.org/gitea/uLab/xrdp-proprietary
0
0
Fork 0
Code Issues Releases Wiki Activity

some oganization and macros

Browse Source
ulab-original
jsorg71 20 years ago
parent 5d8d552eba
commit eeaff18512
7 changed files with 220 additions and 171 deletions
Show Stats Download Patch File Download Diff File

8
xrdp/Makefile
Unescape View File

@ -1,16 +1,18 @@
XRDPOBJ = xrdp.o os_calls.o xrdp_tcp.o xrdp_iso.o xrdp_mcs.o xrdp_sec.o xrdp_rdp.o \
xrdp_process.o xrdp_listen.o xrdp_orders.o xrdp_bitmap.o xrdp_wm.o \
xrdp_painter.o xrdp_list.o xrdp_region.o xrdp_cache.o xrdp_font.o
xrdp_painter.o xrdp_list.o xrdp_region.o xrdp_cache.o xrdp_font.o \
funcs.o
#CFLAGS = -Wall -O2 -DXRDP_DEBUG
CFLAGS = -Wall -O2
LDFLAGS = -L /usr/gnu/lib -lpthread -lcrypto
LDFLAGS = -L /usr/gnu/lib
LIBS = -lpthread -lcrypto
CC = gcc
all: xrdp
xrdp: $(XRDPOBJ)
$(CC) $(LDFLAGS) -o xrdp $(XRDPOBJ)
$(CC) $(LDFLAGS) -o xrdp $(XRDPOBJ) $(LIBS)
clean:
rm -f *.o xrdp

86
xrdp/funcs.c
Unescape View File

@ -0,0 +1,86 @@
/*
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.
xrdp: A Remote Desktop Protocol server.
Copyright (C) Jay Sorg 2004
simple functions
*/
#include "xrdp.h"
/*****************************************************************************/
int rect_contains_pt(struct xrdp_rect* in, int x, int y)
{
if (x < in->left)
return 0;
if (y < in->top)
return 0;
if (x >= in->right)
return 0;
if (y >= in->bottom)
return 0;
return 1;
}
/*****************************************************************************/
int rect_intersect(struct xrdp_rect* in1, struct xrdp_rect* in2,
struct xrdp_rect* out)
{
int rv;
struct xrdp_rect dumby;
if (out == 0)
out = &dumby;
*out = *in1;
if (in2->left > in1->left)
out->left = in2->left;
if (in2->top > in1->top)
out->top = in2->top;
if (in2->right < in1->right)
out->right = in2->right;
if (in2->bottom < in1->bottom)
out->bottom = in2->bottom;
rv = !ISRECTEMPTY(*out);
if (!rv)
g_memset(out, 0, sizeof(struct xrdp_rect));
return rv;
}
/*****************************************************************************/
int color15(int r, int g, int b)
{
r = r >> 3;
g = g >> 3;
b = b >> 3;
return (r << 10) | (g << 5) | b;
}
/*****************************************************************************/
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);
}

37
xrdp/xrdp.h
Unescape View File

@ -53,6 +53,26 @@
#define LOWORD(in) ((in) & 0x0000ffff)
#undef MAKELONG
#define MAKELONG(hi, lo) ((((hi) & 0xffff) << 16) | ((lo) & 0xffff))
#undef MAKERECT
#define MAKERECT(r, x, y, cx, cy) \
{ (r).left = x; (r).top = y; (r).right = (x) + (cx); (r).bottom = (y) + (cy); }
#undef ISRECTEMPTY
#define ISRECTEMPTY(r) (((r).right <= (r).left) || ((r).bottom <= (r).top))
#undef RECTOFFSET
#define RECTOFFSET(r, dx, dy) \
{ (r).left += dx; (r).top += dy; (r).right += dx; (r).bottom += dy; }
#undef GETPIXEL8
#define GETPIXEL8(d, x, y, w) (*(((unsigned char*)d) + ((y) * (w) + (x))))
#undef GETPIXEL16
#define GETPIXEL16(d, x, y, w) (*(((unsigned short*)d) + ((y) * (w) + (x))))
#undef GETPIXEL32
#define GETPIXEL32(d, x, y, w) (*(((unsigned long*)d) + ((y) * (w) + (x))))
#undef SETPIXEL8
#define SETPIXEL8(d, x, y, w, v) (*(((unsigned char*)d) + ((y) * (w) + (x))) = (v))
#undef SETPIXEL16
#define SETPIXEL16(d, x, y, w, v) (*(((unsigned short*)d) + ((y) * (w) + (x))) = (v))
#undef SETPIXEL32
#define SETPIXEL32(d, x, y, w, v) (*(((unsigned long*)d) + ((y) * (w) + (x))) = (v))
/* font macros */
#define FONT_DATASIZE(f) ((((f)->height * (((f)->width + 7) / 8)) + 3) & ~3);
@ -222,15 +242,6 @@ 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_rect(struct xrdp_rect* r, int x, int y, int cx, int cy);
int xrdp_wm_rect_is_empty(struct xrdp_rect* in);
int xrdp_wm_rect_contains_pt(struct xrdp_rect* in, int x, int y);
int xrdp_wm_rect_intersect(struct xrdp_rect* in1, struct xrdp_rect* in2,
struct xrdp_rect* out);
int xrdp_wm_rect_offset(struct xrdp_rect* in, int dx, int dy);
int xrdp_wm_color15(int r, int g, int b);
int xrdp_wm_color16(int r, int g, int b);
int xrdp_wm_color24(int r, int g, int b);
/* xrdp_process.c */
struct xrdp_process* xrdp_process_create(struct xrdp_listen* owner);
@ -306,3 +317,11 @@ struct xrdp_font* xrdp_font_create(struct xrdp_wm* wm);
void xrdp_font_delete(struct xrdp_font* self);
int xrdp_font_item_compare(struct xrdp_font_item* font1,
struct xrdp_font_item* font2);
/* funcs.c */
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 color15(int r, int g, int b);
int color16(int r, int g, int b);
int color24(int r, int g, int b);

61
xrdp/xrdp_bitmap.c
Unescape View File

@ -210,17 +210,17 @@ int xrdp_bitmap_load(struct xrdp_bitmap* self, char* filename, int* palette)
if (self->bpp == 8)
color = xrdp_bitmap_get_index(self, palette, color);
else if (self->bpp == 15)
color = xrdp_wm_color15((color & 0xff0000) >> 16,
(color & 0x00ff00) >> 8,
(color & 0x0000ff) >> 0);
color = color15((color & 0xff0000) >> 16,
(color & 0x00ff00) >> 8,
(color & 0x0000ff) >> 0);
else if (self->bpp == 16)
color = xrdp_wm_color16((color & 0xff0000) >> 16,
(color & 0x00ff00) >> 8,
(color & 0x0000ff) >> 0);
color = color16((color & 0xff0000) >> 16,
(color & 0x00ff00) >> 8,
(color & 0x0000ff) >> 0);
else if (self->bpp == 24)
color = xrdp_wm_color24((color & 0xff0000) >> 16,
(color & 0x00ff00) >> 8,
(color & 0x0000ff) >> 0);
color = color24((color & 0xff0000) >> 16,
(color & 0x00ff00) >> 8,
(color & 0x0000ff) >> 0);
xrdp_bitmap_set_pixel(self, j, i, color);
}
}
@ -241,11 +241,11 @@ int xrdp_bitmap_get_pixel(struct xrdp_bitmap* self, int x, int y)
if (x >= 0 && x < self->width && y >= 0 && y < self->height)
{
if (self->bpp == 8)
return self->data[y * self->width + x];
return GETPIXEL8(self->data, x, y, self->width);
else if (self->bpp == 15 || self->bpp == 16)
return ((short*)self->data)[y * self->width + x];
return GETPIXEL16(self->data, x, y, self->width);
else if (self->bpp == 24)
return ((int*)self->data)[y * self->width + x];
return GETPIXEL32(self->data, x, y, self->width);
}
return 0;
}
@ -253,14 +253,18 @@ int xrdp_bitmap_get_pixel(struct xrdp_bitmap* self, int x, int y)
/*****************************************************************************/
int xrdp_bitmap_set_pixel(struct xrdp_bitmap* self, int x, int y, int pixel)
{
if (self == 0)
return 0;
if (self->data == 0)
return 0;
if (x >= 0 && x < self->width && y >= 0 && y < self->height)
{
if (self->bpp == 8)
self->data[y * self->width + x] = pixel;
SETPIXEL8(self->data, x, y, self->width, pixel);
else if (self->bpp == 15 || self->bpp == 16)
((short*)(self->data))[y * self->width + x] = pixel;
SETPIXEL16(self->data, x, y, self->width, pixel);
else if (self->bpp == 24)
((int*)(self->data))[y * self->width + x] = pixel;
SETPIXEL32(self->data, x, y, self->width, pixel);
}
return 0;
}
@ -278,12 +282,23 @@ int xrdp_bitmap_copy_box(struct xrdp_bitmap* self, struct xrdp_bitmap* dest,
return 0;
if (self->bpp != dest->bpp)
return 0;
for (i = 0; i < cy; i++)
if (self->bpp == 24)
{
for (j = 0; j < cx; j++)
for (i = 0; i < cy; i++)
for (j = 0; j < cx; j++)
SETPIXEL32(dest->data, j, i, dest->width,
GETPIXEL32(self->data, j + x, i + y, self->width));
}
else
{
for (i = 0; i < cy; i++)
{
xrdp_bitmap_set_pixel(dest, j, i,
xrdp_bitmap_get_pixel(self, j + x, i + y));
for (j = 0; j < cx; j++)
{
xrdp_bitmap_set_pixel(dest, j, i,
xrdp_bitmap_get_pixel(self, j + x, i + y));
}
}
}
return 0;
@ -330,7 +345,7 @@ int xrdp_bitmap_invalidate(struct xrdp_bitmap* self, struct xrdp_rect* rect)
painter->use_clip = 0;
else
{
if (xrdp_wm_rect_is_empty(rect))
if (ISRECTEMPTY(*rect))
{
xrdp_painter_delete(painter);
return 0;
@ -507,10 +522,10 @@ int xrdp_bitmap_invalidate(struct xrdp_bitmap* self, struct xrdp_rect* rect)
xrdp_bitmap_invalidate(b, 0);
else
{
xrdp_wm_rect(&r1, b->left, b->top, b->width, b->height);
if (xrdp_wm_rect_intersect(rect, &r1, &r2))
MAKERECT(r1, b->left, b->top, b->width, b->height);
if (rect_intersect(rect, &r1, &r2))
{
xrdp_wm_rect_offset(&r2, -(b->left), -(b->top));
RECTOFFSET(r2, -(b->left), -(b->top));
xrdp_bitmap_invalidate(b, &r2);
}
}

42
xrdp/xrdp_painter.c
Unescape View File

@ -280,15 +280,15 @@ int xrdp_painter_draw_bitmap(struct xrdp_painter* self,
k = 0;
while (xrdp_region_get_rect(region, k, &rect) == 0)
{
xrdp_wm_rect(&rect1, x1, y1, w, h);
if (xrdp_wm_rect_intersect(&rect, &rect1, &rect2))
MAKERECT(rect1, x1, y1, w, h);
if (rect_intersect(&rect, &rect1, &rect2))
{
ok = 1;
if (self->use_clip)
{
rect = self->clip;
xrdp_wm_rect_offset(&rect, x, y);
if (!xrdp_wm_rect_intersect(&rect2, &rect, &rect1))
RECTOFFSET(rect, x, y);
if (!rect_intersect(&rect2, &rect, &rect1))
ok = 0;
}
else
@ -390,6 +390,8 @@ int xrdp_painter_draw_text(struct xrdp_painter* self,
char* data;
struct xrdp_region* region;
struct xrdp_rect rect;
struct xrdp_rect clip_rect;
struct xrdp_rect draw_rect;
struct xrdp_bitmap* b;
struct xrdp_font* font;
struct xrdp_font_item* font_item;
@ -430,19 +432,31 @@ int xrdp_painter_draw_text(struct xrdp_painter* self,
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;
while (xrdp_region_get_rect(region, k, &rect) == 0)
{
x1 = x;
y1 = y;
rect.right--;
rect.bottom--;
flags = 0x03; /* 0x73; TEXT2_IMPLICIT_X and something else */
xrdp_orders_text(self->orders, f, flags, 0,
font->color, 0,
x1, y1, x1 + total_width, y1 + total_height,
0, 0, 0, 0,
x1, y1 + total_height, data, len * 2, &rect);
if (rect_intersect(&rect, &clip_rect, &draw_rect))
{
x1 = x;
y1 = y + total_height;
draw_rect.right--;
draw_rect.bottom--;
flags = 0x03; /* 0x73; TEXT2_IMPLICIT_X and something else */
xrdp_orders_text(self->orders, f, flags, 0,
font->color, 0,
x, y, x + total_width, y + total_height,
0, 0, 0, 0, x1, y1, data, len * 2, &draw_rect);
}
k++;
}
xrdp_region_delete(region);

2
xrdp/xrdp_rdp.c
Unescape View File

@ -546,7 +546,7 @@ int xrdp_rdp_process_screen_update(struct xrdp_rdp* self, struct stream* s)
in_uint16_le(s, top);
in_uint16_le(s, right);
in_uint16_le(s, bottom);
xrdp_wm_rect(&rect, left, top, (right - left) + 1, (bottom - top) + 1);
MAKERECT(rect, left, top, (right - left) + 1, (bottom - top) + 1);
if (self->up_and_running && self->pro_layer->wm != 0)
xrdp_bitmap_invalidate(self->pro_layer->wm->screen, &rect);
return 0;

155
xrdp/xrdp_wm.c
Unescape View File

@ -131,30 +131,6 @@ int xrdp_wm_send_bitmap(struct xrdp_wm* self, struct xrdp_bitmap* bitmap,
return 0;
}
/*****************************************************************************/
int xrdp_wm_color15(int r, int g, int b)
{
r = r >> 3;
g = g >> 3;
b = b >> 3;
return (r << 10) | (g << 5) | b;
}
/*****************************************************************************/
int xrdp_wm_color16(int r, int g, int b)
{
r = r >> 3;
g = g >> 2;
b = b >> 3;
return (r << 11) | (g << 5) | b;
}
/*****************************************************************************/
int xrdp_wm_color24(int r, int g, int b)
{
return r | (g << 8) | (b << 16);
}
/*****************************************************************************/
/* all login help screen events go here */
int xrdp_wm_login_help_notify(struct xrdp_bitmap* wnd,
@ -284,7 +260,7 @@ int xrdp_wm_login_notify(struct xrdp_bitmap* wnd,
b = (struct xrdp_bitmap*)
xrdp_list_get_item(wnd->wm->screen->child_list, i);
xrdp_list_remove_item(sender->wm->screen->child_list, i);
xrdp_wm_rect(&rect, b->left, b->top, b->width, b->height);
MAKERECT(rect, b->left, b->top, b->width, b->height);
xrdp_bitmap_invalidate(wnd->wm->screen, &rect);
xrdp_bitmap_delete(sender);
wnd->modal_dialog = 0;
@ -451,33 +427,33 @@ int xrdp_wm_init(struct xrdp_wm* self)
}
else if (self->screen->bpp == 15)
{
self->black = xrdp_wm_color15(0, 0, 0);
self->grey = xrdp_wm_color15(0xc0, 0xc0, 0xc0);
self->dark_grey = xrdp_wm_color15(0x80, 0x80, 0x80);
self->blue = xrdp_wm_color15(0x00, 0x00, 0xff);
self->white = xrdp_wm_color15(0xff, 0xff, 0xff);
self->red = xrdp_wm_color15(0xff, 0x00, 0x00);
self->green = xrdp_wm_color15(0x00, 0xff, 0x00);
self->black = color15(0, 0, 0);
self->grey = color15(0xc0, 0xc0, 0xc0);
self->dark_grey = color15(0x80, 0x80, 0x80);
self->blue = color15(0x00, 0x00, 0xff);
self->white = color15(0xff, 0xff, 0xff);
self->red = color15(0xff, 0x00, 0x00);
self->green = color15(0x00, 0xff, 0x00);
}
else if (self->screen->bpp == 16)
{
self->black = xrdp_wm_color16(0, 0, 0);
self->grey = xrdp_wm_color16(0xc0, 0xc0, 0xc0);
self->dark_grey = xrdp_wm_color16(0x80, 0x80, 0x80);
self->blue = xrdp_wm_color16(0x00, 0x00, 0xff);
self->white = xrdp_wm_color16(0xff, 0xff, 0xff);
self->red = xrdp_wm_color16(0xff, 0x00, 0x00);
self->green = xrdp_wm_color16(0x00, 0xff, 0x00);
self->black = color16(0, 0, 0);
self->grey = color16(0xc0, 0xc0, 0xc0);
self->dark_grey = color16(0x80, 0x80, 0x80);
self->blue = color16(0x00, 0x00, 0xff);
self->white = color16(0xff, 0xff, 0xff);
self->red = color16(0xff, 0x00, 0x00);
self->green = color16(0x00, 0xff, 0x00);
}
else if (self->screen->bpp == 24)
{
self->black = xrdp_wm_color24(0, 0, 0);
self->grey = xrdp_wm_color24(0xc0, 0xc0, 0xc0);
self->dark_grey = xrdp_wm_color24(0x80, 0x80, 0x80);
self->blue = xrdp_wm_color24(0x00, 0x00, 0xff);
self->white = xrdp_wm_color24(0xff, 0xff, 0xff);
self->red = xrdp_wm_color24(0xff, 0x00, 0x00);
self->green = xrdp_wm_color24(0x00, 0xff, 0x00);
self->black = color24(0, 0, 0);
self->grey = color24(0xc0, 0xc0, 0xc0);
self->dark_grey = color24(0x80, 0x80, 0x80);
self->blue = color24(0x00, 0x00, 0xff);
self->white = color24(0xff, 0xff, 0xff);
self->red = color24(0xff, 0x00, 0x00);
self->green = color24(0x00, 0xff, 0x00);
}
/* draw login window */
self->login_window = xrdp_bitmap_create(400, 200, self->screen->bpp, 1);
@ -606,30 +582,29 @@ int xrdp_wm_get_vis_region(struct xrdp_wm* self, struct xrdp_bitmap* bitmap,
struct xrdp_rect b;
/* area we are drawing */
xrdp_wm_rect(&a, bitmap->left + x, bitmap->top + y, cx, cy);
MAKERECT(a, bitmap->left + x, bitmap->top + y, cx, cy);
p = bitmap->parent;
while (p != 0)
{
xrdp_wm_rect_offset(&a, p->left, p->top);
RECTOFFSET(a, p->left, p->top);
p = p->parent;
}
a.left = MAX(self->screen->left, a.left);
a.top = MAX(self->screen->top, a.top);
a.right = MIN(self->screen->left + self->screen->width, a.right);
a.bottom = MIN(self->screen->top + self->screen->height, a.bottom);
xrdp_region_add_rect(region, &a);
if (bitmap == self->screen)
return 0;
/* loop through all windows in z order */
for (i = 0; i < self->screen->child_list->count; i++)
{
p = (struct xrdp_bitmap*)xrdp_list_get_item(self->screen->child_list, i);
if (p == bitmap || p == bitmap->parent)
return 0;
xrdp_wm_rect(&b, p->left, p->top, p->width, p->height);
MAKERECT(b, p->left, p->top, p->width, p->height);
xrdp_region_subtract_rect(region, &b);
}
return 0;
}
@ -735,8 +710,7 @@ int xrdp_wm_bitblt(struct xrdp_wm* self,
int xrdp_wm_is_rect_vis(struct xrdp_wm* self, struct xrdp_bitmap* wnd,
struct xrdp_rect* rect)
{
struct xrdp_rect rect1;
struct xrdp_rect rect2;
struct xrdp_rect wnd_rect;
struct xrdp_bitmap* b;
int i;;
@ -755,8 +729,8 @@ int xrdp_wm_is_rect_vis(struct xrdp_wm* self, struct xrdp_bitmap* wnd,
while (i >= 0)
{
b = (struct xrdp_bitmap*)xrdp_list_get_item(self->screen->child_list, i);
xrdp_wm_rect(&rect1, b->left, b->top, b->width, b->height);
if (xrdp_wm_rect_intersect(rect, &rect1, &rect2))
MAKERECT(wnd_rect, b->left, b->top, b->width, b->height);
if (rect_intersect(rect, &wnd_rect, 0))
return 0;
i--;
}
@ -772,11 +746,11 @@ int xrdp_wm_move_window(struct xrdp_wm* self, struct xrdp_bitmap* wnd,
struct xrdp_region* r;
int i;
xrdp_wm_rect(&rect1, wnd->left, wnd->top, wnd->width, wnd->height);
MAKERECT(rect1, wnd->left, wnd->top, wnd->width, wnd->height);
if (xrdp_wm_is_rect_vis(self, wnd, &rect1))
{
rect2 = rect1;
xrdp_wm_rect_offset(&rect2, dx, dy);
RECTOFFSET(rect2, dx, dy);
if (xrdp_wm_is_rect_vis(self, wnd, &rect2))
{ /* if both src and dst are unobscured, we can do a bitblt move */
xrdp_wm_bitblt(self, self->screen, wnd->left + dx, wnd->top + dy,
@ -804,67 +778,6 @@ int xrdp_wm_move_window(struct xrdp_wm* self, struct xrdp_bitmap* wnd,
return 0;
}
/*****************************************************************************/
int xrdp_wm_rect(struct xrdp_rect* r, int x, int y, int cx, int cy)
{
r->left = x;
r->top = y;
r->right = x + cx;
r->bottom = y + cy;
return 0;
}
/*****************************************************************************/
int xrdp_wm_rect_is_empty(struct xrdp_rect* in)
{
return (in->right <= in->left) || (in->bottom <= in->top);
}
/*****************************************************************************/
int xrdp_wm_rect_contains_pt(struct xrdp_rect* in, int x, int y)
{
if (x < in->left)
return 0;
if (y < in->top)
return 0;
if (x >= in->right)
return 0;
if (y >= in->bottom)
return 0;
return 1;
}
/*****************************************************************************/
int xrdp_wm_rect_intersect(struct xrdp_rect* in1, struct xrdp_rect* in2,
struct xrdp_rect* out)
{
int rv;
*out = *in1;
if (in2->left > in1->left)
out->left = in2->left;
if (in2->top > in1->top)
out->top = in2->top;
if (in2->right < in1->right)
out->right = in2->right;
if (in2->bottom < in1->bottom)
out->bottom = in2->bottom;
rv = !xrdp_wm_rect_is_empty(out);
if (!rv)
g_memset(out, 0, sizeof(struct xrdp_rect));
return rv;
}
/*****************************************************************************/
int xrdp_wm_rect_offset(struct xrdp_rect* in, int dx, int dy)
{
in->left += dx;
in->right += dx;
in->top += dy;
in->bottom += dy;
return 0;
}
/*****************************************************************************/
int xrdp_wm_mouse_move(struct xrdp_wm* self, int x, int y)
{

Write Preview
Loading…
Cancel
Save