wf_gdi.h
wf_event.c
wf_event.h
+ wf_graphics.c
+ wf_graphics.h
wfreerdp.c
wfreerdp.h)
#define DEBUG_KBD(fmt, ...) DEBUG_NULL(fmt, ## __VA_ARGS__)
#endif
-#endif
+#endif /* __WF_EVENT_H */
#include <freerdp/gdi/gdi.h>
#include <freerdp/codec/color.h>
#include <freerdp/codec/bitmap.h>
+#include <freerdp/utils/memory.h>
#include "wfreerdp.h"
+#include "wf_graphics.h"
const uint8 wf_rop2_table[] =
{
return True;
}
-HBITMAP wf_create_dib(wfInfo* wfi, int width, int height, int bpp, uint8* data)
-{
- HDC hdc;
- int negHeight;
- HBITMAP bitmap;
- BITMAPINFO bmi;
- uint8* cdata = NULL;
-
- /**
- * See: http://msdn.microsoft.com/en-us/library/dd183376
- * if biHeight is positive, the bitmap is bottom-up
- * if biHeight is negative, the bitmap is top-down
- * Since we get top-down bitmaps, let's keep it that way
- */
-
- negHeight = (height < 0) ? height : height * (-1);
-
- hdc = GetDC(NULL);
- bmi.bmiHeader.biSize = sizeof(BITMAPINFO);
- bmi.bmiHeader.biWidth = width;
- bmi.bmiHeader.biHeight = negHeight;
- bmi.bmiHeader.biPlanes = 1;
- bmi.bmiHeader.biBitCount = 24;
- bmi.bmiHeader.biCompression = BI_RGB;
- bitmap = CreateDIBSection(hdc, &bmi, DIB_RGB_COLORS, (void**) &cdata, NULL, 0);
-
- if (data != NULL)
- freerdp_image_convert(data, cdata, width, height, bpp, 24, wfi->clrconv);
-
- ReleaseDC(NULL, hdc);
- GdiFlush();
-
- return bitmap;
-}
-
-wfBitmap* wf_image_new(wfInfo* wfi, int width, int height, int bpp, uint8* data)
-{
- HDC hdc;
- wfBitmap* image;
-
- hdc = GetDC(NULL);
- image = (wfBitmap*) malloc(sizeof(wfBitmap));
- image->hdc = CreateCompatibleDC(hdc);
-
- if (data == NULL)
- image->bitmap = CreateCompatibleBitmap(hdc, width, height);
- else
- image->bitmap = wf_create_dib(wfi, width, height, bpp, data);
-
- image->org_bitmap = (HBITMAP) SelectObject(image->hdc, image->bitmap);
- ReleaseDC(NULL, hdc);
-
- return image;
-}
-
-void wf_image_free(wfBitmap* image)
-{
- if (image != 0)
- {
- SelectObject(image->hdc, image->org_bitmap);
- DeleteObject(image->bitmap);
- DeleteDC(image->hdc);
- free(image);
- }
-}
-
wfBitmap* wf_glyph_new(wfInfo* wfi, GLYPH_DATA* glyph)
{
wfBitmap* glyph_bmp;
SetForegroundWindow(wfi->hwnd);
}
+#if 0
void wf_gdi_bitmap_update(rdpUpdate* update, BITMAP_UPDATE* bitmap)
{
int i;
wf_image_free(wf_bmp);
}
}
+#endif
void wf_gdi_palette_update(rdpUpdate* update, PALETTE_UPDATE* palette)
{
}
-void wf_gdi_bitmap_decompress(rdpUpdate* update, rdpBitmap* bitmap_data)
-{
- uint16 dstSize;
-
- dstSize = bitmap_data->width * bitmap_data->height * (bitmap_data->bpp / 8);
-
- if (bitmap_data->dstData == NULL)
- bitmap_data->dstData = (uint8*) xmalloc(dstSize);
- else
- bitmap_data->dstData = (uint8*) xrealloc(bitmap_data->dstData, dstSize);
-
- if (bitmap_data->compressed)
- {
- bitmap_decompress(bitmap_data->srcData, bitmap_data->dstData,
- bitmap_data->width, bitmap_data->height, bitmap_data->length,
- bitmap_data->bpp, bitmap_data->bpp);
- }
- else
- {
- freerdp_image_flip(bitmap_data->srcData, bitmap_data->dstData,
- bitmap_data->width, bitmap_data->height, bitmap_data->bpp);
- }
-
- bitmap_data->compressed = False;
-}
-
void wf_gdi_register_update_callbacks(rdpUpdate* update)
{
- update->BitmapUpdate = wf_gdi_bitmap_update;
update->Palette = wf_gdi_palette_update;
update->SetBounds = wf_gdi_set_bounds;
update->DstBlt = wf_gdi_dstblt;
update->CacheBrush = wf_gdi_cache_brush;
update->SurfaceBits = wf_gdi_surface_bits;
-
- update->BitmapDecompress = wf_gdi_bitmap_decompress;
}
#include "wfreerdp.h"
-HBITMAP wf_create_dib(wfInfo* wfi, int width, int height, int bpp, uint8* data);
+void wf_invalidate_region(wfInfo* wfi, int x, int y, int width, int height);
wfBitmap* wf_image_new(wfInfo* wfi, int width, int height, int bpp, uint8* data);
void wf_image_free(wfBitmap* image);
void wf_toggle_fullscreen(wfInfo* wfi);
--- /dev/null
+/**
+ * FreeRDP: A Remote Desktop Protocol Client
+ * Windows Graphical Objects
+ *
+ * Copyright 2010-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.
+ */
+
+#include <freerdp/utils/memory.h>
+#include <freerdp/codec/bitmap.h>
+
+#include "wf_gdi.h"
+#include "wf_graphics.h"
+
+HBITMAP wf_create_dib(wfInfo* wfi, int width, int height, int bpp, uint8* data)
+{
+ HDC hdc;
+ int negHeight;
+ HBITMAP bitmap;
+ BITMAPINFO bmi;
+ uint8* cdata = NULL;
+
+ /**
+ * See: http://msdn.microsoft.com/en-us/library/dd183376
+ * if biHeight is positive, the bitmap is bottom-up
+ * if biHeight is negative, the bitmap is top-down
+ * Since we get top-down bitmaps, let's keep it that way
+ */
+
+ negHeight = (height < 0) ? height : height * (-1);
+
+ hdc = GetDC(NULL);
+ bmi.bmiHeader.biSize = sizeof(BITMAPINFO);
+ bmi.bmiHeader.biWidth = width;
+ bmi.bmiHeader.biHeight = negHeight;
+ bmi.bmiHeader.biPlanes = 1;
+ bmi.bmiHeader.biBitCount = 24;
+ bmi.bmiHeader.biCompression = BI_RGB;
+ bitmap = CreateDIBSection(hdc, &bmi, DIB_RGB_COLORS, (void**) &cdata, NULL, 0);
+
+ if (data != NULL)
+ freerdp_image_convert(data, cdata, width, height, bpp, 24, wfi->clrconv);
+
+ ReleaseDC(NULL, hdc);
+ GdiFlush();
+
+ return bitmap;
+}
+
+wfBitmap* wf_image_new(wfInfo* wfi, int width, int height, int bpp, uint8* data)
+{
+ HDC hdc;
+ wfBitmap* image;
+
+ hdc = GetDC(NULL);
+ image = (wfBitmap*) malloc(sizeof(wfBitmap));
+ image->hdc = CreateCompatibleDC(hdc);
+
+ if (data == NULL)
+ image->bitmap = CreateCompatibleBitmap(hdc, width, height);
+ else
+ image->bitmap = wf_create_dib(wfi, width, height, bpp, data);
+
+ image->org_bitmap = (HBITMAP) SelectObject(image->hdc, image->bitmap);
+ ReleaseDC(NULL, hdc);
+
+ return image;
+}
+
+void wf_image_free(wfBitmap* image)
+{
+ if (image != 0)
+ {
+ SelectObject(image->hdc, image->org_bitmap);
+ DeleteObject(image->bitmap);
+ DeleteDC(image->hdc);
+ free(image);
+ }
+}
+
+/* Bitmap Class */
+
+void wf_Bitmap_New(rdpContext* context, rdpBitmap* bitmap)
+{
+ HDC hdc;
+ wfBitmap* wf_bitmap = (wfBitmap*) bitmap;
+ wfInfo* wfi = ((wfContext*) context)->wfi;
+
+ if (bitmap->ephemeral)
+ return;
+
+ hdc = GetDC(NULL);
+ wf_bitmap = (wfBitmap*) bitmap;
+ wf_bitmap->hdc = CreateCompatibleDC(hdc);
+
+ if (bitmap->data == NULL)
+ wf_bitmap->bitmap = CreateCompatibleBitmap(hdc, bitmap->width, bitmap->height);
+ else
+ wf_bitmap->bitmap = wf_create_dib(wfi, bitmap->width, bitmap->height, bitmap->bpp, bitmap->data);
+
+ wf_bitmap->org_bitmap = (HBITMAP) SelectObject(wf_bitmap->hdc, wf_bitmap->bitmap);
+ ReleaseDC(NULL, hdc);
+}
+
+void wf_Bitmap_Free(rdpContext* context, rdpBitmap* bitmap)
+{
+ wfBitmap* wf_bitmap = (wfBitmap*) bitmap;
+
+ if (wf_bitmap != 0)
+ {
+ SelectObject(wf_bitmap->hdc, wf_bitmap->org_bitmap);
+ DeleteObject(wf_bitmap->bitmap);
+ DeleteDC(wf_bitmap->hdc);
+ }
+}
+
+void wf_Bitmap_Paint(rdpContext* context, rdpBitmap* bitmap)
+{
+ int width, height;
+ wfBitmap* wf_bitmap = (wfBitmap*) bitmap;
+ wfInfo* wfi = ((wfContext*) context)->wfi;
+
+ width = bitmap->right - bitmap->left + 1;
+ height = bitmap->bottom - bitmap->top + 1;
+
+ BitBlt(wfi->primary->hdc, bitmap->left, bitmap->top,
+ width, height, wf_bitmap->hdc, 0, 0, GDI_SRCCOPY);
+
+ wf_invalidate_region(wfi, bitmap->left, bitmap->top, width, height);
+}
+
+void wf_Bitmap_Decompress(rdpContext* context, rdpBitmap* bitmap,
+ uint8* data, int width, int height, int bpp, int length, boolean compressed)
+{
+ uint16 size;
+
+ size = width * height * (bpp / 8);
+
+ if (bitmap->data == NULL)
+ bitmap->data = (uint8*) xmalloc(size);
+ else
+ bitmap->data = (uint8*) xrealloc(bitmap->data, size);
+
+ if (bitmap->compressed)
+ {
+ boolean status;
+
+ status = bitmap_decompress(data, bitmap->data, width, height, length, bpp, bpp);
+
+ if (status != True)
+ {
+ printf("Bitmap Decompression Failed\n");
+ }
+ }
+ else
+ {
+ freerdp_image_flip(data, bitmap->data, width, height, bpp);
+ }
+
+ bitmap->compressed = False;
+ bitmap->length = size;
+ bitmap->bpp = bpp;
+}
+
+void wf_Bitmap_SetSurface(rdpContext* context, rdpBitmap* bitmap, boolean primary)
+{
+ wfInfo* wfi = ((wfContext*) context)->wfi;
+
+ if (primary)
+ wfi->drawing = wfi->primary;
+ else
+ wfi->drawing = (wfBitmap*) bitmap;
+}
+
+/* Pointer Class */
+
+void wf_Pointer_New(rdpContext* context, rdpPointer* pointer)
+{
+
+}
+
+void wf_Pointer_Free(rdpContext* context, rdpPointer* pointer)
+{
+
+}
+
+void wf_Pointer_Set(rdpContext* context, rdpPointer* pointer)
+{
+
+}
+
+/* Graphics Module */
+
+void wf_register_graphics(rdpGraphics* graphics)
+{
+ rdpBitmap bitmap;
+ rdpPointer pointer;
+
+ memset(&bitmap, 0, sizeof(rdpBitmap));
+ bitmap.size = sizeof(wfBitmap);
+ bitmap.New = wf_Bitmap_New;
+ bitmap.Free = wf_Bitmap_Free;
+ bitmap.Paint = wf_Bitmap_Paint;
+ bitmap.Decompress = wf_Bitmap_Decompress;
+ bitmap.SetSurface = wf_Bitmap_SetSurface;
+
+ memset(&pointer, 0, sizeof(rdpPointer));
+ pointer.size = sizeof(wfPointer);
+ pointer.New = wf_Pointer_New;
+ pointer.Free = wf_Pointer_Free;
+ pointer.Set = wf_Pointer_Set;
+
+ graphics_register_bitmap(graphics, &bitmap);
+ graphics_register_pointer(graphics, &pointer);
+}
--- /dev/null
+/**
+ * FreeRDP: A Remote Desktop Protocol Client
+ * Windows Graphical Objects
+ *
+ * Copyright 2010-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.
+ */
+
+#ifndef __WF_GRAPHICS_H
+#define __WF_GRAPHICS_H
+
+#include "wfreerdp.h"
+
+HBITMAP wf_create_dib(wfInfo* wfi, int width, int height, int bpp, uint8* data);
+wfBitmap* wf_image_new(wfInfo* wfi, int width, int height, int bpp, uint8* data);
+void wf_image_free(wfBitmap* image);
+
+void wf_register_graphics(rdpGraphics* graphics);
+
+#endif /* WF_GRAPHICS */
#include <freerdp/freerdp.h>
#include <freerdp/utils/args.h>
#include <freerdp/utils/event.h>
+#include <freerdp/utils/memory.h>
#include <freerdp/channels/channels.h>
#include "wf_gdi.h"
+#include "wf_graphics.h"
#include "wfreerdp.h"
volatile int g_thread_count = 0;
LPCTSTR g_wnd_class_name = L"wfreerdp";
-void wf_context_size(freerdp* instance, uint32* size)
+void wf_context_new(freerdp* instance, rdpContext* context)
{
- *size = sizeof(wfContext);
-}
-
-void wf_context_new(freerdp* instance, wfContext* context)
-{
- rdpContext* _context = (rdpContext*) &context->_p;
-
context->channels = freerdp_channels_new();
}
-void wf_context_free(freerdp* instance, wfContext* context)
+void wf_context_free(freerdp* instance, rdpContext* context)
{
- rdpContext* _context = (rdpContext*) &context->_p;
+
}
int wf_create_console(void)
}
-void wf_bitmap_size(rdpUpdate* update, uint32* size)
-{
- *size = sizeof(wfBitmap);
-}
-
-void wf_bitmap_new(rdpUpdate* update, wfBitmap* bitmap)
-{
- HDC hdc;
- uint8* data;
- rdpBitmap* _bitmap;
- wfInfo* wfi = ((wfContext*) update->context)->wfi;
-
- hdc = GetDC(NULL);
- bitmap->hdc = CreateCompatibleDC(hdc);
-
- _bitmap = &(bitmap->_p);
- data = _bitmap->dstData;
-
- if (data == NULL)
- bitmap->bitmap = CreateCompatibleBitmap(hdc, _bitmap->width, _bitmap->height);
- else
- bitmap->bitmap = wf_create_dib(wfi, _bitmap->width, _bitmap->height, _bitmap->bpp, data);
-
- bitmap->org_bitmap = (HBITMAP) SelectObject(bitmap->hdc, bitmap->bitmap);
- ReleaseDC(NULL, hdc);
-}
-
-void wf_offscreen_bitmap_new(rdpUpdate* update, wfBitmap* bitmap)
-{
- HDC hdc;
- rdpBitmap* _bitmap;
- wfInfo* wfi = ((wfContext*) update->context)->wfi;
-
- hdc = GetDC(NULL);
- bitmap->hdc = CreateCompatibleDC(hdc);
-
- _bitmap = &(bitmap->_p);
- bitmap->bitmap = CreateCompatibleBitmap(hdc, _bitmap->width, _bitmap->height);
-
- bitmap->org_bitmap = (HBITMAP) SelectObject(bitmap->hdc, bitmap->bitmap);
- ReleaseDC(NULL, hdc);
-}
-
-void wf_set_surface(rdpUpdate* update, wfBitmap* bitmap, boolean primary)
-{
- wfInfo* wfi = ((wfContext*) update->context)->wfi;
-
- if (primary)
- wfi->drawing = wfi->primary;
- else
- wfi->drawing = bitmap;
-}
-
-void wf_bitmap_free(rdpUpdate* update, wfBitmap* bitmap)
-{
- if (bitmap != 0)
- {
- SelectObject(bitmap->hdc, bitmap->org_bitmap);
- DeleteObject(bitmap->bitmap);
- DeleteDC(bitmap->hdc);
- }
-}
-
boolean wf_pre_connect(freerdp* instance)
{
int i1;
}
settings->kbd_layout = (int) GetKeyboardLayout(0) & 0x0000FFFF;
- freerdp_channels_pre_connect(context->channels, instance);
+ freerdp_channels_pre_connect(instance->context->channels, instance);
return True;
}
width = settings->width;
height = settings->height;
+ wf_register_graphics(instance->context->graphics);
+
if (wfi->sw_gdi)
{
gdi_init(instance, CLRCONV_ALPHA | CLRBUF_32BPP, NULL);
instance->update->EndPaint = wf_hw_end_paint;
}
+ pointer_cache_register_callbacks(instance->update);
+
if (wfi->sw_gdi != True)
{
+ brush_cache_register_callbacks(instance->update);
bitmap_cache_register_callbacks(instance->update);
- cache->bitmap->BitmapSize = (cbBitmapSize) wf_bitmap_size;
- cache->bitmap->BitmapNew = (cbBitmapNew) wf_bitmap_new;
- cache->bitmap->BitmapFree = (cbBitmapFree) wf_bitmap_free;
-
offscreen_cache_register_callbacks(instance->update);
- cache->offscreen->BitmapSize = (cbBitmapSize) wf_bitmap_size;
- cache->offscreen->BitmapNew = (cbBitmapNew) wf_offscreen_bitmap_new;
- cache->offscreen->BitmapFree = (cbBitmapFree) wf_bitmap_free;
- cache->offscreen->SetSurface = (cbSetSurface) wf_set_surface;
}
- freerdp_channels_post_connect(context->channels, instance);
+ freerdp_channels_post_connect(instance->context->channels, instance);
return True;
}
return 1;
}
-int wf_process_ui_args(rdpSettings* settings, const char* opt, const char* val, void* user_data)
+int wf_process_client_args(rdpSettings* settings, const char* opt, const char* val, void* user_data)
{
return 0;
}
if (freerdp_connect(instance) != True)
return 0;
- channels = ((wfContext*) instance->context)->channels;
+ channels = instance->context->channels;
/* program main loop */
while (1)
thread_data* data;
WSADATA wsa_data;
WNDCLASSEX wnd_cls;
- wfContext* context;
- rdpChannels* channels;
if (WSAStartup(0x101, &wsa_data) != 0)
return 1;
instance->VerifyCertificate = wf_verify_certificate;
instance->ReceiveChannelData = wf_receive_channel_data;
- instance->ContextSize = (pContextSize) wf_context_size;
- instance->ContextNew = (pcContextNew) wf_context_new;
- instance->ContextFree = (pcContextFree) wf_context_free;
+ instance->context_size = sizeof(wfContext);
+ instance->ContextNew = wf_context_new;
+ instance->ContextFree = wf_context_free;
freerdp_context_new(instance);
- context = (wfContext*) instance->context;
- channels = context->channels;
+ instance->context->argc = __argc;
+ instance->context->argv = __argv;
if (!CreateThread(NULL, 0, kbd_thread_func, NULL, 0, NULL))
printf("error creating keyboard handler thread");
data->instance = instance;
freerdp_parse_args(instance->settings, __argc, __argv,
- wf_process_plugin_args, channels, wf_process_ui_args, NULL);
+ wf_process_plugin_args, instance->context->channels, wf_process_client_args, NULL);
if (CreateThread(NULL, 0, thread_func, data, 0, NULL) != 0)
g_thread_count++;
struct wf_bitmap
{
- rdpBitmap _p;
+ rdpBitmap _bitmap;
HDC hdc;
HBITMAP bitmap;
HBITMAP org_bitmap;
};
typedef struct wf_bitmap wfBitmap;
+struct wf_pointer
+{
+ rdpPointer pointer;
+};
+typedef struct wf_pointer wfPointer;
+
typedef struct wf_info wfInfo;
struct wf_context
rdpContext _p;
wfInfo* wfi;
- rdpChannels* channels;
};
typedef struct wf_context wfContext;
set_target_properties(freerdp-cache PROPERTIES VERSION ${FREERDP_VERSION_FULL} SOVERSION ${FREERDP_VERSION} PREFIX "lib")
+target_link_libraries(freerdp-cache freerdp-core)
target_link_libraries(freerdp-cache freerdp-utils)
install(TARGETS freerdp-cache DESTINATION ${CMAKE_INSTALL_LIBDIR})
add_library(freerdp-gdi ${FREERDP_GDI_SRCS})
+target_link_libraries(freerdp-gdi freerdp-core)
target_link_libraries(freerdp-gdi freerdp-cache)
target_link_libraries(freerdp-gdi freerdp-codec)
* limitations under the License.
*/
-#include <sys/time.h>
#include <stdio.h>
#include <string.h>
+#ifndef _WIN32
+#include <sys/time.h>
+#else
+#include <time.h>
+#include <sys/timeb.h>
+
+struct timeval
+{
+ long tv_sec;
+ long tv_usec;
+};
+
+int gettimeofday(struct timeval* tp, void* tz)
+{
+ struct _timeb timebuffer;
+ _ftime (&timebuffer);
+ tp->tv_sec = (long) timebuffer.time;
+ tp->tv_usec = timebuffer.millitm * 1000;
+ return 0;
+}
+#endif
+
#include <freerdp/types.h>
#include <freerdp/utils/memory.h>
projects / platform / upstream / freerdp.git / commitdiff