mirrors
/
FreeRDP
mirror of https://github.com/FreeRDP/FreeRDP
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Refactoring - mac platform

This commit is contained in:
Benoît LeBlanc 2013-06-14 16:19:03 -04:00
parent 2c7079cd57
commit 1910205d06
8 changed files with 124 additions and 797 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
client/Mac/CMakeLists.txt
View File

@ -154,23 +154,21 @@ if("${CMAKE_GENERATOR}" MATCHES "Unix Makefiles")
--compile ${CMAKE_CURRENT_BINARY_DIR}/$(CONFIGURATION)/${MODULE_NAME}.app/Contents/Resources/${XIB_WE}.nib ${xib}
COMMENT "Compiling ${xib}")
endforeach()
# Copy the public header files into the framework
foreach(HEADER ${${MODULE_NAME}_HEADERS})
# message("adding post-build dependency: ${LIB}")
add_custom_command(TARGET ${MODULE_NAME} POST_BUILD
COMMAND ditto ${HEADER} ${CMAKE_CURRENT_BINARY_DIR}/$(CONFIGURATION)/${MODULE_NAME}.framework/Headers/
COMMENT Copying public header files to ${MODULE_NAME}
)
endforeach()
# Copy the FreeRDP header files into the framework
add_custom_command(TARGET ${MODULE_NAME} POST_BUILD
COMMAND ditto ${CMAKE_SOURCE_DIR}/include/freerdp ${CMAKE_CURRENT_BINARY_DIR}/$(CONFIGURATION)/${MODULE_NAME}.framework/Headers/freerdp
COMMENT Copying FreeRDP header files to ${MODULE_NAME}
)
endif()
# Copy the public header files into the framework
foreach(HEADER ${${MODULE_NAME}_HEADERS})
# message("adding post-build dependency: ${LIB}")
add_custom_command(TARGET ${MODULE_NAME} POST_BUILD
COMMAND ditto ${HEADER} ${CMAKE_CURRENT_BINARY_DIR}/$(CONFIGURATION)/${MODULE_NAME}.framework/Headers/
COMMENT Copying public header files to ${MODULE_NAME}
)
endforeach()
# Copy the FreeRDP header files into the framework
add_custom_command(TARGET ${MODULE_NAME} POST_BUILD
COMMAND ditto ${CMAKE_SOURCE_DIR}/include/freerdp ${CMAKE_CURRENT_BINARY_DIR}/$(CONFIGURATION)/${MODULE_NAME}.framework/Headers/freerdp
COMMENT Copying FreeRDP header files to ${MODULE_NAME}
)

5
client/Mac/MRDPView.m
View File

