2011-08-26 02:07:52 +04:00
/**
* FreeRDP : A Remote Desktop Protocol Client
* X11 GDI
*
* Copyright 2011 Marc - Andre Moreau < marcandre . moreau @ gmail . com >
*
* Licensed under the Apache License , Version 2.0 ( the " License " ) ;
* you may not use this file except in compliance with the License .
* You may obtain a copy of the License at
*
* http : //www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing , software
* distributed under the License is distributed on an " AS IS " BASIS ,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND , either express or implied .
* See the License for the specific language governing permissions and
* limitations under the License .
*/
2011-10-27 21:29:16 +04:00
# include <X11/Xlib.h>
# include <X11/Xutil.h>
2011-09-12 06:32:22 +04:00
# include <freerdp/gdi/gdi.h>
2011-10-03 04:52:17 +04:00
# include <freerdp/codec/rfx.h>
# include <freerdp/codec/nsc.h>
2011-09-12 05:22:03 +04:00
# include <freerdp/constants.h>
2011-08-26 22:48:51 +04:00
# include <freerdp/utils/memory.h>
2011-10-03 04:28:20 +04:00
# include <freerdp/codec/color.h>
2011-10-03 07:09:13 +04:00
# include <freerdp/codec/bitmap.h>
2011-08-26 22:48:51 +04:00
2011-08-26 02:07:52 +04:00
# include "xf_gdi.h"
static const uint8 xf_rop2_table [ ] =
{
0 ,
GXclear , /* 0 */
GXnor , /* DPon */
GXandInverted , /* DPna */
GXcopyInverted , /* Pn */
GXandReverse , /* PDna */
GXinvert , /* Dn */
GXxor , /* DPx */
GXnand , /* DPan */
GXand , /* DPa */
GXequiv , /* DPxn */
GXnoop , /* D */
GXorInverted , /* DPno */
GXcopy , /* P */
GXorReverse , /* PDno */
GXor , /* DPo */
GXset /* 1 */
} ;
boolean xf_set_rop2 ( xfInfo * xfi , int rop2 )
{
if ( ( rop2 < 0x01 ) | | ( rop2 > 0x10 ) )
{
printf ( " Unsupported ROP2: %d \n " , rop2 ) ;
2011-11-19 21:19:16 +04:00
return false ;
2011-08-26 02:07:52 +04:00
}
XSetFunction ( xfi - > display , xfi - > gc , xf_rop2_table [ rop2 ] ) ;
2011-11-19 21:19:16 +04:00
return true ;
2011-08-26 02:07:52 +04:00
}
boolean xf_set_rop3 ( xfInfo * xfi , int rop3 )
{
int function = - 1 ;
switch ( rop3 )
{
case GDI_BLACKNESS :
function = GXclear ;
break ;
2012-02-13 03:12:28 +04:00
case GDI_DPon :
2011-08-26 02:07:52 +04:00
function = GXnor ;
break ;
2012-02-13 03:12:28 +04:00
case GDI_DPna :
2011-08-26 02:07:52 +04:00
function = GXandInverted ;
break ;
2012-02-13 03:12:28 +04:00
case GDI_Pn :
2011-08-26 02:07:52 +04:00
function = GXcopyInverted ;
break ;
case GDI_NOTSRCERASE :
function = GXnor ;
break ;
case GDI_DSna :
function = GXandInverted ;
break ;
case GDI_NOTSRCCOPY :
function = GXcopyInverted ;
break ;
case GDI_SRCERASE :
function = GXandReverse ;
break ;
2012-02-13 03:12:28 +04:00
case GDI_PDna :
2011-08-26 02:07:52 +04:00
function = GXandReverse ;
break ;
case GDI_DSTINVERT :
function = GXinvert ;
break ;
case GDI_PATINVERT :
function = GXxor ;
break ;
2012-02-13 03:12:28 +04:00
case GDI_DPan :
2011-08-26 02:07:52 +04:00
function = GXnand ;
break ;
case GDI_SRCINVERT :
function = GXxor ;
break ;
2012-02-13 03:12:28 +04:00
case GDI_DSan :
2011-08-26 02:07:52 +04:00
function = GXnand ;
break ;
case GDI_SRCAND :
function = GXand ;
break ;
2012-02-13 03:12:28 +04:00
case GDI_DSxn :
2011-08-26 02:07:52 +04:00
function = GXequiv ;
break ;
2012-02-13 03:12:28 +04:00
case GDI_DPa :
2011-08-26 02:07:52 +04:00
function = GXand ;
break ;
case GDI_PDxn :
function = GXequiv ;
break ;
2012-02-13 03:12:28 +04:00
case GDI_D :
2011-08-26 02:07:52 +04:00
function = GXnoop ;
break ;
2012-02-13 03:12:28 +04:00
case GDI_DPno :
2011-08-26 02:07:52 +04:00
function = GXorInverted ;
break ;
case GDI_MERGEPAINT :
function = GXorInverted ;
break ;
case GDI_SRCCOPY :
function = GXcopy ;
break ;
2012-02-13 03:12:28 +04:00
case GDI_SDno :
2011-08-26 02:07:52 +04:00
function = GXorReverse ;
break ;
case GDI_SRCPAINT :
function = GXor ;
break ;
case GDI_PATCOPY :
function = GXcopy ;
break ;
2012-02-13 03:12:28 +04:00
case GDI_PDno :
2011-08-26 02:07:52 +04:00
function = GXorReverse ;
break ;
2012-02-13 03:12:28 +04:00
case GDI_DPo :
2011-08-26 02:07:52 +04:00
function = GXor ;
break ;
case GDI_WHITENESS :
function = GXset ;
break ;
2012-02-13 03:12:28 +04:00
case GDI_PSDPxax :
function = GXand ;
break ;
2011-08-26 02:07:52 +04:00
default :
break ;
}
if ( function < 0 )
{
printf ( " Unsupported ROP3: 0x%08X \n " , rop3 ) ;
XSetFunction ( xfi - > display , xfi - > gc , GXclear ) ;
2011-11-19 21:19:16 +04:00
return false ;
2011-08-26 02:07:52 +04:00
}
XSetFunction ( xfi - > display , xfi - > gc , function ) ;
2011-11-19 21:19:16 +04:00
return true ;
2011-08-26 02:07:52 +04:00
}
2011-10-13 23:51:07 +04:00
Pixmap xf_brush_new ( xfInfo * xfi , int width , int height , int bpp , uint8 * data )
{
Pixmap bitmap ;
uint8 * cdata ;
XImage * image ;
bitmap = XCreatePixmap ( xfi - > display , xfi - > drawable , width , height , xfi - > depth ) ;
2012-02-13 03:12:28 +04:00
if ( data ! = NULL )
2011-10-13 23:51:07 +04:00
{
2012-02-13 03:12:28 +04:00
GC gc ;
2012-01-01 02:00:26 +04:00
2011-10-13 23:51:07 +04:00
cdata = freerdp_image_convert ( data , NULL , width , height , bpp , xfi - > bpp , xfi - > clrconv ) ;
2012-02-13 03:12:28 +04:00
2011-10-13 23:51:07 +04:00
image = XCreateImage ( xfi - > display , xfi - > visual , xfi - > depth ,
ZPixmap , 0 , ( char * ) cdata , width , height , xfi - > scanline_pad , 0 ) ;
2012-01-01 02:00:26 +04:00
gc = XCreateGC ( xfi - > display , xfi - > drawable , 0 , NULL ) ;
XPutImage ( xfi - > display , bitmap , gc , image , 0 , 0 , 0 , 0 , width , height ) ;
2011-10-13 23:51:07 +04:00
XFree ( image ) ;
2012-02-13 03:12:28 +04:00
2011-10-13 23:51:07 +04:00
if ( cdata ! = data )
xfree ( cdata ) ;
2012-01-01 02:00:26 +04:00
XFreeGC ( xfi - > display , gc ) ;
2011-10-13 23:51:07 +04:00
}
return bitmap ;
}
2011-09-12 06:32:22 +04:00
Pixmap xf_mono_bitmap_new ( xfInfo * xfi , int width , int height , uint8 * data )
{
int scanline ;
XImage * image ;
Pixmap bitmap ;
scanline = ( width + 7 ) / 8 ;
2011-09-23 08:06:39 +04:00
bitmap = XCreatePixmap ( xfi - > display , xfi - > drawable , width , height , 1 ) ;
2011-09-12 06:32:22 +04:00
image = XCreateImage ( xfi - > display , xfi - > visual , 1 ,
ZPixmap , 0 , ( char * ) data , width , height , 8 , scanline ) ;
XPutImage ( xfi - > display , bitmap , xfi - > gc_mono , image , 0 , 0 , 0 , 0 , width , height ) ;
XFree ( image ) ;
return bitmap ;
}
2011-09-19 02:29:23 +04:00
Pixmap xf_glyph_new ( xfInfo * xfi , int width , int height , uint8 * data )
{
int scanline ;
Pixmap bitmap ;
XImage * image ;
scanline = ( width + 7 ) / 8 ;
2011-09-23 08:06:39 +04:00
bitmap = XCreatePixmap ( xfi - > display , xfi - > drawable , width , height , 1 ) ;
2011-09-19 02:29:23 +04:00
image = XCreateImage ( xfi - > display , xfi - > visual , 1 ,
ZPixmap , 0 , ( char * ) data , width , height , 8 , scanline ) ;
image - > byte_order = MSBFirst ;
image - > bitmap_bit_order = MSBFirst ;
XInitImage ( image ) ;
XPutImage ( xfi - > display , bitmap , xfi - > gc_mono , image , 0 , 0 , 0 , 0 , width , height ) ;
XFree ( image ) ;
return bitmap ;
}
2011-11-22 04:41:49 +04:00
void xf_gdi_palette_update ( rdpContext * context , PALETTE_UPDATE * palette )
2011-08-26 02:07:52 +04:00
{
2011-11-22 04:41:49 +04:00
xfInfo * xfi = ( ( xfContext * ) context ) - > xfi ;
2011-10-21 20:17:04 +04:00
xfi - > clrconv - > palette - > count = palette - > number ;
xfi - > clrconv - > palette - > entries = palette - > entries ;
2011-08-26 02:07:52 +04:00
}
2011-11-22 04:41:49 +04:00
void xf_gdi_set_bounds ( rdpContext * context , rdpBounds * bounds )
2011-08-26 02:07:52 +04:00
{
2011-08-26 22:48:51 +04:00
XRectangle clip ;
2011-11-22 04:41:49 +04:00
xfInfo * xfi = ( ( xfContext * ) context ) - > xfi ;
2011-08-26 02:07:52 +04:00
2011-08-26 22:48:51 +04:00
if ( bounds ! = NULL )
{
clip . x = bounds - > left ;
clip . y = bounds - > top ;
clip . width = bounds - > right - bounds - > left + 1 ;
clip . height = bounds - > bottom - bounds - > top + 1 ;
XSetClipRectangles ( xfi - > display , xfi - > gc , 0 , 0 , & clip , 1 , YXBanded ) ;
}
else
{
XSetClipMask ( xfi - > display , xfi - > gc , None ) ;
}
2011-08-26 02:07:52 +04:00
}
2011-11-22 03:11:43 +04:00
void xf_gdi_dstblt ( rdpContext * context , DSTBLT_ORDER * dstblt )
2011-08-26 02:07:52 +04:00
{
2011-11-22 03:11:43 +04:00
xfInfo * xfi = ( ( xfContext * ) context ) - > xfi ;
2011-08-26 22:48:51 +04:00
xf_set_rop3 ( xfi , gdi_rop3_code ( dstblt - > bRop ) ) ;
2011-08-26 02:07:52 +04:00
2011-08-26 22:48:51 +04:00
XSetFillStyle ( xfi - > display , xfi - > gc , FillSolid ) ;
XFillRectangle ( xfi - > display , xfi - > drawing , xfi - > gc ,
dstblt - > nLeftRect , dstblt - > nTopRect ,
dstblt - > nWidth , dstblt - > nHeight ) ;
if ( xfi - > drawing = = xfi - > primary )
{
2011-11-19 21:19:16 +04:00
if ( xfi - > remote_app ! = true )
2011-09-23 08:06:39 +04:00
{
XFillRectangle ( xfi - > display , xfi - > drawable , xfi - > gc ,
2011-09-12 06:32:22 +04:00
dstblt - > nLeftRect , dstblt - > nTopRect , dstblt - > nWidth , dstblt - > nHeight ) ;
2011-09-23 08:06:39 +04:00
}
gdi_InvalidateRegion ( xfi - > hdc , dstblt - > nLeftRect , dstblt - > nTopRect , dstblt - > nWidth , dstblt - > nHeight ) ;
2011-08-26 22:48:51 +04:00
}
2011-10-19 13:31:34 +04:00
XSetFunction ( xfi - > display , xfi - > gc , GXcopy ) ;
2011-08-26 02:07:52 +04:00
}
2011-11-22 03:11:43 +04:00
void xf_gdi_patblt ( rdpContext * context , PATBLT_ORDER * patblt )
2011-08-26 02:07:52 +04:00
{
2011-09-12 06:32:22 +04:00
Pixmap pattern ;
2011-10-21 01:28:59 +04:00
rdpBrush * brush ;
2011-09-12 06:32:22 +04:00
uint32 foreColor ;
uint32 backColor ;
2011-11-22 03:11:43 +04:00
xfInfo * xfi = ( ( xfContext * ) context ) - > xfi ;
2011-09-12 06:32:22 +04:00
brush = & patblt - > brush ;
xf_set_rop3 ( xfi , gdi_rop3_code ( patblt - > bRop ) ) ;
2011-12-30 19:00:03 +04:00
foreColor = freerdp_color_convert_rgb ( patblt - > foreColor , xfi - > srcBpp , 32 , xfi - > clrconv ) ;
backColor = freerdp_color_convert_rgb ( patblt - > backColor , xfi - > srcBpp , 32 , xfi - > clrconv ) ;
2011-09-12 06:32:22 +04:00
if ( brush - > style = = GDI_BS_SOLID )
{
XSetFillStyle ( xfi - > display , xfi - > gc , FillSolid ) ;
2011-11-18 01:54:08 +04:00
XSetForeground ( xfi - > display , xfi - > gc , foreColor ) ;
2011-09-12 06:32:22 +04:00
XFillRectangle ( xfi - > display , xfi - > drawing , xfi - > gc ,
patblt - > nLeftRect , patblt - > nTopRect , patblt - > nWidth , patblt - > nHeight ) ;
}
else if ( brush - > style = = GDI_BS_PATTERN )
{
if ( brush - > bpp > 1 )
{
2011-10-13 23:51:07 +04:00
pattern = xf_brush_new ( xfi , 8 , 8 , brush - > bpp , brush - > data ) ;
2011-09-12 06:32:22 +04:00
XSetFillStyle ( xfi - > display , xfi - > gc , FillTiled ) ;
XSetTile ( xfi - > display , xfi - > gc , pattern ) ;
XSetTSOrigin ( xfi - > display , xfi - > gc , brush - > x , brush - > y ) ;
XFillRectangle ( xfi - > display , xfi - > drawing , xfi - > gc ,
patblt - > nLeftRect , patblt - > nTopRect , patblt - > nWidth , patblt - > nHeight ) ;
XSetTile ( xfi - > display , xfi - > gc , xfi - > primary ) ;
2012-01-01 02:00:26 +04:00
XFreePixmap ( xfi - > display , pattern ) ;
2011-09-12 06:32:22 +04:00
}
else
{
pattern = xf_mono_bitmap_new ( xfi , 8 , 8 , brush - > data ) ;
XSetForeground ( xfi - > display , xfi - > gc , backColor ) ;
XSetBackground ( xfi - > display , xfi - > gc , foreColor ) ;
XSetFillStyle ( xfi - > display , xfi - > gc , FillOpaqueStippled ) ;
2011-12-22 03:51:22 +04:00
XSetStipple ( xfi - > display , xfi - > gc , pattern ) ;
2011-09-12 06:32:22 +04:00
XSetTSOrigin ( xfi - > display , xfi - > gc , brush - > x , brush - > y ) ;
XFillRectangle ( xfi - > display , xfi - > drawing , xfi - > gc ,
patblt - > nLeftRect , patblt - > nTopRect , patblt - > nWidth , patblt - > nHeight ) ;
2012-01-01 02:00:26 +04:00
XFreePixmap ( xfi - > display , pattern ) ;
2011-09-12 06:32:22 +04:00
}
}
else
{
printf ( " unimplemented brush style:%d \n " , brush - > style ) ;
}
2011-08-26 02:07:52 +04:00
2011-09-12 06:32:22 +04:00
if ( xfi - > drawing = = xfi - > primary )
{
XSetFunction ( xfi - > display , xfi - > gc , GXcopy ) ;
2011-09-23 08:06:39 +04:00
2011-11-19 21:19:16 +04:00
if ( xfi - > remote_app ! = true )
2011-09-23 08:06:39 +04:00
{
XCopyArea ( xfi - > display , xfi - > primary , xfi - > drawable , xfi - > gc , patblt - > nLeftRect , patblt - > nTopRect ,
2011-09-12 06:32:22 +04:00
patblt - > nWidth , patblt - > nHeight , patblt - > nLeftRect , patblt - > nTopRect ) ;
2011-09-23 08:06:39 +04:00
}
gdi_InvalidateRegion ( xfi - > hdc , patblt - > nLeftRect , patblt - > nTopRect , patblt - > nWidth , patblt - > nHeight ) ;
2011-09-12 06:32:22 +04:00
}
2011-10-21 07:15:18 +04:00
2011-10-19 13:31:34 +04:00
XSetFunction ( xfi - > display , xfi - > gc , GXcopy ) ;
2011-08-26 02:07:52 +04:00
}
2011-11-22 03:11:43 +04:00
void xf_gdi_scrblt ( rdpContext * context , SCRBLT_ORDER * scrblt )
2011-08-26 02:07:52 +04:00
{
2011-11-22 03:11:43 +04:00
xfInfo * xfi = ( ( xfContext * ) context ) - > xfi ;
2011-08-26 22:48:51 +04:00
xf_set_rop3 ( xfi , gdi_rop3_code ( scrblt - > bRop ) ) ;
2011-09-23 08:06:39 +04:00
2011-08-26 22:48:51 +04:00
XCopyArea ( xfi - > display , xfi - > primary , xfi - > drawing , xfi - > gc , scrblt - > nXSrc , scrblt - > nYSrc ,
scrblt - > nWidth , scrblt - > nHeight , scrblt - > nLeftRect , scrblt - > nTopRect ) ;
2011-08-26 02:07:52 +04:00
2011-08-26 22:48:51 +04:00
if ( xfi - > drawing = = xfi - > primary )
{
2011-11-19 21:19:16 +04:00
if ( xfi - > remote_app ! = true )
2011-08-26 22:48:51 +04:00
{
2011-09-23 08:06:39 +04:00
if ( xfi - > unobscured )
{
XCopyArea ( xfi - > display , xfi - > drawable , xfi - > drawable , xfi - > gc ,
scrblt - > nXSrc , scrblt - > nYSrc , scrblt - > nWidth , scrblt - > nHeight ,
scrblt - > nLeftRect , scrblt - > nTopRect ) ;
}
else
{
XSetFunction ( xfi - > display , xfi - > gc , GXcopy ) ;
XCopyArea ( xfi - > display , xfi - > primary , xfi - > drawable , xfi - > gc ,
scrblt - > nLeftRect , scrblt - > nTopRect , scrblt - > nWidth , scrblt - > nHeight ,
scrblt - > nLeftRect , scrblt - > nTopRect ) ;
}
2011-08-26 22:48:51 +04:00
}
2011-09-23 08:06:39 +04:00
2012-01-14 04:07:27 +04:00
gdi_InvalidateRegion ( xfi - > hdc , scrblt - > nLeftRect , scrblt - > nTopRect , scrblt - > nWidth , scrblt - > nHeight ) ;
2011-08-26 22:48:51 +04:00
}
2011-10-21 07:15:18 +04:00
2011-10-19 13:31:34 +04:00
XSetFunction ( xfi - > display , xfi - > gc , GXcopy ) ;
2011-08-26 02:07:52 +04:00
}
2011-11-22 03:11:43 +04:00
void xf_gdi_opaque_rect ( rdpContext * context , OPAQUE_RECT_ORDER * opaque_rect )
2011-08-26 02:07:52 +04:00
{
2011-08-26 22:48:51 +04:00
uint32 color ;
2011-11-22 03:11:43 +04:00
xfInfo * xfi = ( ( xfContext * ) context ) - > xfi ;
2011-08-26 22:48:51 +04:00
2012-03-03 02:49:52 +04:00
color = freerdp_color_convert_var ( opaque_rect - > color , xfi - > srcBpp , xfi - > bpp , xfi - > clrconv ) ;
2011-08-26 02:07:52 +04:00
2011-08-26 22:48:51 +04:00
XSetFunction ( xfi - > display , xfi - > gc , GXcopy ) ;
XSetFillStyle ( xfi - > display , xfi - > gc , FillSolid ) ;
XSetForeground ( xfi - > display , xfi - > gc , color ) ;
2012-01-10 03:45:36 +04:00
2011-08-26 22:48:51 +04:00
XFillRectangle ( xfi - > display , xfi - > drawing , xfi - > gc ,
opaque_rect - > nLeftRect , opaque_rect - > nTopRect ,
opaque_rect - > nWidth , opaque_rect - > nHeight ) ;
if ( xfi - > drawing = = xfi - > primary )
{
2011-11-19 21:19:16 +04:00
if ( xfi - > remote_app ! = true )
2011-09-23 08:06:39 +04:00
{
XFillRectangle ( xfi - > display , xfi - > drawable , xfi - > gc ,
2011-09-12 06:32:22 +04:00
opaque_rect - > nLeftRect , opaque_rect - > nTopRect , opaque_rect - > nWidth , opaque_rect - > nHeight ) ;
2011-09-23 08:06:39 +04:00
}
gdi_InvalidateRegion ( xfi - > hdc , opaque_rect - > nLeftRect , opaque_rect - > nTopRect ,
opaque_rect - > nWidth , opaque_rect - > nHeight ) ;
2011-08-26 22:48:51 +04:00
}
2011-08-26 02:07:52 +04:00
}
2011-11-22 03:11:43 +04:00
void xf_gdi_multi_opaque_rect ( rdpContext * context , MULTI_OPAQUE_RECT_ORDER * multi_opaque_rect )
2011-08-26 02:07:52 +04:00
{
2011-08-26 22:48:51 +04:00
int i ;
uint32 color ;
DELTA_RECT * rectangle ;
2011-11-22 03:11:43 +04:00
xfInfo * xfi = ( ( xfContext * ) context ) - > xfi ;
2011-08-26 22:48:51 +04:00
2012-03-03 02:49:52 +04:00
color = freerdp_color_convert_var ( multi_opaque_rect - > color , xfi - > srcBpp , xfi - > bpp , xfi - > clrconv ) ;
2011-08-26 02:07:52 +04:00
2011-08-26 22:48:51 +04:00
XSetFunction ( xfi - > display , xfi - > gc , GXcopy ) ;
XSetFillStyle ( xfi - > display , xfi - > gc , FillSolid ) ;
XSetForeground ( xfi - > display , xfi - > gc , color ) ;
for ( i = 1 ; i < multi_opaque_rect - > numRectangles + 1 ; i + + )
{
rectangle = & multi_opaque_rect - > rectangles [ i ] ;
XFillRectangle ( xfi - > display , xfi - > drawing , xfi - > gc ,
rectangle - > left , rectangle - > top ,
rectangle - > width , rectangle - > height ) ;
if ( xfi - > drawing = = xfi - > primary )
{
2011-11-19 21:19:16 +04:00
if ( xfi - > remote_app ! = true )
2011-09-23 08:06:39 +04:00
{
XFillRectangle ( xfi - > display , xfi - > drawable , xfi - > gc ,
2011-09-12 06:32:22 +04:00
rectangle - > left , rectangle - > top , rectangle - > width , rectangle - > height ) ;
2011-09-23 08:06:39 +04:00
}
gdi_InvalidateRegion ( xfi - > hdc , rectangle - > left , rectangle - > top , rectangle - > width , rectangle - > height ) ;
2011-08-26 22:48:51 +04:00
}
}
2011-08-26 02:07:52 +04:00
}
2012-02-13 04:41:39 +04:00
void xf_gdi_draw_nine_grid ( rdpContext * context , DRAW_NINE_GRID_ORDER * draw_nine_grid )
{
printf ( " DrawNineGrid \n " ) ;
}
2011-11-22 03:11:43 +04:00
void xf_gdi_line_to ( rdpContext * context , LINE_TO_ORDER * line_to )
2011-08-26 02:07:52 +04:00
{
2011-09-12 06:32:22 +04:00
uint32 color ;
2011-11-22 03:11:43 +04:00
xfInfo * xfi = ( ( xfContext * ) context ) - > xfi ;
2011-08-26 02:07:52 +04:00
2011-09-12 06:32:22 +04:00
xf_set_rop2 ( xfi , line_to - > bRop2 ) ;
2011-12-30 19:00:03 +04:00
color = freerdp_color_convert_rgb ( line_to - > penColor , xfi - > srcBpp , 32 , xfi - > clrconv ) ;
2011-09-12 06:32:22 +04:00
XSetFillStyle ( xfi - > display , xfi - > gc , FillSolid ) ;
XSetForeground ( xfi - > display , xfi - > gc , color ) ;
XDrawLine ( xfi - > display , xfi - > drawing , xfi - > gc ,
line_to - > nXStart , line_to - > nYStart , line_to - > nXEnd , line_to - > nYEnd ) ;
if ( xfi - > drawing = = xfi - > primary )
{
2012-01-14 04:07:27 +04:00
int width , height ;
2011-11-19 21:19:16 +04:00
if ( xfi - > remote_app ! = true )
2011-09-23 08:06:39 +04:00
{
XDrawLine ( xfi - > display , xfi - > drawable , xfi - > gc ,
2011-09-12 06:32:22 +04:00
line_to - > nXStart , line_to - > nYStart , line_to - > nXEnd , line_to - > nYEnd ) ;
2012-01-14 04:07:27 +04:00
}
2011-09-23 08:06:39 +04:00
2012-01-14 04:07:27 +04:00
width = line_to - > nXStart - line_to - > nXEnd ;
height = line_to - > nYStart - line_to - > nYEnd ;
2011-09-23 08:06:39 +04:00
2012-01-14 04:07:27 +04:00
if ( width < 0 )
width * = ( - 1 ) ;
2011-09-23 08:06:39 +04:00
2012-01-14 04:07:27 +04:00
if ( height < 0 )
height * = ( - 1 ) ;
gdi_InvalidateRegion ( xfi - > hdc , line_to - > nXStart , line_to - > nYStart , width , height ) ;
2011-09-23 08:06:39 +04:00
2011-09-12 06:32:22 +04:00
}
2011-10-21 07:15:18 +04:00
2011-10-19 13:31:34 +04:00
XSetFunction ( xfi - > display , xfi - > gc , GXcopy ) ;
2011-08-26 02:07:52 +04:00
}
2011-11-22 03:11:43 +04:00
void xf_gdi_polyline ( rdpContext * context , POLYLINE_ORDER * polyline )
2011-08-26 02:07:52 +04:00
{
2011-09-12 06:32:22 +04:00
int i ;
2011-10-10 05:43:31 +04:00
int x , y ;
2011-10-13 02:10:54 +04:00
int x1 , y1 ;
int x2 , y2 ;
int npoints ;
2011-09-12 06:32:22 +04:00
uint32 color ;
XPoint * points ;
2011-10-10 05:43:31 +04:00
int width , height ;
2011-11-22 03:11:43 +04:00
xfInfo * xfi = ( ( xfContext * ) context ) - > xfi ;
2011-09-12 06:32:22 +04:00
xf_set_rop2 ( xfi , polyline - > bRop2 ) ;
2012-03-03 02:49:52 +04:00
color = freerdp_color_convert_var ( polyline - > penColor , xfi - > srcBpp , xfi - > bpp , xfi - > clrconv ) ;
2011-09-12 06:32:22 +04:00
XSetFillStyle ( xfi - > display , xfi - > gc , FillSolid ) ;
XSetForeground ( xfi - > display , xfi - > gc , color ) ;
2011-10-13 02:10:54 +04:00
npoints = polyline - > numPoints + 1 ;
points = xmalloc ( sizeof ( XPoint ) * npoints ) ;
points [ 0 ] . x = polyline - > xStart ;
points [ 0 ] . y = polyline - > yStart ;
2011-09-12 06:32:22 +04:00
for ( i = 0 ; i < polyline - > numPoints ; i + + )
{
2011-10-13 02:10:54 +04:00
points [ i + 1 ] . x = polyline - > points [ i ] . x ;
points [ i + 1 ] . y = polyline - > points [ i ] . y ;
2011-09-12 06:32:22 +04:00
}
2011-10-13 02:10:54 +04:00
XDrawLines ( xfi - > display , xfi - > drawing , xfi - > gc , points , npoints , CoordModePrevious ) ;
2011-08-26 02:07:52 +04:00
2011-09-12 06:32:22 +04:00
if ( xfi - > drawing = = xfi - > primary )
{
2011-11-19 21:19:16 +04:00
if ( xfi - > remote_app ! = true )
2011-10-13 02:10:54 +04:00
XDrawLines ( xfi - > display , xfi - > drawable , xfi - > gc , points , npoints , CoordModePrevious ) ;
x1 = points [ 0 ] . x ;
y1 = points [ 0 ] . y ;
2011-10-13 00:00:10 +04:00
2011-10-13 02:10:54 +04:00
for ( i = 1 ; i < npoints ; i + + )
2011-09-23 08:06:39 +04:00
{
2011-10-13 02:10:54 +04:00
x2 = points [ i ] . x + x1 ;
y2 = points [ i ] . y + y1 ;
2011-10-10 05:43:31 +04:00
2011-10-13 02:10:54 +04:00
x = ( x2 < x1 ) ? x2 : x1 ;
width = ( x2 > x1 ) ? x2 - x1 : x1 - x2 ;
2011-10-27 21:29:16 +04:00
2011-10-13 02:10:54 +04:00
y = ( y2 < y1 ) ? y2 : y1 ;
height = ( y2 > y1 ) ? y2 - y1 : y1 - y2 ;
x1 = x2 ;
y1 = y2 ;
2011-10-10 05:43:31 +04:00
gdi_InvalidateRegion ( xfi - > hdc , x , y , width , height ) ;
2011-09-23 08:06:39 +04:00
}
2011-09-12 06:32:22 +04:00
}
2011-10-19 13:31:34 +04:00
XSetFunction ( xfi - > display , xfi - > gc , GXcopy ) ;
2011-09-12 06:32:22 +04:00
xfree ( points ) ;
2011-08-26 02:07:52 +04:00
}
2011-11-22 03:11:43 +04:00
void xf_gdi_memblt ( rdpContext * context , MEMBLT_ORDER * memblt )
2011-10-05 05:29:01 +04:00
{
2011-10-13 23:51:07 +04:00
xfBitmap * bitmap ;
2011-11-22 03:11:43 +04:00
xfInfo * xfi = ( ( xfContext * ) context ) - > xfi ;
2011-10-05 05:29:01 +04:00
2011-10-13 23:51:07 +04:00
bitmap = ( xfBitmap * ) memblt - > bitmap ;
2011-10-10 05:23:18 +04:00
xf_set_rop3 ( xfi , gdi_rop3_code ( memblt - > bRop ) ) ;
2011-10-12 04:21:35 +04:00
2011-10-13 23:51:07 +04:00
XCopyArea ( xfi - > display , bitmap - > pixmap , xfi - > drawing , xfi - > gc ,
memblt - > nXSrc , memblt - > nYSrc , memblt - > nWidth , memblt - > nHeight ,
2011-10-05 05:29:01 +04:00
memblt - > nLeftRect , memblt - > nTopRect ) ;
if ( xfi - > drawing = = xfi - > primary )
{
2011-11-19 21:19:16 +04:00
if ( xfi - > remote_app ! = true )
2011-10-10 05:23:18 +04:00
{
2011-10-13 23:51:07 +04:00
XCopyArea ( xfi - > display , bitmap - > pixmap , xfi - > drawable , xfi - > gc ,
memblt - > nXSrc , memblt - > nYSrc , memblt - > nWidth , memblt - > nHeight ,
2011-10-10 05:23:18 +04:00
memblt - > nLeftRect , memblt - > nTopRect ) ;
}
2011-10-05 05:29:01 +04:00
2011-10-10 05:23:18 +04:00
gdi_InvalidateRegion ( xfi - > hdc , memblt - > nLeftRect , memblt - > nTopRect , memblt - > nWidth , memblt - > nHeight ) ;
2011-10-05 05:29:01 +04:00
}
2011-10-21 07:15:18 +04:00
2011-10-19 13:31:34 +04:00
XSetFunction ( xfi - > display , xfi - > gc , GXcopy ) ;
2011-10-05 05:29:01 +04:00
}
2011-11-22 03:11:43 +04:00
void xf_gdi_mem3blt ( rdpContext * context , MEM3BLT_ORDER * mem3blt )
2011-10-05 05:29:01 +04:00
{
2012-02-13 03:12:28 +04:00
rdpBrush * brush ;
xfBitmap * bitmap ;
uint32 foreColor ;
uint32 backColor ;
Pixmap pattern = 0 ;
xfInfo * xfi = ( ( xfContext * ) context ) - > xfi ;
brush = & mem3blt - > brush ;
bitmap = ( xfBitmap * ) mem3blt - > bitmap ;
xf_set_rop3 ( xfi , gdi_rop3_code ( mem3blt - > bRop ) ) ;
foreColor = freerdp_color_convert_rgb ( mem3blt - > foreColor , xfi - > srcBpp , 32 , xfi - > clrconv ) ;
backColor = freerdp_color_convert_rgb ( mem3blt - > backColor , xfi - > srcBpp , 32 , xfi - > clrconv ) ;
if ( brush - > style = = GDI_BS_PATTERN )
{
if ( brush - > bpp > 1 )
{
pattern = xf_brush_new ( xfi , 8 , 8 , brush - > bpp , brush - > data ) ;
XSetFillStyle ( xfi - > display , xfi - > gc , FillTiled ) ;
XSetTile ( xfi - > display , xfi - > gc , pattern ) ;
XSetTSOrigin ( xfi - > display , xfi - > gc , brush - > x , brush - > y ) ;
}
else
{
pattern = xf_mono_bitmap_new ( xfi , 8 , 8 , brush - > data ) ;
XSetForeground ( xfi - > display , xfi - > gc , backColor ) ;
XSetBackground ( xfi - > display , xfi - > gc , foreColor ) ;
XSetFillStyle ( xfi - > display , xfi - > gc , FillOpaqueStippled ) ;
XSetStipple ( xfi - > display , xfi - > gc , pattern ) ;
XSetTSOrigin ( xfi - > display , xfi - > gc , brush - > x , brush - > y ) ;
}
}
else if ( brush - > style = = GDI_BS_SOLID )
{
2012-02-13 04:41:39 +04:00
XSetFillStyle ( xfi - > display , xfi - > gc , FillSolid ) ;
2012-02-13 03:12:28 +04:00
XSetForeground ( xfi - > display , xfi - > gc , backColor ) ;
XSetBackground ( xfi - > display , xfi - > gc , foreColor ) ;
2012-02-13 04:41:39 +04:00
XSetTSOrigin ( xfi - > display , xfi - > gc , brush - > x , brush - > y ) ;
2012-02-13 03:12:28 +04:00
}
else
{
printf ( " Mem3Blt unimplemented brush style:%d \n " , brush - > style ) ;
}
XCopyArea ( xfi - > display , bitmap - > pixmap , xfi - > drawing , xfi - > gc ,
mem3blt - > nXSrc , mem3blt - > nYSrc , mem3blt - > nWidth , mem3blt - > nHeight ,
mem3blt - > nLeftRect , mem3blt - > nTopRect ) ;
if ( xfi - > drawing = = xfi - > primary )
{
if ( xfi - > remote_app ! = true )
{
XCopyArea ( xfi - > display , bitmap - > pixmap , xfi - > drawable , xfi - > gc ,
mem3blt - > nXSrc , mem3blt - > nYSrc , mem3blt - > nWidth , mem3blt - > nHeight ,
mem3blt - > nLeftRect , mem3blt - > nTopRect ) ;
}
gdi_InvalidateRegion ( xfi - > hdc , mem3blt - > nLeftRect , mem3blt - > nTopRect , mem3blt - > nWidth , mem3blt - > nHeight ) ;
}
XSetFillStyle ( xfi - > display , xfi - > gc , FillSolid ) ;
XSetTSOrigin ( xfi - > display , xfi - > gc , 0 , 0 ) ;
if ( pattern ! = 0 )
XFreePixmap ( xfi - > display , pattern ) ;
XSetFunction ( xfi - > display , xfi - > gc , GXcopy ) ;
2012-02-13 02:14:59 +04:00
}
void xf_gdi_polygon_sc ( rdpContext * context , POLYGON_SC_ORDER * polygon_sc )
{
int i , npoints ;
XPoint * points ;
uint32 brush_color ;
xfInfo * xfi = ( ( xfContext * ) context ) - > xfi ;
xf_set_rop2 ( xfi , polygon_sc - > bRop2 ) ;
2012-03-03 02:49:52 +04:00
brush_color = freerdp_color_convert_var ( polygon_sc - > brushColor , xfi - > srcBpp , xfi - > bpp , xfi - > clrconv ) ;
2012-02-13 02:14:59 +04:00
npoints = polygon_sc - > numPoints + 1 ;
points = xmalloc ( sizeof ( XPoint ) * npoints ) ;
points [ 0 ] . x = polygon_sc - > xStart ;
points [ 0 ] . y = polygon_sc - > yStart ;
for ( i = 0 ; i < polygon_sc - > numPoints ; i + + )
{
points [ i + 1 ] . x = polygon_sc - > points [ i ] . x ;
points [ i + 1 ] . y = polygon_sc - > points [ i ] . y ;
}
switch ( polygon_sc - > fillMode )
{
case 1 : /* alternate */
XSetFillRule ( xfi - > display , xfi - > gc , EvenOddRule ) ;
break ;
case 2 : /* winding */
XSetFillRule ( xfi - > display , xfi - > gc , WindingRule ) ;
break ;
default :
printf ( " PolygonSC unknown fillMode: %d \n " , polygon_sc - > fillMode ) ;
break ;
}
XSetFillStyle ( xfi - > display , xfi - > gc , FillSolid ) ;
XSetForeground ( xfi - > display , xfi - > gc , brush_color ) ;
XFillPolygon ( xfi - > display , xfi - > drawing , xfi - > gc ,
points , npoints , Complex , CoordModePrevious ) ;
if ( xfi - > drawing = = xfi - > primary )
{
XFillPolygon ( xfi - > display , xfi - > drawable , xfi - > gc ,
points , npoints , Complex , CoordModePrevious ) ;
}
XSetFunction ( xfi - > display , xfi - > gc , GXcopy ) ;
xfree ( points ) ;
}
void xf_gdi_polygon_cb ( rdpContext * context , POLYGON_CB_ORDER * polygon_cb )
{
int i , npoints ;
XPoint * points ;
Pixmap pattern ;
rdpBrush * brush ;
uint32 foreColor ;
uint32 backColor ;
xfInfo * xfi = ( ( xfContext * ) context ) - > xfi ;
2011-10-05 05:29:01 +04:00
2012-02-13 02:14:59 +04:00
brush = & ( polygon_cb - > brush ) ;
xf_set_rop2 ( xfi , polygon_cb - > bRop2 ) ;
foreColor = freerdp_color_convert_rgb ( polygon_cb - > foreColor , xfi - > srcBpp , 32 , xfi - > clrconv ) ;
backColor = freerdp_color_convert_rgb ( polygon_cb - > backColor , xfi - > srcBpp , 32 , xfi - > clrconv ) ;
npoints = polygon_cb - > numPoints + 1 ;
points = xmalloc ( sizeof ( XPoint ) * npoints ) ;
points [ 0 ] . x = polygon_cb - > xStart ;
points [ 0 ] . y = polygon_cb - > yStart ;
for ( i = 0 ; i < polygon_cb - > numPoints ; i + + )
{
points [ i + 1 ] . x = polygon_cb - > points [ i ] . x ;
points [ i + 1 ] . y = polygon_cb - > points [ i ] . y ;
}
switch ( polygon_cb - > fillMode )
{
case 1 : /* alternate */
XSetFillRule ( xfi - > display , xfi - > gc , EvenOddRule ) ;
break ;
case 2 : /* winding */
XSetFillRule ( xfi - > display , xfi - > gc , WindingRule ) ;
break ;
default :
printf ( " PolygonCB unknown fillMode: %d \n " , polygon_cb - > fillMode ) ;
break ;
}
if ( brush - > style = = GDI_BS_PATTERN )
{
if ( brush - > bpp > 1 )
{
pattern = xf_brush_new ( xfi , 8 , 8 , brush - > bpp , brush - > data ) ;
XSetFillStyle ( xfi - > display , xfi - > gc , FillTiled ) ;
XSetTile ( xfi - > display , xfi - > gc , pattern ) ;
XSetTSOrigin ( xfi - > display , xfi - > gc , brush - > x , brush - > y ) ;
XFillPolygon ( xfi - > display , xfi - > drawing , xfi - > gc ,
points , npoints , Complex , CoordModePrevious ) ;
if ( xfi - > drawing = = xfi - > primary )
{
XFillPolygon ( xfi - > display , xfi - > drawable , xfi - > gc ,
points , npoints , Complex , CoordModePrevious ) ;
}
XSetFillStyle ( xfi - > display , xfi - > gc , FillSolid ) ;
XSetTSOrigin ( xfi - > display , xfi - > gc , 0 , 0 ) ;
XFreePixmap ( xfi - > display , pattern ) ;
}
else
{
pattern = xf_mono_bitmap_new ( xfi , 8 , 8 , brush - > data ) ;
XSetForeground ( xfi - > display , xfi - > gc , backColor ) ;
XSetBackground ( xfi - > display , xfi - > gc , foreColor ) ;
if ( polygon_cb - > backMode = = BACKMODE_TRANSPARENT )
XSetFillStyle ( xfi - > display , xfi - > gc , FillStippled ) ;
else if ( polygon_cb - > backMode = = BACKMODE_OPAQUE )
XSetFillStyle ( xfi - > display , xfi - > gc , FillOpaqueStippled ) ;
XSetStipple ( xfi - > display , xfi - > gc , pattern ) ;
XSetTSOrigin ( xfi - > display , xfi - > gc , brush - > x , brush - > y ) ;
XFillPolygon ( xfi - > display , xfi - > drawing , xfi - > gc ,
points , npoints , Complex , CoordModePrevious ) ;
if ( xfi - > drawing = = xfi - > primary )
{
XFillPolygon ( xfi - > display , xfi - > drawable , xfi - > gc ,
points , npoints , Complex , CoordModePrevious ) ;
}
XSetFillStyle ( xfi - > display , xfi - > gc , FillSolid ) ;
XSetTSOrigin ( xfi - > display , xfi - > gc , 0 , 0 ) ;
XFreePixmap ( xfi - > display , pattern ) ;
}
}
else
{
2012-02-13 03:12:28 +04:00
printf ( " PolygonCB unimplemented brush style:%d \n " , brush - > style ) ;
2012-02-13 02:14:59 +04:00
}
XSetFunction ( xfi - > display , xfi - > gc , GXcopy ) ;
xfree ( points ) ;
}
void xf_gdi_ellipse_sc ( rdpContext * context , ELLIPSE_SC_ORDER * ellipse_sc )
{
printf ( " EllipseSC \n " ) ;
}
void xf_gdi_ellipse_cb ( rdpContext * context , ELLIPSE_CB_ORDER * ellipse_cb )
{
printf ( " EllipseCB \n " ) ;
2011-10-05 05:29:01 +04:00
}
2011-11-25 20:30:15 +04:00
void xf_gdi_surface_frame_marker ( rdpContext * context , SURFACE_FRAME_MARKER * surface_frame_marker )
2011-11-25 14:48:51 +04:00
{
}
2011-11-22 04:41:49 +04:00
void xf_gdi_surface_bits ( rdpContext * context , SURFACE_BITS_COMMAND * surface_bits_command )
2011-08-26 02:07:52 +04:00
{
2011-09-12 05:22:03 +04:00
int i , tx , ty ;
2011-09-19 06:34:19 +04:00
XImage * image ;
2011-09-12 05:22:03 +04:00
RFX_MESSAGE * message ;
2011-11-22 04:41:49 +04:00
xfInfo * xfi = ( ( xfContext * ) context ) - > xfi ;
RFX_CONTEXT * rfx_context = ( RFX_CONTEXT * ) xfi - > rfx_context ;
NSC_CONTEXT * nsc_context = ( NSC_CONTEXT * ) xfi - > nsc_context ;
2011-09-12 05:22:03 +04:00
if ( surface_bits_command - > codecID = = CODEC_ID_REMOTEFX )
{
2011-11-22 04:41:49 +04:00
message = rfx_process_message ( rfx_context ,
surface_bits_command - > bitmapData , surface_bits_command - > bitmapDataLength ) ;
2011-09-12 05:22:03 +04:00
XSetFunction ( xfi - > display , xfi - > gc , GXcopy ) ;
XSetFillStyle ( xfi - > display , xfi - > gc , FillSolid ) ;
XSetClipRectangles ( xfi - > display , xfi - > gc ,
surface_bits_command - > destLeft , surface_bits_command - > destTop ,
( XRectangle * ) message - > rects , message - > num_rects , YXBanded ) ;
2011-08-26 02:07:52 +04:00
2011-09-12 05:22:03 +04:00
/* Draw the tiles to primary surface, each is 64x64. */
for ( i = 0 ; i < message - > num_tiles ; i + + )
{
image = XCreateImage ( xfi - > display , xfi - > visual , 24 , ZPixmap , 0 ,
( char * ) message - > tiles [ i ] - > data , 64 , 64 , 32 , 0 ) ;
tx = message - > tiles [ i ] - > x + surface_bits_command - > destLeft ;
ty = message - > tiles [ i ] - > y + surface_bits_command - > destTop ;
XPutImage ( xfi - > display , xfi - > primary , xfi - > gc , image , 0 , 0 , tx , ty , 64 , 64 ) ;
XFree ( image ) ;
}
/* Copy the updated region from backstore to the window. */
for ( i = 0 ; i < message - > num_rects ; i + + )
{
tx = message - > rects [ i ] . x + surface_bits_command - > destLeft ;
ty = message - > rects [ i ] . y + surface_bits_command - > destTop ;
2011-11-19 21:19:16 +04:00
if ( xfi - > remote_app ! = true )
2011-09-23 08:06:39 +04:00
{
XCopyArea ( xfi - > display , xfi - > primary , xfi - > drawable , xfi - > gc ,
tx , ty , message - > rects [ i ] . width , message - > rects [ i ] . height , tx , ty ) ;
}
gdi_InvalidateRegion ( xfi - > hdc , tx , ty , message - > rects [ i ] . width , message - > rects [ i ] . height ) ;
2011-09-12 05:22:03 +04:00
}
XSetClipMask ( xfi - > display , xfi - > gc , None ) ;
2011-11-22 04:41:49 +04:00
rfx_message_free ( rfx_context , message ) ;
2011-09-12 05:22:03 +04:00
}
2011-10-02 23:16:22 +04:00
else if ( surface_bits_command - > codecID = = CODEC_ID_NSCODEC )
{
2012-03-05 13:32:14 +04:00
nsc_process_message ( nsc_context , surface_bits_command - > bpp , surface_bits_command - > width , surface_bits_command - > height ,
surface_bits_command - > bitmapData , surface_bits_command - > bitmapDataLength ) ;
2011-10-02 23:16:22 +04:00
XSetFunction ( xfi - > display , xfi - > gc , GXcopy ) ;
XSetFillStyle ( xfi - > display , xfi - > gc , FillSolid ) ;
xfi - > bmp_codec_nsc = ( uint8 * ) xrealloc ( xfi - > bmp_codec_nsc ,
surface_bits_command - > width * surface_bits_command - > height * 4 ) ;
2011-11-22 04:41:49 +04:00
freerdp_image_flip ( nsc_context - > bmpdata , xfi - > bmp_codec_nsc ,
2011-10-02 23:16:22 +04:00
surface_bits_command - > width , surface_bits_command - > height , 32 ) ;
image = XCreateImage ( xfi - > display , xfi - > visual , 24 , ZPixmap , 0 ,
( char * ) xfi - > bmp_codec_nsc , surface_bits_command - > width , surface_bits_command - > height , 32 , 0 ) ;
XPutImage ( xfi - > display , xfi - > primary , xfi - > gc , image , 0 , 0 ,
surface_bits_command - > destLeft , surface_bits_command - > destTop ,
surface_bits_command - > width , surface_bits_command - > height ) ;
2011-11-19 21:19:16 +04:00
if ( xfi - > remote_app ! = true )
2011-10-02 23:16:22 +04:00
{
XCopyArea ( xfi - > display , xfi - > primary , xfi - > window - > handle , xfi - > gc ,
surface_bits_command - > destLeft , surface_bits_command - > destTop ,
surface_bits_command - > width , surface_bits_command - > height ,
surface_bits_command - > destLeft , surface_bits_command - > destTop ) ;
}
gdi_InvalidateRegion ( xfi - > hdc , surface_bits_command - > destLeft , surface_bits_command - > destTop ,
surface_bits_command - > width , surface_bits_command - > height ) ;
XSetClipMask ( xfi - > display , xfi - > gc , None ) ;
}
2011-09-12 05:22:03 +04:00
else if ( surface_bits_command - > codecID = = CODEC_ID_NONE )
{
2011-09-14 22:47:04 +04:00
XSetFunction ( xfi - > display , xfi - > gc , GXcopy ) ;
XSetFillStyle ( xfi - > display , xfi - > gc , FillSolid ) ;
2012-03-05 01:59:15 +04:00
/* Validate that the data received is large enough */
if ( surface_bits_command - > width * surface_bits_command - > height * surface_bits_command - > bpp / 8 < = surface_bits_command - > bitmapDataLength )
{
xfi - > bmp_codec_none = ( uint8 * ) xrealloc ( xfi - > bmp_codec_none ,
surface_bits_command - > width * surface_bits_command - > height * 4 ) ;
2011-09-14 22:47:04 +04:00
2012-03-05 01:59:15 +04:00
freerdp_image_flip ( surface_bits_command - > bitmapData , xfi - > bmp_codec_none ,
surface_bits_command - > width , surface_bits_command - > height , 32 ) ;
2011-09-14 22:47:04 +04:00
2012-03-05 01:59:15 +04:00
image = XCreateImage ( xfi - > display , xfi - > visual , 24 , ZPixmap , 0 ,
( char * ) xfi - > bmp_codec_none , surface_bits_command - > width , surface_bits_command - > height , 32 , 0 ) ;
2011-09-12 05:22:03 +04:00
2012-03-05 01:59:15 +04:00
XPutImage ( xfi - > display , xfi - > primary , xfi - > gc , image , 0 , 0 ,
surface_bits_command - > destLeft , surface_bits_command - > destTop ,
surface_bits_command - > width , surface_bits_command - > height ) ;
2011-09-14 22:47:04 +04:00
2012-03-05 01:59:15 +04:00
if ( xfi - > remote_app ! = true )
{
XCopyArea ( xfi - > display , xfi - > primary , xfi - > window - > handle , xfi - > gc ,
surface_bits_command - > destLeft , surface_bits_command - > destTop ,
surface_bits_command - > width , surface_bits_command - > height ,
surface_bits_command - > destLeft , surface_bits_command - > destTop ) ;
}
2011-09-23 08:06:39 +04:00
2012-03-05 01:59:15 +04:00
gdi_InvalidateRegion ( xfi - > hdc , surface_bits_command - > destLeft , surface_bits_command - > destTop ,
surface_bits_command - > width , surface_bits_command - > height ) ;
2011-09-14 22:47:04 +04:00
2012-03-05 01:59:15 +04:00
XSetClipMask ( xfi - > display , xfi - > gc , None ) ;
} else {
printf ( " Invalid bitmap size - data is %d bytes for %dx%d \n update " , surface_bits_command - > bitmapDataLength , surface_bits_command - > width , surface_bits_command - > height ) ;
}
2011-09-12 05:22:03 +04:00
}
else
{
printf ( " Unsupported codecID %d \n " , surface_bits_command - > codecID ) ;
}
2011-08-26 02:07:52 +04:00
}
void xf_gdi_register_update_callbacks ( rdpUpdate * update )
{
2011-11-22 03:11:43 +04:00
rdpPrimaryUpdate * primary = update - > primary ;
2011-08-26 02:07:52 +04:00
update - > Palette = xf_gdi_palette_update ;
update - > SetBounds = xf_gdi_set_bounds ;
2011-11-22 03:11:43 +04:00
primary - > DstBlt = xf_gdi_dstblt ;
primary - > PatBlt = xf_gdi_patblt ;
primary - > ScrBlt = xf_gdi_scrblt ;
primary - > OpaqueRect = xf_gdi_opaque_rect ;
primary - > DrawNineGrid = NULL ;
primary - > MultiDstBlt = NULL ;
primary - > MultiPatBlt = NULL ;
primary - > MultiScrBlt = NULL ;
primary - > MultiOpaqueRect = xf_gdi_multi_opaque_rect ;
primary - > MultiDrawNineGrid = NULL ;
primary - > LineTo = xf_gdi_line_to ;
primary - > Polyline = xf_gdi_polyline ;
primary - > MemBlt = xf_gdi_memblt ;
primary - > Mem3Blt = xf_gdi_mem3blt ;
primary - > SaveBitmap = NULL ;
primary - > GlyphIndex = NULL ;
primary - > FastIndex = NULL ;
primary - > FastGlyph = NULL ;
2012-02-13 02:14:59 +04:00
primary - > PolygonSC = xf_gdi_polygon_sc ;
primary - > PolygonCB = xf_gdi_polygon_cb ;
primary - > EllipseSC = xf_gdi_ellipse_sc ;
primary - > EllipseCB = xf_gdi_ellipse_cb ;
2011-08-26 02:07:52 +04:00
update - > SurfaceBits = xf_gdi_surface_bits ;
2011-11-25 14:48:51 +04:00
update - > SurfaceFrameMarker = xf_gdi_surface_frame_marker ;
2011-08-26 02:07:52 +04:00
}