{
XSetRegion(xfc->display, xfc->gc, reg1);
XFillRectangle(xfc->display, xfc->window->handle, xfc->gc, 0, 0,
- xfc->window->width, xfc->window->height);
+ xfc->window->width, xfc->window->height);
XSetClipMask(xfc->display, xfc->gc, None);
}
picFormat = XRenderFindVisualFormat(xfc->display, xfc->visual);
pa.subwindow_mode = IncludeInferiors;
primaryPicture = XRenderCreatePicture(xfc->display, xfc->primary, picFormat,
- CPSubwindowMode, &pa);
+ CPSubwindowMode, &pa);
windowPicture = XRenderCreatePicture(xfc->display, xfc->window->handle,
- picFormat, CPSubwindowMode, &pa);
+ picFormat, CPSubwindowMode, &pa);
XRenderSetPictureFilter(xfc->display, primaryPicture, FilterBilinear, 0, 0);
transform.matrix[0][0] = XDoubleToFixed(xScalingFactor);
transform.matrix[0][1] = XDoubleToFixed(0.0);
h = ceil(y2 / yScalingFactor) + 1 - y;
XRenderSetPictureTransform(xfc->display, primaryPicture, &transform);
XRenderComposite(xfc->display, PictOpSrc, primaryPicture, 0, windowPicture, x,
- y, 0, 0, xfc->offset_x + x, xfc->offset_y + y, w, h);
+ y, 0, 0, xfc->offset_x + x, xfc->offset_y + y, w, h);
XRenderFreePicture(xfc->display, primaryPicture);
XRenderFreePicture(xfc->display, windowPicture);
}
#endif
XCopyArea(xfc->display, xfc->primary, xfc->window->handle, xfc->gc, x, y, w, h,
- x, y);
+ x, y);
}
static BOOL xf_desktop_resize(rdpContext* context)
XFreePixmap(xfc->display, xfc->primary);
if (!(xfc->primary = XCreatePixmap(
- xfc->display, xfc->drawable,
- settings->DesktopWidth,
- settings->DesktopHeight, xfc->depth)))
+ xfc->display, xfc->drawable,
+ settings->DesktopWidth,
+ settings->DesktopHeight, xfc->depth)))
return FALSE;
if (same)
if (!xfc->fullscreen)
{
xf_ResizeDesktopWindow(xfc, xfc->window, settings->DesktopWidth,
- settings->DesktopHeight);
+ settings->DesktopHeight);
}
else
{
XSetFillStyle(xfc->display, xfc->gc, FillSolid);
XSetForeground(xfc->display, xfc->gc, 0);
XFillRectangle(xfc->display, xfc->drawable, xfc->gc, 0, 0, xfc->window->width,
- xfc->window->height);
+ xfc->window->height);
}
return TRUE;
xf_lock_x11(xfc, FALSE);
XPutImage(xfc->display, xfc->primary, xfc->gc, xfc->image,
- x, y, x, y, w, h);
+ x, y, x, y, w, h);
xf_draw_screen(xfc, x, y, w, h);
xf_unlock_x11(xfc, FALSE);
}
w = cinvalid[i].w;
h = cinvalid[i].h;
XPutImage(xfc->display, xfc->primary, xfc->gc,
- xfc->image, x, y, x, y, w, h);
+ xfc->image, x, y, x, y, w, h);
xf_draw_screen(xfc, x, y, w, h);
}
}
if (!(xfc->image = XCreateImage(xfc->display, xfc->visual, xfc->depth, ZPixmap,
- 0,
- (char*) gdi->primary_buffer, gdi->width, gdi->height, xfc->scanline_pad, 0)))
+ 0,
+ (char*) gdi->primary_buffer, gdi->width, gdi->height, xfc->scanline_pad, 0)))
{
goto out;
}
else if (settings->ServerPort == 3389)
{
windowTitle = malloc(1 + sizeof("FreeRDP: ") + strlen(
- settings->ServerHostname));
+ settings->ServerHostname));
sprintf(windowTitle, "FreeRDP: %s", settings->ServerHostname);
}
else
{
windowTitle = malloc(1 + sizeof("FreeRDP: ") + strlen(settings->ServerHostname)
- + sizeof(":00000"));
+ + sizeof(":00000"));
sprintf(windowTitle, "FreeRDP: %s:%i", settings->ServerHostname,
- settings->ServerPort);
+ settings->ServerPort);
}
#ifdef WITH_XRENDER
if (!xfc->primary)
xfc->primary = XCreatePixmap(xfc->display, xfc->drawable,
- settings->DesktopWidth,
- settings->DesktopHeight, xfc->depth);
+ settings->DesktopWidth,
+ settings->DesktopHeight, xfc->depth);
xfc->drawing = xfc->primary;
if (!xfc->gc_mono)
xfc->gc_mono = XCreateGC(xfc->display, xfc->bitmap_mono, GCGraphicsExposures,
- &gcv);
+ &gcv);
XSetFunction(xfc->display, xfc->gc, GXcopy);
XSetFillStyle(xfc->display, xfc->gc, FillSolid);
XSetForeground(xfc->display, xfc->gc, BlackPixelOfScreen(xfc->screen));
XFillRectangle(xfc->display, xfc->primary, xfc->gc, 0, 0,
- settings->DesktopWidth,
- settings->DesktopHeight);
+ settings->DesktopWidth,
+ settings->DesktopHeight);
XFlush(xfc->display);
if (!xfc->image)
{
rdpGdi* gdi = xfc->context.gdi;
xfc->image = XCreateImage(xfc->display, xfc->visual,
- xfc->depth,
- ZPixmap, 0, (char*) gdi->primary_buffer,
- settings->DesktopWidth, settings->DesktopHeight,
- xfc->scanline_pad, 0);
+ xfc->depth,
+ ZPixmap, 0, (char*) gdi->primary_buffer,
+ settings->DesktopWidth, settings->DesktopHeight,
+ xfc->scanline_pad, 0);
}
return TRUE;
* @return 0 on success, otherwise a Win32 error code
*/
static UINT xf_encomsp_participant_created(EncomspClientContext* context,
- ENCOMSP_PARTICIPANT_CREATED_PDU* participantCreated)
+ ENCOMSP_PARTICIPANT_CREATED_PDU* participantCreated)
{
return CHANNEL_RC_OK;
}
template.screen = xfc->screen_number;
if (XGetWindowAttributes(xfc->display, RootWindowOfScreen(xfc->screen),
- &window_attributes) == 0)
+ &window_attributes) == 0)
{
WLog_ERR(TAG, "XGetWindowAttributes failed");
return FALSE;
}
vis = XGetVisualInfo(xfc->display, VisualClassMask | VisualScreenMask,
- &template, &vi_count);
+ &template, &vi_count);
if (!vis)
{
/* calculate color shifts required for rdp order color conversion */
xf_calculate_color_shifts(vi->red_mask, &xfc->red_shift_r, &xfc->red_shift_l);
xf_calculate_color_shifts(vi->green_mask, &xfc->green_shift_r,
- &xfc->green_shift_l);
+ &xfc->green_shift_l);
xf_calculate_color_shifts(vi->blue_mask, &xfc->blue_shift_r,
- &xfc->blue_shift_l);
+ &xfc->blue_shift_l);
}
XFree(vis);
}
static BOOL xf_play_sound(rdpContext* context,
- const PLAY_SOUND_UPDATE* play_sound)
+ const PLAY_SOUND_UPDATE* play_sound)
{
xfContext* xfc = (xfContext*) context;
XkbBell(xfc->display, None, 100, 0);
if (XkbLibraryVersion(&xkb_major, &xkb_minor)
&& XkbQueryExtension(context->display, &xkb_opcode, &xkb_event,
- &xkb_error, &xkb_major, &xkb_minor))
+ &xkb_error, &xkb_major, &xkb_minor))
{
context->xkbAvailable = TRUE;
}
int xrender_error_base;
if (XRenderQueryExtension(context->display, &xrender_event_base,
- &xrender_error_base))
+ &xrender_error_base))
{
context->xrenderAvailable = TRUE;
}
else
{
WLog_ERR(TAG, "Mouse physical button %d is mapped to logical button %d",
- physical, logical);
+ physical, logical);
}
}
}
settings->OrderSupport[NEG_ELLIPSE_SC_INDEX] = FALSE;
settings->OrderSupport[NEG_ELLIPSE_CB_INDEX] = FALSE;
PubSub_SubscribeChannelConnected(instance->context->pubSub,
- (pChannelConnectedEventHandler) xf_OnChannelConnectedEventHandler);
+ (pChannelConnectedEventHandler) xf_OnChannelConnectedEventHandler);
PubSub_SubscribeChannelDisconnected(instance->context->pubSub,
- (pChannelDisconnectedEventHandler) xf_OnChannelDisconnectedEventHandler);
+ (pChannelDisconnectedEventHandler) xf_OnChannelDisconnectedEventHandler);
if (!freerdp_client_load_addins(channels, instance->settings))
return FALSE;
else
{
if (!(inputEvent = freerdp_get_message_queue_event_handle(instance,
- FREERDP_INPUT_MESSAGE_QUEUE)))
+ FREERDP_INPUT_MESSAGE_QUEUE)))
{
WLog_ERR(TAG, "async input: failed to get input event handle");
exit_code = XF_EXIT_UNKNOWN;
}
if (!(inputThread = CreateThread(NULL, 0,
- (LPTHREAD_START_ROUTINE) xf_input_thread, instance, 0, NULL)))
+ (LPTHREAD_START_ROUTINE) xf_input_thread, instance, 0, NULL)))
{
WLog_ERR(TAG, "async input: failed to create input thread");
exit_code = XF_EXIT_UNKNOWN;
if (WaitForSingleObject(inputEvent, 0) == WAIT_OBJECT_0)
{
if (!freerdp_message_queue_process_pending_messages(instance,
- FREERDP_INPUT_MESSAGE_QUEUE))
+ FREERDP_INPUT_MESSAGE_QUEUE))
{
WLog_INFO(TAG, "User Disconnect");
xfc->disconnect = TRUE;
if (settings->AsyncInput)
{
wMessageQueue* inputQueue = freerdp_get_message_queue(instance,
- FREERDP_INPUT_MESSAGE_QUEUE);
+ FREERDP_INPUT_MESSAGE_QUEUE);
if (MessageQueue_PostQuit(inputQueue, 0))
WaitForSingleObject(inputThread, INFINITE);
DWORD xf_exit_code_from_disconnect_reason(DWORD reason)
{
if (reason == 0 || (reason >= XF_EXIT_PARSE_ARGUMENTS
- && reason <= XF_EXIT_AUTH_FAILURE))
+ && reason <= XF_EXIT_AUTH_FAILURE))
return reason;
/* License error set */
else if (reason >= 0x100 && reason <= 0x10A)
- reason -= 0x100 + XF_EXIT_LICENSE_INTERNAL;
+ reason -= 0x100 + XF_EXIT_LICENSE_INTERNAL;
/* RDP protocol error set */
else if (reason >= 0x10c9 && reason <= 0x1193)
- reason = XF_EXIT_RDP;
+ reason = XF_EXIT_RDP;
/* There's no need to test protocol-independent codes: they match */
else if (!(reason <= 0xC))
- reason = XF_EXIT_UNKNOWN;
+ reason = XF_EXIT_UNKNOWN;
return reason;
}
if (context->settings->AsyncInput)
{
queue = freerdp_get_message_queue(context->instance,
- FREERDP_INPUT_MESSAGE_QUEUE);
+ FREERDP_INPUT_MESSAGE_QUEUE);
if (queue)
MessageQueue_PostQuit(queue, 0);
#ifdef WITH_XRENDER
static void xf_ZoomingChangeEventHandler(rdpContext* context,
- ZoomingChangeEventArgs* e)
+ ZoomingChangeEventArgs* e)
{
xfContext* xfc = (xfContext*) context;
rdpSettings* settings = context->settings;
}
static void xf_PanningChangeEventHandler(rdpContext* context,
- PanningChangeEventArgs* e)
+ PanningChangeEventArgs* e)
{
xfContext* xfc = (xfContext*) context;
rdpSettings* settings = context->settings;
if (!settings->ServerHostname)
{
WLog_ERR(TAG,
- "error: server hostname was not specified with /v:<server>[:port]");
+ "error: server hostname was not specified with /v:<server>[:port]");
return -1;
}
xfc->disconnect = FALSE;
if (!(xfc->thread = CreateThread(NULL, 0,
- (LPTHREAD_START_ROUTINE) xf_client_thread,
- context->instance, 0, NULL)))
+ (LPTHREAD_START_ROUTINE) xf_client_thread,
+ context->instance, 0, NULL)))
{
WLog_ERR(TAG, "failed to create client thread");
return -1;
{
wMessageQueue* queue;
queue = freerdp_get_message_queue(context->instance,
- FREERDP_INPUT_MESSAGE_QUEUE);
+ FREERDP_INPUT_MESSAGE_QUEUE);
if (queue)
MessageQueue_PostQuit(queue, 0);
settings = instance->settings;
xfc->settings = instance->context->settings;
PubSub_SubscribeTerminate(context->pubSub,
- (pTerminateEventHandler) xf_TerminateEventHandler);
+ (pTerminateEventHandler) xf_TerminateEventHandler);
#ifdef WITH_XRENDER
PubSub_SubscribeZoomingChange(context->pubSub,
- (pZoomingChangeEventHandler) xf_ZoomingChangeEventHandler);
+ (pZoomingChangeEventHandler) xf_ZoomingChangeEventHandler);
PubSub_SubscribePanningChange(context->pubSub,
- (pPanningChangeEventHandler) xf_PanningChangeEventHandler);
+ (pPanningChangeEventHandler) xf_PanningChangeEventHandler);
#endif
xfc->UseXThreads = TRUE;
//xfc->debug = TRUE;
{
WLog_ERR(TAG, "failed to open display: %s", XDisplayName(NULL));
WLog_ERR(TAG,
- "Please check that the $DISPLAY environment variable is properly set.");
+ "Please check that the $DISPLAY environment variable is properly set.");
goto fail_open_display;
}
xfc->_NET_WM_ICON = XInternAtom(xfc->display, "_NET_WM_ICON", False);
xfc->_MOTIF_WM_HINTS = XInternAtom(xfc->display, "_MOTIF_WM_HINTS", False);
xfc->_NET_CURRENT_DESKTOP = XInternAtom(xfc->display, "_NET_CURRENT_DESKTOP",
- False);
+ False);
xfc->_NET_WORKAREA = XInternAtom(xfc->display, "_NET_WORKAREA", False);
xfc->_NET_WM_STATE = XInternAtom(xfc->display, "_NET_WM_STATE", False);
xfc->_NET_WM_STATE_FULLSCREEN = XInternAtom(xfc->display,
- "_NET_WM_STATE_FULLSCREEN", False);
+ "_NET_WM_STATE_FULLSCREEN", False);
xfc->_NET_WM_STATE_MAXIMIZED_HORZ = XInternAtom(xfc->display,
- "_NET_WM_STATE_MAXIMIZED_HORZ", False);
+ "_NET_WM_STATE_MAXIMIZED_HORZ", False);
xfc->_NET_WM_STATE_MAXIMIZED_VERT = XInternAtom(xfc->display,
- "_NET_WM_STATE_MAXIMIZED_VERT", False);
+ "_NET_WM_STATE_MAXIMIZED_VERT", False);
xfc->_NET_WM_FULLSCREEN_MONITORS = XInternAtom(xfc->display,
- "_NET_WM_FULLSCREEN_MONITORS", False);
+ "_NET_WM_FULLSCREEN_MONITORS", False);
xfc->_NET_WM_NAME = XInternAtom(xfc->display, "_NET_WM_NAME", False);
xfc->_NET_WM_PID = XInternAtom(xfc->display, "_NET_WM_PID", False);
xfc->_NET_WM_WINDOW_TYPE = XInternAtom(xfc->display, "_NET_WM_WINDOW_TYPE",
- False);
+ False);
xfc->_NET_WM_WINDOW_TYPE_NORMAL = XInternAtom(xfc->display,
- "_NET_WM_WINDOW_TYPE_NORMAL", False);
+ "_NET_WM_WINDOW_TYPE_NORMAL", False);
xfc->_NET_WM_WINDOW_TYPE_DIALOG = XInternAtom(xfc->display,
- "_NET_WM_WINDOW_TYPE_DIALOG", False);
+ "_NET_WM_WINDOW_TYPE_DIALOG", False);
xfc->_NET_WM_WINDOW_TYPE_POPUP = XInternAtom(xfc->display,
- "_NET_WM_WINDOW_TYPE_POPUP", False);
+ "_NET_WM_WINDOW_TYPE_POPUP", False);
xfc->_NET_WM_WINDOW_TYPE_UTILITY = XInternAtom(xfc->display,
- "_NET_WM_WINDOW_TYPE_UTILITY", False);
+ "_NET_WM_WINDOW_TYPE_UTILITY", False);
xfc->_NET_WM_WINDOW_TYPE_DROPDOWN_MENU = XInternAtom(xfc->display,
- "_NET_WM_WINDOW_TYPE_DROPDOWN_MENU", False);
+ "_NET_WM_WINDOW_TYPE_DROPDOWN_MENU", False);
xfc->_NET_WM_STATE_SKIP_TASKBAR = XInternAtom(xfc->display,
- "_NET_WM_STATE_SKIP_TASKBAR", False);
+ "_NET_WM_STATE_SKIP_TASKBAR", False);
xfc->_NET_WM_STATE_SKIP_PAGER = XInternAtom(xfc->display,
- "_NET_WM_STATE_SKIP_PAGER", False);
+ "_NET_WM_STATE_SKIP_PAGER", False);
xfc->_NET_WM_MOVERESIZE = XInternAtom(xfc->display, "_NET_WM_MOVERESIZE",
- False);
+ False);
xfc->_NET_MOVERESIZE_WINDOW = XInternAtom(xfc->display,
- "_NET_MOVERESIZE_WINDOW", False);
+ "_NET_MOVERESIZE_WINDOW", False);
xfc->UTF8_STRING = XInternAtom(xfc->display, "UTF8_STRING", FALSE);
xfc->WM_PROTOCOLS = XInternAtom(xfc->display, "WM_PROTOCOLS", False);
xfc->WM_DELETE_WINDOW = XInternAtom(xfc->display, "WM_DELETE_WINDOW", False);
xfc->invert = (ImageByteOrder(xfc->display) == MSBFirst) ? TRUE : FALSE;
xfc->complex_regions = TRUE;
xfc->x11event = CreateFileDescriptorEvent(NULL, FALSE, FALSE, xfc->xfds,
- WINPR_FD_READ);
+ WINPR_FD_READ);
if (!xfc->x11event)
{
else
xfc->format = PIXEL_FORMAT_RGBX32;
- xfc->format = PIXEL_FORMAT_RGBX32;
-
if (xfc->debug)
{
WLog_INFO(TAG, "Enabling X11 debug mode.");
#define TAG FREERDP_TAG("cache.bitmap")
static rdpBitmap* bitmap_cache_get(rdpBitmapCache* bitmapCache, UINT32 id,
- UINT32 index);
+ UINT32 index);
static void bitmap_cache_put(rdpBitmapCache* bitmap_cache, UINT32 id,
- UINT32 index, rdpBitmap* bitmap);
+ UINT32 index, rdpBitmap* bitmap);
static BOOL update_gdi_memblt(rdpContext* context,
- MEMBLT_ORDER* memblt)
+ MEMBLT_ORDER* memblt)
{
rdpBitmap* bitmap;
rdpCache* cache = context->cache;
bitmap = offscreen_cache_get(cache->offscreen, memblt->cacheIndex);
else
bitmap = bitmap_cache_get(cache->bitmap, (BYTE) memblt->cacheId,
- memblt->cacheIndex);
+ memblt->cacheIndex);
/* XP-SP2 servers sometimes ask for cached bitmaps they've never defined. */
if (bitmap == NULL)
}
static BOOL update_gdi_mem3blt(rdpContext* context,
- MEM3BLT_ORDER* mem3blt)
+ MEM3BLT_ORDER* mem3blt)
{
BYTE style;
rdpBitmap* bitmap;
bitmap = offscreen_cache_get(cache->offscreen, mem3blt->cacheIndex);
else
bitmap = bitmap_cache_get(cache->bitmap, (BYTE) mem3blt->cacheId,
- mem3blt->cacheIndex);
+ mem3blt->cacheIndex);
/* XP-SP2 servers sometimes ask for cached bitmaps they've never defined. */
if (!bitmap)
}
static BOOL update_gdi_cache_bitmap(rdpContext* context,
- const CACHE_BITMAP_ORDER* cacheBitmap)
+ const CACHE_BITMAP_ORDER* cacheBitmap)
{
rdpBitmap* bitmap;
rdpBitmap* prevBitmap;
return FALSE;
if (!bitmap->Decompress(context, bitmap,
- cacheBitmap->bitmapDataStream, cacheBitmap->bitmapWidth,
- cacheBitmap->bitmapHeight,
- cacheBitmap->bitmapBpp, cacheBitmap->bitmapLength,
- cacheBitmap->compressed, RDP_CODEC_ID_NONE))
+ cacheBitmap->bitmapDataStream, cacheBitmap->bitmapWidth,
+ cacheBitmap->bitmapHeight,
+ cacheBitmap->bitmapBpp, cacheBitmap->bitmapLength,
+ cacheBitmap->compressed, RDP_CODEC_ID_NONE))
{
bitmap->Free(context, bitmap);
return FALSE;
}
prevBitmap = bitmap_cache_get(cache->bitmap, cacheBitmap->cacheId,
- cacheBitmap->cacheIndex);
+ cacheBitmap->cacheIndex);
if (prevBitmap != NULL)
prevBitmap->Free(context, prevBitmap);
bitmap_cache_put(cache->bitmap, cacheBitmap->cacheId, cacheBitmap->cacheIndex,
- bitmap);
+ bitmap);
return TRUE;
}
static BOOL update_gdi_cache_bitmap_v2(rdpContext* context,
- CACHE_BITMAP_V2_ORDER* cacheBitmapV2)
+ CACHE_BITMAP_V2_ORDER* cacheBitmapV2)
{
rdpBitmap* bitmap;
cacheBitmapV2->bitmapBpp = settings->ColorDepth;
if (!bitmap->Decompress(context, bitmap,
- cacheBitmapV2->bitmapDataStream,
- cacheBitmapV2->bitmapWidth,
- cacheBitmapV2->bitmapHeight,
- cacheBitmapV2->bitmapBpp,
- cacheBitmapV2->bitmapLength,
- cacheBitmapV2->compressed,
- RDP_CODEC_ID_NONE))
+ cacheBitmapV2->bitmapDataStream,
+ cacheBitmapV2->bitmapWidth,
+ cacheBitmapV2->bitmapHeight,
+ cacheBitmapV2->bitmapBpp,
+ cacheBitmapV2->bitmapLength,
+ cacheBitmapV2->compressed,
+ RDP_CODEC_ID_NONE))
{
bitmap->Free(context, bitmap);
return FALSE;
}
prevBitmap = bitmap_cache_get(cache->bitmap, cacheBitmapV2->cacheId,
- cacheBitmapV2->cacheIndex);
+ cacheBitmapV2->cacheIndex);
if (!bitmap->New(context, bitmap))
return FALSE;
prevBitmap->Free(context, prevBitmap);
bitmap_cache_put(cache->bitmap, cacheBitmapV2->cacheId,
- cacheBitmapV2->cacheIndex, bitmap);
+ cacheBitmapV2->cacheIndex, bitmap);
return TRUE;
}
static BOOL update_gdi_cache_bitmap_v3(rdpContext* context,
- CACHE_BITMAP_V3_ORDER* cacheBitmapV3)
+ CACHE_BITMAP_V3_ORDER* cacheBitmapV3)
{
rdpBitmap* bitmap;
rdpBitmap* prevBitmap;
compressed = (bitmapData->codecID != RDP_CODEC_ID_NONE);
bitmap->Decompress(context, bitmap,
- bitmapData->data, bitmapData->width, bitmapData->height,
- bitmapData->bpp, bitmapData->length, compressed,
- bitmapData->codecID);
+ bitmapData->data, bitmapData->width, bitmapData->height,
+ bitmapData->bpp, bitmapData->length, compressed,
+ bitmapData->codecID);
if (!bitmap->New(context, bitmap))
return FALSE;
prevBitmap = bitmap_cache_get(cache->bitmap, cacheBitmapV3->cacheId,
- cacheBitmapV3->cacheIndex);
+ cacheBitmapV3->cacheIndex);
if (prevBitmap)
prevBitmap->Free(context, prevBitmap);
bitmap_cache_put(cache->bitmap, cacheBitmapV3->cacheId,
- cacheBitmapV3->cacheIndex, bitmap);
+ cacheBitmapV3->cacheIndex, bitmap);
return TRUE;
}
static BOOL update_gdi_bitmap_update(rdpContext* context,
- const BITMAP_UPDATE* bitmapUpdate)
+ const BITMAP_UPDATE* bitmapUpdate)
{
UINT32 i;
BOOL reused = TRUE;
bitmap->length = bitmapData->bitmapLength;
bitmap->compressed = bitmapData->compressed;
Bitmap_SetRectangle(bitmap,
- bitmapData->destLeft, bitmapData->destTop,
- bitmapData->destRight, bitmapData->destBottom);
+ bitmapData->destLeft, bitmapData->destTop,
+ bitmapData->destRight, bitmapData->destBottom);
+
+ bitmap->Decompress(context, bitmap,
+ bitmapData->bitmapDataStream, bitmapData->width, bitmapData->height,
+ bitmapData->bitsPerPixel, bitmapData->bitmapLength,
+ bitmapData->compressed, RDP_CODEC_ID_NONE);
if (reused)
bitmap->Free(context, bitmap);
- bitmap->Decompress(context, bitmap,
- bitmapData->bitmapDataStream, bitmapData->width, bitmapData->height,
- bitmapData->bitsPerPixel, bitmapData->bitmapLength,
- bitmapData->compressed, RDP_CODEC_ID_NONE);
+ reused = TRUE;
if (!bitmap->New(context, bitmap))
return FALSE;
}
rdpBitmap* bitmap_cache_get(rdpBitmapCache* bitmapCache, UINT32 id,
- UINT32 index)
+ UINT32 index)
{
rdpBitmap* bitmap;
}
void bitmap_cache_put(rdpBitmapCache* bitmapCache, UINT32 id, UINT32 index,
- rdpBitmap* bitmap)
+ rdpBitmap* bitmap)
{
if (id > bitmapCache->maxCells)
{
bitmapCache->context = bitmapCache->update->context;
bitmapCache->maxCells = settings->BitmapCacheV2NumCells;
bitmapCache->cells = (BITMAP_V2_CELL*) calloc(bitmapCache->maxCells,
- sizeof(BITMAP_V2_CELL));
+ sizeof(BITMAP_V2_CELL));
if (!bitmapCache->cells)
{
bitmapCache->cells[i].number = settings->BitmapCacheV2CellInfo[i].numEntries;
/* allocate an extra entry for BITMAP_CACHE_WAITING_LIST_INDEX */
bitmapCache->cells[i].entries = (rdpBitmap**) calloc((
- bitmapCache->cells[i].number + 1), sizeof(rdpBitmap*));
+ bitmapCache->cells[i].number + 1), sizeof(rdpBitmap*));
}
}
return FALSE;
return freerdp_image_copy(hDstBmp->data, hDstBmp->format, hDstBmp->scanline,
- nXDest, nYDest, nWidth, nHeight,
- hSrcBmp->data, hSrcBmp->format, hSrcBmp->scanline,
+ nXDest, nYDest, nWidth, nHeight,
+ hSrcBmp->data, hSrcBmp->format, hSrcBmp->scanline,
nXSrc, nYSrc, palette);
}
{
UINT32 x, y;
+ /* SDna */
if (!hdcDest || !hdcSrc)
return FALSE;
UINT32 color;
colorA = ConvertColor(colorA, hdcSrc->format, hdcDest->format,
palette);
- color = colorA & ~colorB;
+ color = ~colorA & colorB;
WriteColor(dstp, hdcDest->format, color);
}
}
{
UINT32 x, y;
+ /* DSon */
if (!hdcDest || !hdcSrc)
return FALSE;
UINT32 colorB = ReadColor(dstp, hdcDest->format);
colorA = ConvertColor(colorA, hdcSrc->format,
hdcDest->format, palette);
- color = ~colorA & ~colorB;
+ color = ~colorA | colorB;
WriteColor(dstp, hdcDest->format, color);
}
}
{
UINT32 x, y;
+ /* DSx */
if (!hdcDest || !hdcSrc)
return FALSE;
{
UINT32 x, y;
+ /* DSa */
if (!hdcDest || !hdcSrc)
return FALSE;
{
UINT32 x, y;
+ /* DSo */
if (!hdcDest || !hdcSrc)
return FALSE;
UINT32 nXSrc, UINT32 nYSrc, const gdiPalette* palette)
{
UINT32 x, y;
- UINT32 color;
if (!hdcDest || !hdcSrc)
return FALSE;
- /* D = (D ^ S) & (P ^ D) */
- color = hdcDest->textColor;
+ if (hdcDest->brush->style == GDI_BS_SOLID)
+ {
+ UINT32 color = hdcDest->brush->color;
- for (y = 0; y < nHeight; y++)
+ for (y = 0; y < nHeight; y++)
+ {
+ for (x = 0; x < nWidth; x++)
+ {
+ const BYTE* srcp = gdi_get_bitmap_pointer(
+ hdcSrc, nXSrc + x, nYSrc + y);
+ BYTE* dstp = gdi_get_bitmap_pointer(
+ hdcDest, nXDest + x, nYDest + y);
+
+ if (srcp && dstp)
+ {
+ UINT32 dstColor;
+ UINT32 colorA = ReadColor(srcp, hdcSrc->format);
+ UINT32 colorB = ReadColor(dstp, hdcDest->format);
+ colorA = ConvertColor(colorA, hdcSrc->format,
+ hdcDest->format, palette);
+ dstColor = (colorA ^ color) & (colorA ^ colorB);
+ WriteColor(dstp, hdcDest->format, dstColor);
+ }
+ }
+ }
+ }
+ else
{
- for (x = 0; x < nWidth; x++)
+ for (y = 0; y < nHeight; y++)
{
- const BYTE* srcp = gdi_get_bitmap_pointer(
- hdcSrc, nXSrc + x, nYSrc + y);
- BYTE* dstp = gdi_get_bitmap_pointer(
- hdcDest, nXDest + x, nYDest + y);
+ for (x = 0; x < nWidth; x++)
+ {
+ const BYTE* patp = gdi_get_brush_pointer(
+ hdcDest, nXDest + x, nYDest + y);
+ const BYTE* srcp = gdi_get_bitmap_pointer(
+ hdcSrc, nXSrc + x, nYSrc + y);
+ BYTE* dstp = gdi_get_bitmap_pointer(
+ hdcDest, nXDest + x, nYDest + y);
- if (srcp && dstp)
+ if (srcp && dstp)
+ {
+ UINT32 dstColor;
+ UINT32 color = ReadColor(patp, hdcDest->format);
+ UINT32 colorA = ReadColor(srcp, hdcSrc->format);
+ UINT32 colorB = ReadColor(dstp, hdcDest->format);
+ colorA = ConvertColor(colorA, hdcSrc->format,
+ hdcDest->format, palette);
+ dstColor = (colorA ^ color) & (colorA ^ colorB);
+ WriteColor(dstp, hdcDest->format, dstColor);
+ }
+ }
+ }
+ }
+
+ return TRUE;
+}
+
+static BOOL BitBlt_DSPDxox(HGDI_DC hdcDest, UINT32 nXDest, UINT32 nYDest,
+ UINT32 nWidth, UINT32 nHeight, HGDI_DC hdcSrc,
+ UINT32 nXSrc, UINT32 nYSrc, const gdiPalette* palette)
+{
+ UINT32 x, y;
+
+ if (!hdcDest || !hdcSrc)
+ return FALSE;
+
+ if (hdcDest->brush->style == GDI_BS_SOLID)
+ {
+ UINT32 color = hdcDest->textColor;
+
+ for (y = 0; y < nHeight; y++)
+ {
+ for (x = 0; x < nWidth; x++)
{
- UINT32 dstColor;
- UINT32 colorA = ReadColor(srcp, hdcSrc->format);
- UINT32 colorB = ReadColor(dstp, hdcDest->format);
- colorA = ConvertColor(colorA, hdcSrc->format,
- hdcDest->format, palette);
- dstColor = (colorA & color) | (~colorA & colorB);
- WriteColor(dstp, hdcDest->format, dstColor);
+ const BYTE* srcp = gdi_get_bitmap_pointer(
+ hdcSrc, nXSrc + x, nYSrc + y);
+ BYTE* dstp = gdi_get_bitmap_pointer(
+ hdcDest, nXDest + x, nYDest + y);
+
+ if (srcp && dstp)
+ {
+ UINT32 dstColor;
+ UINT32 colorA = ReadColor(srcp, hdcSrc->format);
+ UINT32 colorB = ReadColor(dstp, hdcDest->format);
+ colorA = ConvertColor(colorA, hdcSrc->format,
+ hdcDest->format, palette);
+ dstColor = (colorA ^ color) | (colorA ^ colorB);
+ WriteColor(dstp, hdcDest->format, dstColor);
+ }
+ }
+ }
+ }
+ else
+ {
+ for (y = 0; y < nHeight; y++)
+ {
+ for (x = 0; x < nWidth; x++)
+ {
+ const BYTE* srcp = gdi_get_bitmap_pointer(
+ hdcSrc, nXSrc + x, nYSrc + y);
+ const BYTE* patp = gdi_get_brush_pointer(
+ hdcDest, nXDest + x, nYDest + y);
+ BYTE* dstp = gdi_get_bitmap_pointer(
+ hdcDest, nXDest + x, nYDest + y);
+
+ if (srcp && dstp)
+ {
+ UINT32 color;
+ UINT32 colorA = ReadColor(srcp, hdcSrc->format);
+ UINT32 colorB = ReadColor(dstp, hdcDest->format);
+ UINT32 colorC = ReadColor(patp, hdcDest->format);
+ colorA = ConvertColor(colorA, hdcSrc->format,
+ hdcDest->format, palette);
+ color = (colorA ^ colorB) | (colorA ^ colorC);
+ WriteColor(dstp, hdcDest->format, color);
+ }
}
}
}
if (!hdcDest || !hdcSrc)
return FALSE;
- /* D = (S & D) | (~S & P) */
if (hdcDest->brush->style == GDI_BS_SOLID)
{
UINT32 colorC = hdcDest->brush->color;
UINT32 colorB = ReadColor(dstp, hdcDest->format);
colorA = ConvertColor(colorA, hdcSrc->format,
hdcDest->format, palette);
- color = (colorA & colorB) | (~colorA & colorC);
+ color = (colorA ^ colorB) & (colorA ^ colorC);
WriteColor(dstp, hdcDest->format, color);
}
}
UINT32 colorC = ReadColor(patp, hdcDest->format);
colorA = ConvertColor(colorA, hdcSrc->format,
hdcDest->format, palette);
- color = (colorA & colorB) | (~colorA & colorC);
+ color = (colorA ^ colorB) & (colorA ^ colorC);
WriteColor(dstp, hdcDest->format, color);
}
}
UINT32 colorB = ReadColor(dstp, hdcDest->format);
colorA = ConvertColor(colorA, hdcSrc->format,
hdcDest->format, palette);
- colorD = colorA ^ (color & (colorB ^ colorA));
- WriteColor(dstp, hdcDest->format, color);
+ colorD = (colorA ^ color) & (colorB ^ colorA);
+ WriteColor(dstp, hdcDest->format, colorD);
}
}
}
UINT32 color = ReadColor(patp, hdcDest->format);
colorA = ConvertColor(colorA, hdcSrc->format,
hdcDest->format, palette);
- colorD = colorA ^ (color & (colorB ^ colorA));
- WriteColor(dstp, hdcDest->format, color);
+ colorD = (colorA ^ color) & (colorB ^ colorA);
+ WriteColor(dstp, hdcDest->format, colorD);
}
}
}
if (!hdcDest || !hdcSrc)
return FALSE;
- for (y = 0; y < nHeight; y++)
+ if (hdcDest->brush->style == GDI_BS_SOLID)
{
- for (x = 0; x < nWidth; x++)
+ UINT32 colorB = hdcDest->brush->color;
+
+ for (y = 0; y < nHeight; y++)
{
- const BYTE* srcp = gdi_get_bitmap_pointer(hdcSrc, nXSrc + x, nYSrc + y);
- const BYTE* patp = gdi_get_brush_pointer(hdcDest, nXDest + x, nYDest + y);
- BYTE* dstp = gdi_get_bitmap_pointer(hdcDest, nXDest + x, nYDest + y);
+ for (x = 0; x < nWidth; x++)
+ {
+ const BYTE* srcp = gdi_get_bitmap_pointer(hdcSrc, nXSrc + x, nYSrc + y);
+ BYTE* dstp = gdi_get_bitmap_pointer(hdcDest, nXDest + x, nYDest + y);
- if (srcp && patp && dstp)
+ if (srcp && dstp)
+ {
+ UINT32 color;
+ UINT32 colorA = ReadColor(srcp, hdcSrc->format);
+ colorB = ConvertColor(colorB, hdcDest->format,
+ hdcSrc->format, palette);
+ color = ~colorA & colorB;
+ color = ConvertColor(color, hdcSrc->format, hdcDest->format, palette);
+ WriteColor(dstp, hdcDest->format, color);
+ }
+ }
+ }
+ }
+ else
+ {
+ for (y = 0; y < nHeight; y++)
+ {
+ for (x = 0; x < nWidth; x++)
{
- UINT32 color;
- UINT32 colorA = ReadColor(srcp, hdcSrc->format);
- UINT32 colorB = ReadColor(patp, hdcDest->format);
- colorB = ConvertColor(colorB, hdcDest->format,
- hdcSrc->format, palette);
- color = colorA & ~colorB;
- color = ConvertColor(color, hdcSrc->format, hdcDest->format, palette);
- WriteColor(dstp, hdcDest->format, color);
+ const BYTE* srcp = gdi_get_bitmap_pointer(hdcSrc, nXSrc + x, nYSrc + y);
+ const BYTE* patp = gdi_get_brush_pointer(hdcDest, nXDest + x, nYDest + y);
+ BYTE* dstp = gdi_get_bitmap_pointer(hdcDest, nXDest + x, nYDest + y);
+
+ if (srcp && patp && dstp)
+ {
+ UINT32 color;
+ UINT32 colorA = ReadColor(srcp, hdcSrc->format);
+ UINT32 colorB = ReadColor(patp, hdcDest->format);
+ colorB = ConvertColor(colorB, hdcDest->format,
+ hdcSrc->format, palette);
+ color = ~colorA & colorB;
+ color = ConvertColor(color, hdcSrc->format, hdcDest->format, palette);
+ WriteColor(dstp, hdcDest->format, color);
+ }
}
}
}
UINT32 colorB = ReadColor(dstp, hdcDest->format);
colorA = ConvertColor(colorA, hdcSrc->format,
hdcDest->format, palette);
- color = ~colorA & colorB;
+ color = colorA & ~colorB;
WriteColor(dstp, hdcDest->format, color);
}
}
{
UINT32 x, y;
+ /* PSa */
if (!hdcDest || !hdcSrc)
return FALSE;
{
UINT32 x, y;
+ /* DSno */
if (!hdcDest || !hdcSrc)
return FALSE;
UINT32 color;
colorA = ConvertColor(colorA, hdcSrc->format, hdcDest->format,
palette);
- color = ~colorA | colorB;
+ color = colorA | ~colorB;
WriteColor(dstp, hdcDest->format, color);
}
}
return BitBlt_DSPDxax(hdcDest, nXDest, nYDest, nWidth, nHeight,
hdcSrc, nXSrc, nYSrc, palette);
+ case GDI_DSPDxox:
+ return BitBlt_DSPDxox(hdcDest, nXDest, nYDest, nWidth, nHeight,
+ hdcSrc, nXSrc, nYSrc, palette);
+
case GDI_PSDPxax:
return BitBlt_PSDPxax(hdcDest, nXDest, nYDest, nWidth, nHeight,
hdcSrc, nXSrc, nYSrc, palette);
{
UINT32 colorA = ReadColor(dstp, hdcDest->format);
UINT32 colorB = ReadColor(patp, hdcDest->format);
- UINT32 color = colorA ^ ~colorB;
+ UINT32 color = ~colorA ^ colorB;
WriteColor(dstp, hdcDest->format, color);
}
}
{
UINT32 x, y;
+ /* DPx */
if (hdcDest->brush->style == GDI_BS_SOLID)
{
UINT32 color = hdcDest->brush->color;
{
UINT32 x, y;
+ /* DPSnoo */
if (!hdcDest || !hdcSrc)
return FALSE;
{
UINT32 x, y, xOffset, yOffset;
+ /* P */
if (hdcDest->brush->style == GDI_BS_SOLID)
{
UINT32 color = hdcDest->brush->color;
gdi_glyph = (gdiGlyph*) glyph;
return gdi_BitBlt(gdi->drawing->hdc, x, y, gdi_glyph->bitmap->width,
gdi_glyph->bitmap->height, gdi_glyph->hdc, 0, 0,
- GDI_DSPDxax, &context->gdi->palette);
+ GDI_DSPDxox, &context->gdi->palette);
}
static BOOL gdi_Glyph_BeginDraw(rdpContext* context, UINT32 x, UINT32 y,
UINT32 fgcolor, BOOL fOpRedundant)
{
rdpGdi* gdi;
- GDI_RECT rect;
- HGDI_BRUSH brush;
if (!context || !context->gdi)
return FALSE;
if (!gdi_decode_color(gdi, fgcolor, &fgcolor, NULL))
return FALSE;
+ gdi->drawing->hdc->brush = gdi_CreateSolidBrush(fgcolor);
+
+ if (!gdi->drawing->hdc->brush)
+ return FALSE;
+
gdi_SetTextColor(gdi->drawing->hdc, fgcolor);
gdi_SetBkColor(gdi->drawing->hdc, bgcolor);
return gdi_SetClipRgn(gdi->drawing->hdc, x, y, width, height);
if (!gdi->drawing || !gdi->drawing->hdc)
return FALSE;
+ gdi_DeleteObject(gdi->drawing->hdc->brush);
gdi_SetNullClipRgn(gdi->drawing->hdc);
return TRUE;
}
projects / platform / upstream / freerdp.git / commitdiff