@ -87,7 +87,7 @@ void mf_Pointer_SetDefault(rdpContext* context);
BOOL mac_pre_connect(freerdp* instance);
BOOL mac_post_connect(freerdp* instance);
BOOL mac_authenticate(freerdp* instance, char** username, char** password, char** domain);
void mac_context_new(freerdp* instance, rdpContext* context);
int mac_context_new(freerdp* instance, rdpContext* context);
void mac_context_free(freerdp* instance, rdpContext* context);
void mac_set_bounds(rdpContext* context, rdpBounds* bounds);
void mac_bitmap_update(rdpContext* context, BITMAP_UPDATE* bitmap);
@ -1342,10 +1342,11 @@ void mf_Pointer_SetDefault(rdpContext* context)
* create a new context - but all we really need to do is save state info
***********************************************************************/
void mac_context_new(freerdp* instance, rdpContext* context)
int mac_context_new(freerdp* instance, rdpContext* context)
{
[g_mrdpview saveStateInfo:instance :context];
context->channels = freerdp_channels_new();
return 0;
}
/** *********************************************************************

224
client/Mac/mf_client.c
View File

@ -1,224 +0,0 @@
/**
* FreeRDP: A Remote Desktop Protocol Implementation
* X11 Client Interface
*
* Copyright 2013 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.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <freerdp/utils/signal.h>
#include <freerdp/client/cmdline.h>
#include "mf_client.h"
/**
* Client Interface
*/
int freerdp_client_global_init()
{
// setlocale(LC_ALL, "");
freerdp_handle_signals();
freerdp_channels_global_init();
return 0;
}
int freerdp_client_global_uninit()
{
freerdp_channels_global_uninit();
return 0;
}
int freerdp_client_start(rdpContext* cfc)
{
mfContext* mfc = (mfContext*) cfc;
rdpSettings* settings = mfc->settings;
if (!settings->ServerHostname)
{
fprintf(stderr, "error: server hostname was not specified with /v:<server>[:port]\n");
return -1;
}
//mfi->thread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) mf_thread, (void*) mfi->instance, 0, NULL);
return 0;
}
int freerdp_client_stop(rdpContext* cfc)
{
mfContext* mfc = (mfContext*) cfc;
// if (mfi->instance->settings->AsyncInput)
// {
// wMessageQueue* queue;
// queue = freerdp_get_message_queue(mfi->instance, FREERDP_INPUT_MESSAGE_QUEUE);
// MessageQueue_PostQuit(queue, 0);
// }
// else
// {
// mfi->disconnect = TRUE;
// }
return 0;
}
HANDLE freerdp_client_get_thread(rdpContext* cfc)
{
mfContext* mfc = (mfContext*) cfc;
return mfc->thread;
}
rdpClient* freerdp_client_get_interface(rdpContext* cfc)
{
mfContext* mfc = (mfContext*) cfc;
return mfc->client;
}
rdpContext* freerdp_client_new(int argc, char** argv)
{
int index;
int status;
mfContext* mfc;
rdpFile* file;
freerdp* instance;
rdpSettings* settings;
instance = freerdp_new();
// instance->PreConnect = mf_pre_connect;
// instance->PostConnect = mf_post_connect;
// instance->Authenticate = mf_authenticate;
// instance->VerifyCertificate = mf_verify_certificate;
// instance->LogonErrorInfo = mf_logon_error_info;
// instance->ReceiveChannelData = mf_receive_channel_data;
instance->ContextSize = sizeof(mfContext);
instance->ContextNew = (pContextNew) mf_context_new;
instance->ContextFree = (pContextFree) mf_context_free;
freerdp_context_new(instance);
instance->context->argc = argc;
instance->context->argv = (char**) malloc(sizeof(char*) * argc);
for (index = 0; index < argc; index++)
instance->context->argv[index] = _strdup(argv[index]);
mfc = (mfContext*) instance->context;
mfc->instance = instance;
settings = instance->settings;
mfc->client = instance->context->client;
mfc->settings = instance->context->settings;
settings->OsMajorType = OSMAJORTYPE_UNIX;
settings->OsMinorType = OSMINORTYPE_NATIVE_XSERVER;
settings->OrderSupport[NEG_DSTBLT_INDEX] = TRUE;
settings->OrderSupport[NEG_PATBLT_INDEX] = TRUE;
settings->OrderSupport[NEG_SCRBLT_INDEX] = TRUE;
settings->OrderSupport[NEG_OPAQUE_RECT_INDEX] = TRUE;
settings->OrderSupport[NEG_DRAWNINEGRID_INDEX] = FALSE;
settings->OrderSupport[NEG_MULTIDSTBLT_INDEX] = FALSE;
settings->OrderSupport[NEG_MULTIPATBLT_INDEX] = FALSE;
settings->OrderSupport[NEG_MULTISCRBLT_INDEX] = FALSE;
settings->OrderSupport[NEG_MULTIOPAQUERECT_INDEX] = TRUE;
settings->OrderSupport[NEG_MULTI_DRAWNINEGRID_INDEX] = FALSE;
settings->OrderSupport[NEG_LINETO_INDEX] = TRUE;
settings->OrderSupport[NEG_POLYLINE_INDEX] = TRUE;
settings->OrderSupport[NEG_MEMBLT_INDEX] = settings->BitmapCacheEnabled;
settings->OrderSupport[NEG_MEM3BLT_INDEX] = (settings->SoftwareGdi) ? TRUE : FALSE;
settings->OrderSupport[NEG_MEMBLT_V2_INDEX] = settings->BitmapCacheEnabled;
settings->OrderSupport[NEG_MEM3BLT_V2_INDEX] = FALSE;
settings->OrderSupport[NEG_SAVEBITMAP_INDEX] = FALSE;
settings->OrderSupport[NEG_GLYPH_INDEX_INDEX] = TRUE;
settings->OrderSupport[NEG_FAST_INDEX_INDEX] = TRUE;
settings->OrderSupport[NEG_FAST_GLYPH_INDEX] = TRUE;
settings->OrderSupport[NEG_POLYGON_SC_INDEX] = (settings->SoftwareGdi) ? FALSE : TRUE;
settings->OrderSupport[NEG_POLYGON_CB_INDEX] = (settings->SoftwareGdi) ? FALSE : TRUE;
settings->OrderSupport[NEG_ELLIPSE_SC_INDEX] = FALSE;
settings->OrderSupport[NEG_ELLIPSE_CB_INDEX] = FALSE;
return (rdpContext*) mfc;
}
void freerdp_client_free(rdpContext* cfc)
{
mfContext* mfc = (mfContext*) cfc;
if (mfc)
{
int index;
freerdp* instance;
rdpContext* context;
context = (rdpContext*) mfc;
instance = context->instance;
for (index = 0; index < context->argc; index++)
free(context->argv[index]);
free(context->argv);
freerdp_context_free(instance);
freerdp_free(instance);
}
}
void freerdp_client_mouse_event(rdpContext* cfc, DWORD flags, int x, int y)
{
int width, height;
mfContext* mfc = (mfContext*) cfc;
rdpInput* input = mfc->instance->input;
rdpSettings* settings = mfc->instance->settings;
width = settings->DesktopWidth;
height = settings->DesktopHeight;
if (x < 0)
x = 0;
if (x >= width)
x = width - 1;
if (y < 0)
y = 0;
if (y >= height)
y = height - 1;
input->MouseEvent(input, flags, x, y);
}
int mf_context_new(freerdp* instance, cfContext* cfc)
{
cfc->instance = instance;
cfc->settings = instance->settings;
return 0;
}
void mf_context_free(freerdp* instance, cfContext* cfc)
{
}

97
client/Mac/mf_client.h
View File

@ -1,97 +0,0 @@
#ifndef MF_CLIENT_H
#define MF_CLIENT_H
#ifdef __cplusplus
extern "C" {
#endif
#include <winpr/windows.h>
#include <freerdp/api.h>
#include <freerdp/freerdp.h>
#include <freerdp/gdi/gdi.h>
#include <freerdp/gdi/dc.h>
#include <freerdp/gdi/region.h>
#include <freerdp/cache/cache.h>
#include <freerdp/codec/color.h>
#include <freerdp/utils/debug.h>
#include <freerdp/channels/channels.h>
#include <freerdp/codec/rfx.h>
#include <freerdp/codec/nsc.h>
#include <freerdp/client/file.h>
#include "mf_event.h"
// System menu constants
#define SYSCOMMAND_ID_SMARTSIZING 1000
struct mf_context
{
rdpContext context;
freerdp* instance;
rdpClient* client;
rdpSettings* settings;
int width;
int height;
int offset_x;
int offset_y;
int fs_toggle;
int fullscreen;
int percentscreen;
char window_title[64];
int client_x;
int client_y;
int client_width;
int client_height;
HANDLE thread;
HANDLE keyboardThread;
HGDI_DC hdc;
UINT16 srcBpp;
UINT16 dstBpp;
DWORD mainThreadId;
DWORD keyboardThreadId;
RFX_CONTEXT* rfx_context;
NSC_CONTEXT* nsc_context;
BOOL sw_gdi;
rdpFile* connectionRdpFile;
// Keep track of window size and position, disable when in fullscreen mode.
BOOL disablewindowtracking;
// These variables are required for horizontal scrolling.
BOOL updating_scrollbars;
BOOL xScrollVisible;
int xMinScroll; // minimum horizontal scroll value
int xCurrentScroll; // current horizontal scroll value
int xMaxScroll; // maximum horizontal scroll value
// These variables are required for vertical scrolling.
BOOL yScrollVisible;
int yMinScroll; // minimum vertical scroll value
int yCurrentScroll; // current vertical scroll value
int yMaxScroll; // maximum vertical scroll value
};
typedef struct mf_context mfContext;
/**
* Client Interface
*/
typedef struct mf_context cfContext;
void mf_context_new(freerdp* instance, cfContext* context);
void mf_context_free(freerdp* instance, cfContext* context);
#ifdef __cplusplus
}
#endif
#endif // MF_CLIENT_H

305
client/Mac/mf_interface.c
View File

@ -22,6 +22,7 @@
#endif
#include "mfreerdp.h"
#include <freerdp/constants.h>
#include <freerdp/utils/signal.h>
#include <freerdp/client/cmdline.h>
@ -29,87 +30,61 @@
* Client Interface
*/
int freerdp_client_global_init()
void mfreerdp_client_global_init()
{
// setlocale(LC_ALL, "");
freerdp_handle_signals();
freerdp_channels_global_init();
return 0;
}
int freerdp_client_global_uninit()
void mfreerdp_client_global_uninit()
{
freerdp_channels_global_uninit();
}
int mfreerdp_client_start(rdpContext* context)
{
mfContext* mfc = (mfContext*) context;
rdpSettings* settings = context->settings;
if (!settings->ServerHostname)
{
fprintf(stderr, "error: server hostname was not specified with /v:<server>[:port]\n");
return -1;
}
// mfc->thread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) mf_thread, context->instance, 0, NULL);
return 0;
}
int freerdp_client_start(void* cfi)
int mfreerdp_client_stop(rdpContext* context)
{
mfInfo* mfi = (mfInfo*) cfi;
mfContext* mfc = (mfContext*) context;
rdpSettings* settings = mfi->instance->settings;
if (context->settings->AsyncInput)
{
wMessageQueue* queue;
queue = freerdp_get_message_queue(context->instance, FREERDP_INPUT_MESSAGE_QUEUE);
MessageQueue_PostQuit(queue, 0);
}
else
{
mfc->disconnect = TRUE;
}
if (!settings->ServerHostname)
{
fprintf(stderr, "error: server hostname was not specified with /v:<server>[:port]\n");
return -1;
}
//mfi->thread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) mf_thread, (void*) mfi->instance, 0, NULL);
return 0;
return 0;
}
int freerdp_client_stop(void* cfi)
int mfreerdp_client_new(freerdp* instance, rdpContext* context)
{
mfInfo* mfi = (mfInfo*) cfi;
mfContext* mfc;
rdpSettings* settings;
// if (mfi->instance->settings->AsyncInput)
// {
// wMessageQueue* queue;
// queue = freerdp_get_message_queue(mfi->instance, FREERDP_INPUT_MESSAGE_QUEUE);
// MessageQueue_PostQuit(queue, 0);
// }
// else
// {
// mfi->disconnect = TRUE;
// }
mfc = (mfContext*) instance->context;
return 0;
}
void* freerdp_client_get_instance(void* cfi)
{
mfInfo* mfi = (mfInfo*) cfi;
return mfi->instance;
}
HANDLE freerdp_client_get_thread(void* cfi)
{
mfInfo* mfi = (mfInfo*) cfi;
return mfi->thread;
}
void* freerdp_client_get_interface(void* cfi)
{
mfInfo* mfi = (mfInfo*) cfi;
return mfi->client;
}
cfInfo* freerdp_client_new(int argc, char** argv)
{
int index;
int status;
mfInfo* mfi;
rdpFile* file;
freerdp* instance;
rdpSettings* settings;
instance = freerdp_new();
// TODO
// instance->PreConnect = mf_pre_connect;
// instance->PostConnect = mf_post_connect;
// instance->Authenticate = mf_authenticate;
@ -117,48 +92,14 @@ cfInfo* freerdp_client_new(int argc, char** argv)
// instance->LogonErrorInfo = mf_logon_error_info;
// instance->ReceiveChannelData = mf_receive_channel_data;
instance->context_size = sizeof(mfContext);
instance->ContextNew = (pContextNew) mf_context_new;
instance->ContextFree = (pContextFree) mf_context_free;
freerdp_context_new(instance);
context->channels = freerdp_channels_new();
instance->context->argc = argc;
instance->context->argv = (char**) malloc(sizeof(char*) * argc);
settings = instance->settings;
mfc->client = instance->context->client;
mfc->settings = instance->context->settings;
for (index = 0; index < argc; index++)
instance->context->argv[index] = _strdup(argv[index]);
mfi = (mfInfo*) malloc(sizeof(mfInfo));
ZeroMemory(mfi, sizeof(mfInfo));
((mfContext*) instance->context)->mfi = mfi;
mfi->instance = instance;
settings = instance->settings;
mfi->client = instance->context->client;
status = freerdp_client_parse_command_line_arguments(instance->context->argc,
instance->context->argv, settings);
if (status < 0)
{
freerdp_context_free(mfi->instance);
freerdp_free(mfi->instance);
free(mfi);
return NULL;
}
if (settings->ConnectionFile)
{
file = freerdp_client_rdp_file_new();
fprintf(stderr, "Using connection file: %s\n", settings->ConnectionFile);
freerdp_client_parse_rdp_file(file, settings->ConnectionFile);
freerdp_client_populate_settings_from_rdp_file(file, settings);
}
settings->OsMajorType = OSMAJORTYPE_UNIX;
settings->OsMinorType = OSMINORTYPE_NATIVE_XSERVER;
settings->OsMajorType = OSMAJORTYPE_MACINTOSH;
settings->OsMinorType = OSMINORTYPE_MACINTOSH;
settings->OrderSupport[NEG_DSTBLT_INDEX] = TRUE;
settings->OrderSupport[NEG_PATBLT_INDEX] = TRUE;
@ -189,130 +130,58 @@ cfInfo* freerdp_client_new(int argc, char** argv)
settings->OrderSupport[NEG_ELLIPSE_SC_INDEX] = FALSE;
settings->OrderSupport[NEG_ELLIPSE_CB_INDEX] = FALSE;
// if (settings->ListMonitors)
// {
// mf_list_monitors(mfi);
// }
return mfi;
return 0;
}
void freerdp_client_free(void* cfi)
void mfreerdp_client_free(freerdp* instance, rdpContext* context)
{
mfInfo* mfi = (mfInfo*) cfi;
mfContext* mfc = (mfContext*) context;
if (mfi)
{
int index;
rdpContext* context;
// mf_window_free(mfi);
// free(mfi->bmp_codec_none);
// XCloseDisplay(mfi->display);
// context = (rdpContext*) mfi->context;
for (index = 0; index < context->argc; index++)
free(context->argv[index]);
free(context->argv);
freerdp_context_free(mfi->instance);
freerdp_free(mfi->instance);
free(mfi);
}
if (context)
{
}
}
//void freerdp_client_mouse_event(rdpContext* cfc, DWORD flags, int x, int y)
//{
// int width, height;
// rdpInput* input = cfc->instance->input;
// rdpSettings* settings = cfc->instance->settings;
BOOL freerdp_client_get_param_bool(void* cfi, int id)
// width = settings->DesktopWidth;
// height = settings->DesktopHeight;
// if (x < 0)
// x = 0;
// if (x >= width)
// x = width - 1;
// if (y < 0)
// y = 0;
// if (y >= height)
// y = height - 1;
// input->MouseEvent(input, flags, x, y);
//}
int RdpClientEntry(RDP_CLIENT_ENTRY_POINTS* pEntryPoints)
{
mfInfo* mfi = (mfInfo*) cfi;
rdpSettings* settings = mfi->instance->settings;
pEntryPoints->Version = 1;
pEntryPoints->Size = sizeof(RDP_CLIENT_ENTRY_POINTS_V1);
return freerdp_get_param_bool(settings, id);
}
int freerdp_client_set_param_bool(void* cfi, int id, BOOL param)
{
mfInfo* mfi = (mfInfo*) cfi;
rdpSettings* settings = mfi->instance->settings;
return freerdp_set_param_bool(settings, id, param);
}
UINT32 freerdp_client_get_param_uint32(void* cfi, int id)
{
mfInfo* mfi = (mfInfo*) cfi;
rdpSettings* settings = mfi->instance->settings;
return freerdp_get_param_uint32(settings, id);
}
int freerdp_client_set_param_uint32(void* cfi, int id, UINT32 param)
{
mfInfo* mfi = (mfInfo*) cfi;
rdpSettings* settings = mfi->instance->settings;
return freerdp_set_param_uint32(settings, id, param);
}
UINT64 freerdp_client_get_param_uint64(void* cfi, int id)
{
mfInfo* mfi = (mfInfo*) cfi;
rdpSettings* settings = mfi->instance->settings;
return freerdp_get_param_uint64(settings, id);
}
int freerdp_client_set_param_uint64(void* cfi, int id, UINT64 param)
{
mfInfo* mfi = (mfInfo*) cfi;
rdpSettings* settings = mfi->instance->settings;
return freerdp_set_param_uint64(settings, id, param);
}
char* freerdp_client_get_param_string(void* cfi, int id)
{
mfInfo* mfi = (mfInfo*) cfi;
rdpSettings* settings = mfi->instance->settings;
return freerdp_get_param_string(settings, id);
}
int freerdp_client_set_param_string(void* cfi, int id, char* param)
{
mfInfo* mfi = (mfInfo*) cfi;
rdpSettings* settings = mfi->instance->settings;
return freerdp_set_param_string(settings, id, param);
}
void freerdp_client_mouse_event(void* cfi, DWORD flags, int x, int y)
{
int width, height;
mfInfo* mfi = (mfInfo*) cfi;
rdpInput* input = mfi->instance->input;
rdpSettings* settings = mfi->instance->settings;
width = settings->DesktopWidth;
height = settings->DesktopHeight;
if (x < 0)
x = 0;
if (x >= width)
x = width - 1;
if (y < 0)
y = 0;
if (y >= height)
y = height - 1;
input->MouseEvent(input, flags, x, y);
pEntryPoints->GlobalInit = mfreerdp_client_global_init;
pEntryPoints->GlobalUninit = mfreerdp_client_global_uninit;
pEntryPoints->ContextSize = sizeof(mfContext);
pEntryPoints->ClientNew = mfreerdp_client_new;
pEntryPoints->ClientFree = mfreerdp_client_free;
pEntryPoints->ClientStart = mfreerdp_client_start;
pEntryPoints->ClientStop = mfreerdp_client_stop;
return 0;
}

53
client/Mac/mf_interface.h
View File

@ -22,58 +22,17 @@
#ifndef __MF_INTERFACE_H
#define __MF_INTERFACE_H
#include <freerdp/client.h>
#ifdef __cplusplus
extern "C" {
#endif
#include "mfreerdp.h"
#include <freerdp/api.h>
/**
* Client Interface
*/
// Callback type codes. Move elsewhere?
#define CALLBACK_TYPE_PARAM_CHANGE 0x01
#define CALLBACK_TYPE_CONNECTED 0x02
#define CALLBACK_TYPE_DISCONNECTED 0x03
// Public API functions
FREERDP_API int freerdp_client_global_init();
FREERDP_API int freerdp_client_global_uninit();
FREERDP_API int freerdp_client_start(void* cfi); // mfInfo
FREERDP_API int freerdp_client_stop(void* cfi); // mfInfo
FREERDP_API void* freerdp_client_get_thread(void* cfi); // HANDLE, mfInfo
FREERDP_API void* freerdp_client_get_instance(void* cfi); // freerdp, mfInfo
FREERDP_API void* freerdp_client_get_interface(void* cfi); // rdpClient, mfInfo
FREERDP_API int freerdp_client_focus_in(void* cfi); // mfInfo
FREERDP_API int freerdp_client_focus_out(void* cfi); // mfInfo
FREERDP_API int freerdp_client_set_window_size(void* cfi, int width, int height);
FREERDP_API cfInfo* freerdp_client_new(int argc, char** argv); // cfInfo*
FREERDP_API void freerdp_client_free(cfInfo* cfi); // mfInfo*
FREERDP_API int freerdp_client_set_client_callback_function(void* cfi, void* callbackFunc);
FREERDP_API void* freerdp_client_get_settings(void* cfi); // rdpSettings*, mfInfo*
FREERDP_API int freerdp_client_load_settings_from_rdp_file(void* cfi, char* filename); // mfInfo*
FREERDP_API int freerdp_client_save_settings_to_rdp_file(void* cfi, char* filename); // mfInfo*
FREERDP_API BOOL freerdp_client_get_param_bool(void* cfi, int id);
FREERDP_API int freerdp_client_set_param_bool(void* cfi, int id, BOOL param);
FREERDP_API UINT32 freerdp_client_get_param_uint32(void* cfi, int id);
FREERDP_API int freerdp_client_set_param_uint32(void* cfi, int id, UINT32 param);
FREERDP_API UINT64 freerdp_client_get_param_uint64(void* cfi, int id);
FREERDP_API int freerdp_client_set_param_uint64(void* cfi, int id, UINT64 param);
FREERDP_API char* freerdp_client_get_param_string(void* cfi, int id);
FREERDP_API int freerdp_client_set_param_string(void* cfi, int id, char* param);
FREERDP_API void freerdp_client_mouse_event(void* cfi, DWORD flags, int x, int y);
FREERDP_API int RdpClientEntry(RDP_CLIENT_ENTRY_POINTS* pEntryPoints);
#ifdef __cplusplus
}

109
client/Mac/mfreerdp.c
View File

@ -1,109 +0,0 @@
/**
* FreeRDP: A Remote Desktop Protocol Implementation
* X11 Client Interface
*
* Copyright 2013 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.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
#include <unistd.h>
#include <string.h>
#include <termios.h>
#include <pthread.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <sys/select.h>
#include <freerdp/freerdp.h>
#include <freerdp/constants.h>
#include <freerdp/codec/nsc.h>
#include <freerdp/codec/rfx.h>
#include <freerdp/codec/color.h>
#include <freerdp/codec/bitmap.h>
#include <freerdp/utils/event.h>
#include <freerdp/utils/signal.h>
#include <freerdp/utils/passphrase.h>
#include <freerdp/client/cliprdr.h>
#include <freerdp/client/channels.h>
#include <freerdp/rail.h>
#include <freerdp/client/file.h>
#include <freerdp/client/cmdline.h>
#include <winpr/crt.h>
#include <winpr/synch.h>
#include <winpr/file.h>
#include "mf_interface.h"
#include "mfreerdp.h"
static long xv_port = 0;
static const size_t password_size = 512;
mfInfo* mf_mfi_new()
{
mfInfo* mfi;
mfi = (mfInfo*) malloc(sizeof(mfInfo));
ZeroMemory(mfi, sizeof(mfInfo));
return mfi;
}
void mf_mfi_free(mfInfo* mfi)
{
free(mfi);
}
void mf_context_new(freerdp* instance, rdpContext* context)
{
mfInfo* mfi;
context->channels = freerdp_channels_new();
mfi = mf_mfi_new();
((mfContext*) context)->mfi = mfi;
mfi->instance = instance;
// Register callbacks
instance->context->client->OnParamChange = mf_on_param_change;
}
void mf_context_free(freerdp* instance, rdpContext* context)
{
if (context->cache)
cache_free(context->cache);
freerdp_channels_free(context->channels);
mf_mfi_free(((mfContext*) context)->mfi);
((mfContext*) context)->mfi = NULL;
}
void mf_on_param_change(freerdp* instance, int id)
{
}

92
client/Mac/mfreerdp.h
View File

@ -1,51 +1,30 @@
#ifndef MFREERDP_H
#define MFREERDP_H
#ifdef __cplusplus
extern "C" {
#endif
#include <winpr/windows.h>
typedef struct mf_context mfContext;
#include <freerdp/freerdp.h>
#include <freerdp/client/file.h>
#include <freerdp/api.h>
#include <freerdp/freerdp.h>
#include <freerdp/gdi/gdi.h>
#include <freerdp/gdi/dc.h>
#include <freerdp/gdi/region.h>
#include <freerdp/rail/rail.h>
#include <freerdp/cache/cache.h>
#include <freerdp/codec/color.h>
#include <freerdp/utils/debug.h>
#include <freerdp/channels/channels.h>
#include <freerdp/codec/rfx.h>
#include <freerdp/codec/nsc.h>
#include <freerdp/client/file.h>
#include "mf_event.h"
#ifdef __cplusplus
}
#endif
// System menu constants
#define SYSCOMMAND_ID_SMARTSIZING 1000
typedef struct mf_info mfInfo;
#include <winpr/crt.h>
#include <winpr/synch.h>
#include <winpr/thread.h>
struct mf_context
{
rdpContext _p;
rdpContext context;
mfInfo* mfi;
};
typedef struct mf_context mfContext;
typedef void (CALLBACK * callbackFunc)(mfInfo* mfi, int callback_type, DWORD param1, DWORD param2);
struct mf_info
{
rdpClient* client;
rdpSettings* settings;
int width;
int height;
@ -70,11 +49,8 @@ struct mf_info
DWORD mainThreadId;
DWORD keyboardThreadId;
RFX_CONTEXT* rfx_context;
NSC_CONTEXT* nsc_context;
BOOL disconnect;
BOOL sw_gdi;
callbackFunc client_callback_func;
rdpFile* connectionRdpFile;
@ -95,50 +71,4 @@ struct mf_info
int yMaxScroll; // maximum vertical scroll value
};
/**
* Client Interface
*/
#define cfInfo mfInfo
void mf_on_param_change(freerdp* instance, int id);
//FREERDP_API int freerdp_client_global_init();
//FREERDP_API int freerdp_client_global_uninit();
//FREERDP_API int freerdp_client_start(mfInfo* cfi);
//FREERDP_API int freerdp_client_stop(mfInfo* cfi);
//FREERDP_API HANDLE freerdp_client_get_thread(mfInfo* cfi);
//FREERDP_API freerdp* freerdp_client_get_instance(mfInfo* cfi);
//FREERDP_API rdpClient* freerdp_client_get_interface(mfInfo* cfi);
//FREERDP_API int freerdp_client_focus_in(mfInfo* cfi);
//FREERDP_API int freerdp_client_focus_out(mfInfo* cfi);
//FREERDP_API int freerdp_client_set_window_size(mfInfo* cfi, int width, int height);
//FREERDP_API cfInfo* freerdp_client_new(int argc, char** argv);
//FREERDP_API void freerdp_client_free(mfInfo* cfi);
//FREERDP_API int freerdp_client_set_client_callback_function(mfInfo* cfi, callbackFunc callbackFunc);
//FREERDP_API rdpSettings* freerdp_client_get_settings(mfInfo* wfi);
//FREERDP_API int freerdp_client_load_settings_from_rdp_file(mfInfo* cfi, char* filename);
//FREERDP_API int freerdp_client_save_settings_to_rdp_file(mfInfo* cfi, char* filename);
mfInfo* mf_mfi_new();
void mf_mfi_free(mfInfo* mfi);
void mf_context_new(freerdp* instance, rdpContext* context);
void mf_context_free(freerdp* instance, rdpContext* context);
void mf_on_param_change(freerdp* instance, int id);
#endif // MFREERDP_H