mirrors/FreeRDP
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

freerdp: change boolean type to BOOL type

Browse Source
This commit is contained in:
Marc-André Moreau 2012-10-09 02:38:39 -04:00
parent 5612bc43f8
commit 1ed644786c
199 changed files with 1074 additions and 1079 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
channels/audin/client/alsa/audin_alsa.c
View File

@ -58,7 +58,7 @@ typedef struct _AudinALSADevice
void* user_data;
} AudinALSADevice;
static boolean audin_alsa_set_params(AudinALSADevice* alsa, snd_pcm_t* capture_handle)
static BOOL audin_alsa_set_params(AudinALSADevice* alsa, snd_pcm_t* capture_handle)
{
int error;
snd_pcm_hw_params_t* hw_params;
@ -93,7 +93,7 @@ static boolean audin_alsa_set_params(AudinALSADevice* alsa, snd_pcm_t* capture_h
return TRUE;
}
static boolean audin_alsa_thread_receive(AudinALSADevice* alsa, uint8* src, int size)
static BOOL audin_alsa_thread_receive(AudinALSADevice* alsa, uint8* src, int size)
{
int frames;
int cframes;
@ -239,7 +239,7 @@ static void audin_alsa_free(IAudinDevice* device)
free(alsa);
}
static boolean audin_alsa_format_supported(IAudinDevice* device, audinFormat* format)
static BOOL audin_alsa_format_supported(IAudinDevice* device, audinFormat* format)
{
switch (format->wFormatTag)
{

8
channels/audin/client/audin_main.c
View File

@ -219,7 +219,7 @@ static int audin_send_open_reply_pdu(IWTSVirtualChannelCallback* pChannelCallbac
return error;
}
static boolean audin_receive_wave_data(uint8* data, int size, void* user_data)
static BOOL audin_receive_wave_data(uint8* data, int size, void* user_data)
{
int error;
STREAM* out;
@ -436,7 +436,7 @@ static void audin_register_device_plugin(IWTSPlugin* pPlugin, IAudinDevice* devi
audin->device = device;
}
static boolean audin_load_device_plugin(IWTSPlugin* pPlugin, const char* name, RDP_PLUGIN_DATA* data)
static BOOL audin_load_device_plugin(IWTSPlugin* pPlugin, const char* name, RDP_PLUGIN_DATA* data)
{
char* fullname;
PFREERDP_AUDIN_DEVICE_ENTRY entry;
@ -471,9 +471,9 @@ static boolean audin_load_device_plugin(IWTSPlugin* pPlugin, const char* name, R
return TRUE;
}
static boolean audin_process_plugin_data(IWTSPlugin* pPlugin, RDP_PLUGIN_DATA* data)
static BOOL audin_process_plugin_data(IWTSPlugin* pPlugin, RDP_PLUGIN_DATA* data)
{
boolean ret;
BOOL ret;
AUDIN_PLUGIN* audin = (AUDIN_PLUGIN*) pPlugin;
RDP_PLUGIN_DATA default_data[2] = { { 0 }, { 0 } };

4
channels/audin/client/audin_main.h
View File

@ -34,7 +34,7 @@
#define DEBUG_DVC(fmt, ...) DEBUG_NULL(fmt, ## __VA_ARGS__)
#endif
typedef boolean (*AudinReceive) (uint8* data, int size, void* user_data);
typedef BOOL (*AudinReceive) (uint8* data, int size, void* user_data);
typedef struct audin_format audinFormat;
struct audin_format
@ -52,7 +52,7 @@ typedef struct _IAudinDevice IAudinDevice;
struct _IAudinDevice
{
void (*Open) (IAudinDevice* devplugin, AudinReceive receive, void* user_data);
boolean (*FormatSupported) (IAudinDevice* devplugin, audinFormat* format);
BOOL (*FormatSupported) (IAudinDevice* devplugin, audinFormat* format);
void (*SetFormat) (IAudinDevice* devplugin, audinFormat* format, uint32 FramesPerPacket);
void (*Close) (IAudinDevice* devplugin);
void (*Free) (IAudinDevice* devplugin);

6
channels/audin/client/pulse/audin_pulse.c
View File

@ -80,7 +80,7 @@ static void audin_pulse_context_state_callback(pa_context* context, void* userda
}
}
static boolean audin_pulse_connect(IAudinDevice* device)
static BOOL audin_pulse_connect(IAudinDevice* device)
{
pa_context_state_t state;
AudinPulseDevice* pulse = (AudinPulseDevice*) device;
@ -155,7 +155,7 @@ static void audin_pulse_free(IAudinDevice* device)
free(pulse);
}
static boolean audin_pulse_format_supported(IAudinDevice* device, audinFormat* format)
static BOOL audin_pulse_format_supported(IAudinDevice* device, audinFormat* format)
{
AudinPulseDevice* pulse = (AudinPulseDevice*) device;
@ -279,7 +279,7 @@ static void audin_pulse_stream_request_callback(pa_stream* stream, size_t length
{
int frames;
int cframes;
boolean ret;
BOOL ret;
const void* data;
const uint8* src;
int encoded_size;

18
channels/audin/server/audin.c
View File

@ -50,7 +50,7 @@ typedef struct _audin_server
FREERDP_DSP_CONTEXT* dsp_context;
boolean opened;
BOOL opened;
} audin_server;
static void audin_server_select_format(audin_server_context* context, int client_format_index)
@ -73,7 +73,7 @@ static void audin_server_send_version(audin_server* audin, STREAM* s)
WTSVirtualChannelWrite(audin->audin_channel, stream_get_head(s), stream_get_length(s), NULL);
}
static boolean audin_server_recv_version(audin_server* audin, STREAM* s, uint32 length)
static BOOL audin_server_recv_version(audin_server* audin, STREAM* s, uint32 length)
{
uint32 Version;
@ -120,7 +120,7 @@ static void audin_server_send_formats(audin_server* audin, STREAM* s)
WTSVirtualChannelWrite(audin->audin_channel, stream_get_head(s), stream_get_length(s), NULL);
}
static boolean audin_server_recv_formats(audin_server* audin, STREAM* s, uint32 length)
static BOOL audin_server_recv_formats(audin_server* audin, STREAM* s, uint32 length)
{
int i;
@ -189,7 +189,7 @@ static void audin_server_send_open(audin_server* audin, STREAM* s)
WTSVirtualChannelWrite(audin->audin_channel, stream_get_head(s), stream_get_length(s), NULL);
}
static boolean audin_server_recv_open_reply(audin_server* audin, STREAM* s, uint32 length)
static BOOL audin_server_recv_open_reply(audin_server* audin, STREAM* s, uint32 length)
{
uint32 Result;
@ -202,7 +202,7 @@ static boolean audin_server_recv_open_reply(audin_server* audin, STREAM* s, uint
return TRUE;
}
static boolean audin_server_recv_data(audin_server* audin, STREAM* s, uint32 length)
static BOOL audin_server_recv_data(audin_server* audin, STREAM* s, uint32 length)
{
rdpsndFormat* format;
int sbytes_per_sample;
@ -266,7 +266,7 @@ static void* audin_server_thread_func(void* arg)
STREAM* s;
void* buffer;
uint8 MessageId;
boolean ready = FALSE;
BOOL ready = FALSE;
uint32 bytes_returned = 0;
audin_server* audin = (audin_server*) arg;
freerdp_thread* thread = audin->audin_channel_thread;
@ -287,7 +287,7 @@ static void* audin_server_thread_func(void* arg)
if (WTSVirtualChannelQuery(audin->audin_channel, WTSVirtualChannelReady, &buffer, &bytes_returned) == FALSE)
break;
ready = *((boolean*)buffer);
ready = *((BOOL*)buffer);
WTSFreeMemory(buffer);
if (ready)
break;
@ -366,7 +366,7 @@ static void* audin_server_thread_func(void* arg)
return NULL;
}
static boolean audin_server_open(audin_server_context* context)
static BOOL audin_server_open(audin_server_context* context)
{
audin_server* audin = (audin_server*) context;
@ -386,7 +386,7 @@ static boolean audin_server_open(audin_server_context* context)
return FALSE;
}
static boolean audin_server_close(audin_server_context* context)
static BOOL audin_server_close(audin_server_context* context)
{
audin_server* audin = (audin_server*) context;

4
channels/cliprdr/client/cliprdr_format.c
View File

@ -112,7 +112,7 @@ static void cliprdr_send_format_list_response(cliprdrPlugin* cliprdr)
void cliprdr_process_short_format_names(cliprdrPlugin* cliprdr, STREAM* s, uint32 length, uint16 flags)
{
int i;
boolean ascii;
BOOL ascii;
int num_formats;
CLIPRDR_FORMAT_NAME* format_name;
@ -198,7 +198,7 @@ void cliprdr_process_format_list(cliprdrPlugin* cliprdr, STREAM* s, uint32 dataL
{
int i;
uint32 format;
boolean supported;
BOOL supported;
CLIPRDR_FORMAT_NAME* format_name;
RDP_CB_FORMAT_LIST_EVENT* cb_event;

10
channels/cliprdr/client/cliprdr_main.h
View File

@ -35,11 +35,11 @@ typedef struct _CLIPRDR_FORMAT_NAME CLIPRDR_FORMAT_NAME;
struct cliprdr_plugin
{
rdpSvcPlugin plugin;
boolean received_caps;
boolean use_long_format_names;
boolean stream_fileclip_enabled;
boolean fileclip_no_file_paths;
boolean can_lock_clipdata;
BOOL received_caps;
BOOL use_long_format_names;
BOOL stream_fileclip_enabled;
BOOL fileclip_no_file_paths;
BOOL can_lock_clipdata;
CLIPRDR_FORMAT_NAME* format_names;
int num_format_names;
};

26
channels/disk/client/disk_file.c
View File

@ -55,7 +55,7 @@
#include "disk_file.h"
static boolean disk_file_wildcard_match(const char* pattern, const char* filename)
static BOOL disk_file_wildcard_match(const char* pattern, const char* filename)
{
const char *p = pattern, *f = filename;
char c;
@ -121,13 +121,13 @@ static char* disk_file_combine_fullpath(const char* base_path, const char* path)
return fullpath;
}
static boolean disk_file_remove_dir(const char* path)
static BOOL disk_file_remove_dir(const char* path)
{
DIR* dir;
char* p;
struct STAT st;
struct dirent* pdirent;
boolean ret = TRUE;
BOOL ret = TRUE;
dir = opendir(path);
@ -200,15 +200,15 @@ static void disk_file_set_fullpath(DISK_FILE* file, char* fullpath)
file->filename += 1;
}
static boolean disk_file_init(DISK_FILE* file, uint32 DesiredAccess, uint32 CreateDisposition, uint32 CreateOptions)
static BOOL disk_file_init(DISK_FILE* file, uint32 DesiredAccess, uint32 CreateDisposition, uint32 CreateOptions)
{
struct STAT st;
boolean exists;
BOOL exists;
#ifdef WIN32
const static int mode = _S_IREAD | _S_IWRITE ;
#else
const static int mode = S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH;
boolean largeFile = FALSE;
BOOL largeFile = FALSE;
#endif
int oflag = 0;
@ -346,7 +346,7 @@ void disk_file_free(DISK_FILE* file)
free(file);
}
boolean disk_file_seek(DISK_FILE* file, uint64 Offset)
BOOL disk_file_seek(DISK_FILE* file, uint64 Offset)
{
if (file->is_dir || file->fd == -1)
return FALSE;
@ -357,7 +357,7 @@ boolean disk_file_seek(DISK_FILE* file, uint64 Offset)
return TRUE;
}
boolean disk_file_read(DISK_FILE* file, uint8* buffer, uint32* Length)
BOOL disk_file_read(DISK_FILE* file, uint8* buffer, uint32* Length)
{
ssize_t r;
@ -372,7 +372,7 @@ boolean disk_file_read(DISK_FILE* file, uint8* buffer, uint32* Length)
return TRUE;
}
boolean disk_file_write(DISK_FILE* file, uint8* buffer, uint32 Length)
BOOL disk_file_write(DISK_FILE* file, uint8* buffer, uint32 Length)
{
ssize_t r;
@ -391,7 +391,7 @@ boolean disk_file_write(DISK_FILE* file, uint8* buffer, uint32 Length)
return TRUE;
}
boolean disk_file_query_information(DISK_FILE* file, uint32 FsInformationClass, STREAM* output)
BOOL disk_file_query_information(DISK_FILE* file, uint32 FsInformationClass, STREAM* output)
{
struct STAT st;
@ -442,7 +442,7 @@ boolean disk_file_query_information(DISK_FILE* file, uint32 FsInformationClass,
return TRUE;
}
boolean disk_file_set_information(DISK_FILE* file, uint32 FsInformationClass, uint32 Length, STREAM* input)
BOOL disk_file_set_information(DISK_FILE* file, uint32 FsInformationClass, uint32 Length, STREAM* input)
{
char* s;
@ -541,11 +541,11 @@ boolean disk_file_set_information(DISK_FILE* file, uint32 FsInformationClass, ui
return TRUE;
}
boolean disk_file_query_directory(DISK_FILE* file, uint32 FsInformationClass, uint8 InitialQuery,
BOOL disk_file_query_directory(DISK_FILE* file, uint32 FsInformationClass, uint8 InitialQuery,
const char* path, STREAM* output)
{
int length;
boolean ret;
BOOL ret;
WCHAR* ent_path;
struct STAT st;
struct dirent* ent;

16
channels/disk/client/disk_file.h
View File

@ -84,7 +84,7 @@ typedef struct _DISK_FILE DISK_FILE;
struct _DISK_FILE
{
uint32 id;
boolean is_dir;
BOOL is_dir;
int fd;
int err;
DIR* dir;
@ -92,19 +92,19 @@ struct _DISK_FILE
char* fullpath;
char* filename;
char* pattern;
boolean delete_pending;
BOOL delete_pending;
};
DISK_FILE* disk_file_new(const char* base_path, const char* path, uint32 id,
uint32 DesiredAccess, uint32 CreateDisposition, uint32 CreateOptions);
void disk_file_free(DISK_FILE* file);
boolean disk_file_seek(DISK_FILE* file, uint64 Offset);
boolean disk_file_read(DISK_FILE* file, uint8* buffer, uint32* Length);
boolean disk_file_write(DISK_FILE* file, uint8* buffer, uint32 Length);
boolean disk_file_query_information(DISK_FILE* file, uint32 FsInformationClass, STREAM* output);
boolean disk_file_set_information(DISK_FILE* file, uint32 FsInformationClass, uint32 Length, STREAM* input);
boolean disk_file_query_directory(DISK_FILE* file, uint32 FsInformationClass, uint8 InitialQuery,
BOOL disk_file_seek(DISK_FILE* file, uint64 Offset);
BOOL disk_file_read(DISK_FILE* file, uint8* buffer, uint32* Length);
BOOL disk_file_write(DISK_FILE* file, uint8* buffer, uint32 Length);
BOOL disk_file_query_information(DISK_FILE* file, uint32 FsInformationClass, STREAM* output);
BOOL disk_file_set_information(DISK_FILE* file, uint32 FsInformationClass, uint32 Length, STREAM* input);
BOOL disk_file_query_directory(DISK_FILE* file, uint32 FsInformationClass, uint8 InitialQuery,
const char* path, STREAM* output);
#endif /* __DISK_FILE_H */

2
channels/printer/client/printer_cups.c
View File

@ -213,7 +213,7 @@ static void printer_cups_free_printer(rdpPrinter* printer)
free(printer);
}
static rdpPrinter* printer_cups_new_printer(rdpCupsPrinterDriver* cups_driver, const char* name, boolean is_default)
static rdpPrinter* printer_cups_new_printer(rdpCupsPrinterDriver* cups_driver, const char* name, BOOL is_default)
{
rdpCupsPrinter* cups_printer;

2
channels/printer/client/printer_main.h
View File

@ -57,7 +57,7 @@ struct rdp_printer
int id;
char* name;
char* driver;
boolean is_default;
BOOL is_default;
pcCreatePrintJob CreatePrintJob;
pcFindPrintJob FindPrintJob;

2
channels/printer/client/printer_win.c
View File

@ -171,7 +171,7 @@ static void printer_win_free_printer(rdpPrinter* printer)
free(printer);
}
static rdpPrinter* printer_win_new_printer(rdpWinPrinterDriver* win_driver, const char* name, const wchar_t* drivername, boolean is_default)
static rdpPrinter* printer_win_new_printer(rdpWinPrinterDriver* win_driver, const char* name, const wchar_t* drivername, BOOL is_default)
{
rdpWinPrinter* win_printer;
wchar_t wname[256];

2
channels/rdpdr/client/devman.c
View File

@ -69,7 +69,7 @@ static void devman_register_device(DEVMAN* devman, DEVICE* device)
DEBUG_SVC("device %d.%s registered", device->id, device->name);
}
boolean devman_load_device_service(DEVMAN* devman, RDP_PLUGIN_DATA* plugin_data)
BOOL devman_load_device_service(DEVMAN* devman, RDP_PLUGIN_DATA* plugin_data)
{
char* name;
DEVICE_SERVICE_ENTRY_POINTS ep;

2
channels/rdpdr/client/devman.h
View File

@ -23,7 +23,7 @@
DEVMAN* devman_new(rdpSvcPlugin* plugin);
void devman_free(DEVMAN* devman);
boolean devman_load_device_service(DEVMAN* devman, RDP_PLUGIN_DATA* plugin_data);
BOOL devman_load_device_service(DEVMAN* devman, RDP_PLUGIN_DATA* plugin_data);
DEVICE* devman_get_device_by_id(DEVMAN* devman, uint32 id);
#endif /* FREERDP_CHANNEL_RDPDR_CLIENT_DEVMAN_H */

4
channels/rdpdr/client/rdpdr_main.c
View File

@ -147,7 +147,7 @@ static void rdpdr_process_server_clientid_confirm(rdpdrPlugin* rdpdr, STREAM* da
}
}
static void rdpdr_send_device_list_announce_request(rdpdrPlugin* rdpdr, boolean user_loggedon)
static void rdpdr_send_device_list_announce_request(rdpdrPlugin* rdpdr, BOOL user_loggedon)
{
int i;
int pos;
@ -219,7 +219,7 @@ static void rdpdr_send_device_list_announce_request(rdpdrPlugin* rdpdr, boolean
svc_plugin_send((rdpSvcPlugin*) rdpdr, data_out);
}
static boolean rdpdr_process_irp(rdpdrPlugin* rdpdr, STREAM* data_in)
static BOOL rdpdr_process_irp(rdpdrPlugin* rdpdr, STREAM* data_in)
{
IRP* irp;

2
channels/rdpsnd/client/MacAudio/rdpsnd_audio_q.c
View File

@ -125,7 +125,7 @@ static void rdpsnd_audio_free(rdpsndDevicePlugin* device)
{
}
static boolean rdpsnd_audio_format_supported(rdpsndDevicePlugin* device, rdpsndFormat* format)
static BOOL rdpsnd_audio_format_supported(rdpsndDevicePlugin* device, rdpsndFormat* format)
{
switch (format->wFormatTag)
{

2
channels/rdpsnd/client/alsa/rdpsnd_alsa.c
View File

@ -264,7 +264,7 @@ static void rdpsnd_alsa_free(rdpsndDevicePlugin* device)
free(alsa);
}
static boolean rdpsnd_alsa_format_supported(rdpsndDevicePlugin* device, rdpsndFormat* format)
static BOOL rdpsnd_alsa_format_supported(rdpsndDevicePlugin* device, rdpsndFormat* format)
{
switch (format->wFormatTag)
{

4
channels/rdpsnd/client/pulse/rdpsnd_pulse.c
View File

@ -80,7 +80,7 @@ static void rdpsnd_pulse_context_state_callback(pa_context* context, void* userd
}
}
static boolean rdpsnd_pulse_connect(rdpsndDevicePlugin* device)
static BOOL rdpsnd_pulse_connect(rdpsndDevicePlugin* device)
{
pa_context_state_t state;
rdpsndPulsePlugin* pulse = (rdpsndPulsePlugin*) device;
@ -365,7 +365,7 @@ static void rdpsnd_pulse_free(rdpsndDevicePlugin* device)
free(pulse);
}
static boolean rdpsnd_pulse_format_supported(rdpsndDevicePlugin* device, rdpsndFormat* format)
static BOOL rdpsnd_pulse_format_supported(rdpsndDevicePlugin* device, rdpsndFormat* format)
{
rdpsndPulsePlugin* pulse = (rdpsndPulsePlugin*)device;

6
channels/rdpsnd/client/rdpsnd_main.c
View File

@ -53,13 +53,13 @@ struct rdpsnd_plugin
int n_supported_formats;
int current_format;
boolean expectingWave;
BOOL expectingWave;
uint8 waveData[4];
uint16 waveDataSize;
uint32 wTimeStamp; /* server timestamp */
uint32 wave_timestamp; /* client timestamp */
boolean is_open;
BOOL is_open;
uint32 close_timestamp;
uint16 fixed_format;
@ -429,7 +429,7 @@ static void rdpsnd_register_device_plugin(rdpsndPlugin* rdpsnd, rdpsndDevicePlug
rdpsnd->device = device;
}
static boolean rdpsnd_load_device_plugin(rdpsndPlugin* rdpsnd, const char* name, RDP_PLUGIN_DATA* data)
static BOOL rdpsnd_load_device_plugin(rdpsndPlugin* rdpsnd, const char* name, RDP_PLUGIN_DATA* data)
{
FREERDP_RDPSND_DEVICE_ENTRY_POINTS entryPoints;
PFREERDP_RDPSND_DEVICE_ENTRY entry;

2
channels/rdpsnd/client/rdpsnd_main.h
View File

@ -26,7 +26,7 @@ typedef struct rdpsnd_plugin rdpsndPlugin;
typedef struct rdpsnd_device_plugin rdpsndDevicePlugin;
typedef boolean (*pcFormatSupported) (rdpsndDevicePlugin* device, rdpsndFormat* format);
typedef BOOL (*pcFormatSupported) (rdpsndDevicePlugin* device, rdpsndFormat* format);
typedef void (*pcOpen) (rdpsndDevicePlugin* device, rdpsndFormat* format, int latency);
typedef void (*pcSetFormat) (rdpsndDevicePlugin* device, rdpsndFormat* format, int latency);
typedef void (*pcSetVolume) (rdpsndDevicePlugin* device, uint32 value);

18
channels/rdpsnd/server/rdpsnd.c
View File

@ -60,7 +60,7 @@ typedef struct _rdpsnd_server
#define RDPSND_PDU_FINISH(_s) \
{ \
boolean _r; \
BOOL _r; \
int _pos; \
_pos = stream_get_pos(_s); \
stream_set_pos(_s, 2); \
@ -71,7 +71,7 @@ typedef struct _rdpsnd_server
return _r; \
}
static boolean rdpsnd_server_send_formats(rdpsnd_server* rdpsnd, STREAM* s)
static BOOL rdpsnd_server_send_formats(rdpsnd_server* rdpsnd, STREAM* s)
{
uint16 i;
@ -109,7 +109,7 @@ static boolean rdpsnd_server_send_formats(rdpsnd_server* rdpsnd, STREAM* s)
RDPSND_PDU_FINISH(s);
}
static boolean rdpsnd_server_recv_formats(rdpsnd_server* rdpsnd, STREAM* s)
static BOOL rdpsnd_server_recv_formats(rdpsnd_server* rdpsnd, STREAM* s)
{
int i;
@ -226,7 +226,7 @@ static void* rdpsnd_server_thread_func(void* arg)
return 0;
}
static boolean rdpsnd_server_initialize(rdpsnd_server_context* context)
static BOOL rdpsnd_server_initialize(rdpsnd_server_context* context)
{
rdpsnd_server* rdpsnd = (rdpsnd_server*) context;
@ -297,10 +297,10 @@ static void rdpsnd_server_select_format(rdpsnd_server_context* context, int clie
freerdp_dsp_context_reset_adpcm(rdpsnd->dsp_context);
}
static boolean rdpsnd_server_send_audio_pdu(rdpsnd_server* rdpsnd)
static BOOL rdpsnd_server_send_audio_pdu(rdpsnd_server* rdpsnd)
{
int size;
boolean r;
BOOL r;
uint8* src;
int frames;
int fill_size;
@ -382,7 +382,7 @@ static boolean rdpsnd_server_send_audio_pdu(rdpsnd_server* rdpsnd)
return r;
}
static boolean rdpsnd_server_send_samples(rdpsnd_server_context* context, const void* buf, int nframes)
static BOOL rdpsnd_server_send_samples(rdpsnd_server_context* context, const void* buf, int nframes)
{
int cframes;
int cframesize;
@ -411,7 +411,7 @@ static boolean rdpsnd_server_send_samples(rdpsnd_server_context* context, const
return TRUE;
}
static boolean rdpsnd_server_set_volume(rdpsnd_server_context* context, int left, int right)
static BOOL rdpsnd_server_set_volume(rdpsnd_server_context* context, int left, int right)
{
rdpsnd_server* rdpsnd = (rdpsnd_server*) context;
STREAM* s = rdpsnd->rdpsnd_pdu;
@ -424,7 +424,7 @@ static boolean rdpsnd_server_set_volume(rdpsnd_server_context* context, int left
RDPSND_PDU_FINISH(s);
}
static boolean rdpsnd_server_close(rdpsnd_server_context* context)
static BOOL rdpsnd_server_close(rdpsnd_server_context* context)
{
rdpsnd_server* rdpsnd = (rdpsnd_server*) context;
STREAM* s = rdpsnd->rdpsnd_pdu;

4
channels/serial/client/serial_main.c
View File

@ -75,7 +75,7 @@ struct _SERIAL_DEVICE
static void serial_abort_single_io(SERIAL_DEVICE* serial, uint32 file_id, uint32 abort_io, uint32 io_status);
static void serial_check_for_events(SERIAL_DEVICE* serial);
static void serial_handle_async_irp(SERIAL_DEVICE* serial, IRP* irp);
static boolean serial_check_fds(SERIAL_DEVICE* serial);
static BOOL serial_check_fds(SERIAL_DEVICE* serial);
static void serial_process_irp_create(SERIAL_DEVICE* serial, IRP* irp)
{
@ -696,7 +696,7 @@ static void serial_set_fds(SERIAL_DEVICE* serial)
}
}
static boolean serial_check_fds(SERIAL_DEVICE* serial)
static BOOL serial_check_fds(SERIAL_DEVICE* serial)
{
if (list_size(serial->pending_irps) == 0)
return 1;

12
channels/serial/client/serial_tty.c
View File

@ -75,7 +75,7 @@
static uint32 tty_write_data(SERIAL_TTY* tty, uint8* data, int len);
static void tty_set_termios(SERIAL_TTY* tty);
static boolean tty_get_termios(SERIAL_TTY* tty);
static BOOL tty_get_termios(SERIAL_TTY* tty);
static int tty_get_error_status();
uint32 serial_tty_control(SERIAL_TTY* tty, uint32 IoControlCode, STREAM* input, STREAM* output, uint32* abort_io)
@ -369,7 +369,7 @@ uint32 serial_tty_control(SERIAL_TTY* tty, uint32 IoControlCode, STREAM* input,
return ret;
}
boolean serial_tty_read(SERIAL_TTY* tty, uint8* buffer, uint32* Length)
BOOL serial_tty_read(SERIAL_TTY* tty, uint8* buffer, uint32* Length)
{
long timeout = 90;
struct termios *ptermios;
@ -418,7 +418,7 @@ boolean serial_tty_read(SERIAL_TTY* tty, uint8* buffer, uint32* Length)
return TRUE;
}
boolean serial_tty_write(SERIAL_TTY* tty, uint8* buffer, uint32 Length)
BOOL serial_tty_write(SERIAL_TTY* tty, uint8* buffer, uint32 Length)
{
ssize_t r;
uint32 event_txempty = Length;
@ -531,10 +531,10 @@ SERIAL_TTY* serial_tty_new(const char* path, uint32 id)
return tty;
}
boolean serial_tty_get_event(SERIAL_TTY* tty, uint32* result)
BOOL serial_tty_get_event(SERIAL_TTY* tty, uint32* result)
{
int bytes;
boolean ret = FALSE;
BOOL ret = FALSE;
DEBUG_SVC("in");
@ -628,7 +628,7 @@ boolean serial_tty_get_event(SERIAL_TTY* tty, uint32* result)
return ret;
}
static boolean tty_get_termios(SERIAL_TTY* tty)
static BOOL tty_get_termios(SERIAL_TTY* tty)
{
speed_t speed;
struct termios *ptermios;

6
channels/serial/client/serial_tty.h
View File

@ -69,10 +69,10 @@ struct _SERIAL_TTY
SERIAL_TTY* serial_tty_new(const char* path, uint32 id);
void serial_tty_free(SERIAL_TTY* tty);
boolean serial_tty_read(SERIAL_TTY* tty, uint8* buffer, uint32* Length);
boolean serial_tty_write(SERIAL_TTY* tty, uint8* buffer, uint32 Length);
BOOL serial_tty_read(SERIAL_TTY* tty, uint8* buffer, uint32* Length);
BOOL serial_tty_write(SERIAL_TTY* tty, uint8* buffer, uint32 Length);
uint32 serial_tty_control(SERIAL_TTY* tty, uint32 IoControlCode, STREAM* input, STREAM* output, uint32* abort_io);
boolean serial_tty_get_event(SERIAL_TTY* tty, uint32* result);
BOOL serial_tty_get_event(SERIAL_TTY* tty, uint32* result);
#endif /* __SERIAL_TTY_H */

6
channels/smartcard/client/scard_main.c
View File

@ -157,7 +157,7 @@ static COMPLETIONIDINFO* scard_mark_duplicate_id(SCARD_DEVICE* scard, uint32 Com
return NULL; /* Either no items in the list or no match. */
}
static boolean scard_check_for_duplicate_id(SCARD_DEVICE* scard, uint32 CompletionId)
static BOOL scard_check_for_duplicate_id(SCARD_DEVICE* scard, uint32 CompletionId)
{
/*
* Search from the end of the LIST for one outstanding "CompletionID"
@ -167,7 +167,7 @@ static boolean scard_check_for_duplicate_id(SCARD_DEVICE* scard, uint32 Complet
*/
LIST_ITEM* item;
COMPLETIONIDINFO* CompletionIdInfo;
boolean duplicate;
BOOL duplicate;
for (item = scard->CompletionIds->tail; item; item = item->prev)
{
@ -201,7 +201,7 @@ static void scard_irp_complete(IRP* irp)
* to be in this file so that "scard_irp_request()" can reference it.
*/
int pos;
boolean duplicate;
BOOL duplicate;
SCARD_DEVICE* scard = (SCARD_DEVICE*)irp->device;
DEBUG_SVC("DeviceId %d FileId %d CompletionId %d", irp->device->id, irp->FileId, irp->CompletionId);

4
channels/smartcard/client/scard_main.h
View File

@ -84,7 +84,7 @@
struct _COMPLETIONIDINFO
{
uint32 ID; /* CompletionID */
boolean duplicate; /* Indicates whether or not this
BOOL duplicate; /* Indicates whether or not this
* CompletionID is a duplicate of an
* earlier, outstanding, CompletionID.
*/
@ -115,7 +115,7 @@ typedef struct _SCARD_DEVICE SCARD_DEVICE;
#define DEBUG_SCARD(fmt, ...) DEBUG_NULL(fmt, ## __VA_ARGS__)
#endif
boolean scard_async_op(IRP*);
BOOL scard_async_op(IRP*);
void scard_device_control(SCARD_DEVICE*, IRP*);
#endif

20
channels/smartcard/client/scard_operations.c
View File

@ -84,7 +84,7 @@
#define WIN_FILE_DEVICE_SMARTCARD 0x00000031
static uint32 sc_output_string(IRP* irp, char *src, boolean wide)
static uint32 sc_output_string(IRP* irp, char *src, BOOL wide)
{
uint8* p;
uint32 len;
@ -179,7 +179,7 @@ static void sc_output_buffer_start(IRP *irp, int length)
sc_output_buffer_start_limit(irp, length, 0x7FFFFFFF);
}
static uint32 sc_input_string(IRP* irp, char **dest, uint32 dataLength, boolean wide)
static uint32 sc_input_string(IRP* irp, char **dest, uint32 dataLength, BOOL wide)
{
char* buffer;
int bufferSize;
@ -215,7 +215,7 @@ static void sc_input_repos(IRP* irp, uint32 read)
stream_seek(irp->input, add);
}
static void sc_input_reader_name(IRP* irp, char **dest, boolean wide)
static void sc_input_reader_name(IRP* irp, char **dest, BOOL wide)
{
uint32 dataLength;
@ -330,7 +330,7 @@ static uint32 handle_IsValidContext(IRP* irp)
return rv;
}
static uint32 handle_ListReaders(IRP* irp, boolean wide)
static uint32 handle_ListReaders(IRP* irp, BOOL wide)
{
uint32 len, rv;
SCARDCONTEXT hContext;
@ -415,7 +415,7 @@ static uint32 handle_ListReaders(IRP* irp, boolean wide)
return rv;
}
static uint32 handle_GetStatusChange(IRP* irp, boolean wide)
static uint32 handle_GetStatusChange(IRP* irp, BOOL wide)
{
LONG rv;
SCARDCONTEXT hContext;
@ -546,7 +546,7 @@ static uint32 handle_Cancel(IRP *irp)
return rv;
}
static uint32 handle_Connect(IRP* irp, boolean wide)
static uint32 handle_Connect(IRP* irp, BOOL wide)
{
LONG rv;
SCARDCONTEXT hContext;
@ -771,7 +771,7 @@ static uint32 handle_State(IRP* irp)
return rv;
}
static DWORD handle_Status(IRP *irp, boolean wide)
static DWORD handle_Status(IRP *irp, BOOL wide)
{
LONG rv;
SCARDHANDLE hCard;
@ -1195,7 +1195,7 @@ typedef struct _SERVER_SCARD_ATRMASK
}
SERVER_SCARD_ATRMASK;
static uint32 handle_LocateCardsByATR(IRP* irp, boolean wide)
static uint32 handle_LocateCardsByATR(IRP* irp, BOOL wide)
{
LONG rv;
int i, j, k;
@ -1287,7 +1287,7 @@ static uint32 handle_LocateCardsByATR(IRP* irp, boolean wide)
{
for (j = 0, rsCur = readerStates; j < readerCount; j++, rsCur++)
{
boolean equal = 1;
BOOL equal = 1;
for (k = 0; k < cur->cbAtr; k++)
{
if ((curAtr->rgbAtr[k] & curAtr->rgbMask[k]) !=
@ -1327,7 +1327,7 @@ static uint32 handle_LocateCardsByATR(IRP* irp, boolean wide)
return rv;
}
boolean scard_async_op(IRP* irp)
BOOL scard_async_op(IRP* irp)
{
uint32 ioctl_code;

8
channels/tsmf/client/alsa/tsmf_alsa.c
View File

@ -48,7 +48,7 @@ typedef struct _TSMFALSAAudioDevice
FREERDP_DSP_CONTEXT* dsp_context;
} TSMFALSAAudioDevice;
static boolean tsmf_alsa_open_device(TSMFALSAAudioDevice* alsa)
static BOOL tsmf_alsa_open_device(TSMFALSAAudioDevice* alsa)
{
int error;
@ -63,7 +63,7 @@ static boolean tsmf_alsa_open_device(TSMFALSAAudioDevice* alsa)
return TRUE;
}
static boolean tsmf_alsa_open(ITSMFAudioDevice* audio, const char* device)
static BOOL tsmf_alsa_open(ITSMFAudioDevice* audio, const char* device)
{
TSMFALSAAudioDevice* alsa = (TSMFALSAAudioDevice*) audio;
@ -80,7 +80,7 @@ static boolean tsmf_alsa_open(ITSMFAudioDevice* audio, const char* device)
return tsmf_alsa_open_device(alsa);
}
static boolean tsmf_alsa_set_format(ITSMFAudioDevice* audio,
static BOOL tsmf_alsa_set_format(ITSMFAudioDevice* audio,
uint32 sample_rate, uint32 channels, uint32 bits_per_sample)
{
int error;
@ -147,7 +147,7 @@ static boolean tsmf_alsa_set_format(ITSMFAudioDevice* audio,
return TRUE;
}
static boolean tsmf_alsa_play(ITSMFAudioDevice* audio, uint8* data, uint32 data_size)
static BOOL tsmf_alsa_play(ITSMFAudioDevice* audio, uint8* data, uint32 data_size)
{
int len;
int error;

24
channels/tsmf/client/ffmpeg/tsmf_ffmpeg.c
View File

@ -55,7 +55,7 @@ typedef struct _TSMFFFmpegDecoder
uint32 decoded_size_max;
} TSMFFFmpegDecoder;
static boolean tsmf_ffmpeg_init_context(ITSMFDecoder* decoder)
static BOOL tsmf_ffmpeg_init_context(ITSMFDecoder* decoder)
{
TSMFFFmpegDecoder* mdecoder = (TSMFFFmpegDecoder*) decoder;
@ -69,7 +69,7 @@ static boolean tsmf_ffmpeg_init_context(ITSMFDecoder* decoder)
return TRUE;
}
static boolean tsmf_ffmpeg_init_video_stream(ITSMFDecoder* decoder, const TS_AM_MEDIA_TYPE* media_type)
static BOOL tsmf_ffmpeg_init_video_stream(ITSMFDecoder* decoder, const TS_AM_MEDIA_TYPE* media_type)
{
TSMFFFmpegDecoder* mdecoder = (TSMFFFmpegDecoder*) decoder;
@ -84,7 +84,7 @@ static boolean tsmf_ffmpeg_init_video_stream(ITSMFDecoder* decoder, const TS_AM_
return TRUE;
}
static boolean tsmf_ffmpeg_init_audio_stream(ITSMFDecoder* decoder, const TS_AM_MEDIA_TYPE* media_type)
static BOOL tsmf_ffmpeg_init_audio_stream(ITSMFDecoder* decoder, const TS_AM_MEDIA_TYPE* media_type)
{
TSMFFFmpegDecoder* mdecoder = (TSMFFFmpegDecoder*) decoder;
@ -106,7 +106,7 @@ static boolean tsmf_ffmpeg_init_audio_stream(ITSMFDecoder* decoder, const TS_AM_
return TRUE;
}
static boolean tsmf_ffmpeg_init_stream(ITSMFDecoder* decoder, const TS_AM_MEDIA_TYPE* media_type)
static BOOL tsmf_ffmpeg_init_stream(ITSMFDecoder* decoder, const TS_AM_MEDIA_TYPE* media_type)
{
TSMFFFmpegDecoder* mdecoder = (TSMFFFmpegDecoder*) decoder;
uint32 size;
@ -175,7 +175,7 @@ static boolean tsmf_ffmpeg_init_stream(ITSMFDecoder* decoder, const TS_AM_MEDIA_
return TRUE;
}
static boolean tsmf_ffmpeg_prepare(ITSMFDecoder* decoder)
static BOOL tsmf_ffmpeg_prepare(ITSMFDecoder* decoder)
{
TSMFFFmpegDecoder* mdecoder = (TSMFFFmpegDecoder*) decoder;
@ -190,7 +190,7 @@ static boolean tsmf_ffmpeg_prepare(ITSMFDecoder* decoder)
return TRUE;
}
static boolean tsmf_ffmpeg_set_format(ITSMFDecoder* decoder, TS_AM_MEDIA_TYPE* media_type)
static BOOL tsmf_ffmpeg_set_format(ITSMFDecoder* decoder, TS_AM_MEDIA_TYPE* media_type)
{
TSMFFFmpegDecoder* mdecoder = (TSMFFFmpegDecoder*) decoder;
@ -260,13 +260,13 @@ static boolean tsmf_ffmpeg_set_format(ITSMFDecoder* decoder, TS_AM_MEDIA_TYPE* m
return TRUE;
}
static boolean tsmf_ffmpeg_decode_video(ITSMFDecoder* decoder, const uint8* data, uint32 data_size, uint32 extensions)
static BOOL tsmf_ffmpeg_decode_video(ITSMFDecoder* decoder, const uint8* data, uint32 data_size, uint32 extensions)
{
TSMFFFmpegDecoder* mdecoder = (TSMFFFmpegDecoder*) decoder;
int decoded;
int len;
AVFrame* frame;
boolean ret = TRUE;
BOOL ret = TRUE;
#if LIBAVCODEC_VERSION_MAJOR < 52 || (LIBAVCODEC_VERSION_MAJOR == 52 && LIBAVCODEC_VERSION_MINOR <= 20)
len = avcodec_decode_video(mdecoder->codec_context, mdecoder->frame, &decoded, data, data_size);
@ -319,7 +319,7 @@ static boolean tsmf_ffmpeg_decode_video(ITSMFDecoder* decoder, const uint8* data
return ret;
}
static boolean tsmf_ffmpeg_decode_audio(ITSMFDecoder* decoder, const uint8* data, uint32 data_size, uint32 extensions)
static BOOL tsmf_ffmpeg_decode_audio(ITSMFDecoder* decoder, const uint8* data, uint32 data_size, uint32 extensions)
{
TSMFFFmpegDecoder* mdecoder = (TSMFFFmpegDecoder*) decoder;
int len;
@ -419,7 +419,7 @@ static boolean tsmf_ffmpeg_decode_audio(ITSMFDecoder* decoder, const uint8* data
return TRUE;
}
static boolean tsmf_ffmpeg_decode(ITSMFDecoder* decoder, const uint8* data, uint32 data_size, uint32 extensions)
static BOOL tsmf_ffmpeg_decode(ITSMFDecoder* decoder, const uint8* data, uint32 data_size, uint32 extensions)
{
TSMFFFmpegDecoder* mdecoder = (TSMFFFmpegDecoder*) decoder;
@ -470,7 +470,7 @@ static uint32 tsmf_ffmpeg_get_decoded_format(ITSMFDecoder* decoder)
}
}
static boolean tsmf_ffmpeg_get_decoded_dimension(ITSMFDecoder* decoder, uint32* width, uint32* height)
static BOOL tsmf_ffmpeg_get_decoded_dimension(ITSMFDecoder* decoder, uint32* width, uint32* height)
{
TSMFFFmpegDecoder* mdecoder = (TSMFFFmpegDecoder*) decoder;
@ -505,7 +505,7 @@ static void tsmf_ffmpeg_free(ITSMFDecoder* decoder)
free(decoder);
}
static boolean initialized = FALSE;
static BOOL initialized = FALSE;
ITSMFDecoder*
TSMFDecoderEntry(void)

12
channels/tsmf/client/gstreamer/tsmf_gstreamer.c
View File

@ -69,7 +69,7 @@ typedef struct _TSMFGstreamerDecoder
GstElement *outsink;
GstElement *aVolume;
boolean paused;
BOOL paused;
uint64 last_sample_end_time;
Display *disp;
@ -319,7 +319,7 @@ static int tsmf_gstreamer_pipeline_set_state(TSMFGstreamerDecoder * mdecoder, Gs
return 0;
}
static boolean tsmf_gstreamer_set_format(ITSMFDecoder * decoder, TS_AM_MEDIA_TYPE * media_type)
static BOOL tsmf_gstreamer_set_format(ITSMFDecoder * decoder, TS_AM_MEDIA_TYPE * media_type)
{
TSMFGstreamerDecoder * mdecoder = (TSMFGstreamerDecoder *) decoder;
if (!mdecoder)
@ -680,7 +680,7 @@ static void tsmf_gstreamer_pipeline_send_end_of_stream(TSMFGstreamerDecoder * md
#ifdef __arm__
/* code from TI to check whether OMX is being lock or not */
static boolean tsmf_gstreamer_pipeline_omx_available()
static BOOL tsmf_gstreamer_pipeline_omx_available()
{
bool ret = TRUE;
int shm_fd = 0;
@ -772,7 +772,7 @@ static void tsmf_gstreamer_clean_up(TSMFGstreamerDecoder * mdecoder)
}
static boolean tsmf_gstreamer_pipeline_build(TSMFGstreamerDecoder * mdecoder)
static BOOL tsmf_gstreamer_pipeline_build(TSMFGstreamerDecoder * mdecoder)
{
if (!mdecoder)
return FALSE;
@ -1036,7 +1036,7 @@ static boolean tsmf_gstreamer_pipeline_build(TSMFGstreamerDecoder * mdecoder)
out_pad = gst_element_get_static_pad(mdecoder->outconv, "sink");
gboolean linkResult = FALSE;
gBOOL linkResult = FALSE;
gst_bin_add(GST_BIN(mdecoder->outbin), mdecoder->outconv);
gst_bin_add(GST_BIN(mdecoder->outbin), mdecoder->outsink);
if (mdecoder->aVolume)
@ -1094,7 +1094,7 @@ static boolean tsmf_gstreamer_pipeline_build(TSMFGstreamerDecoder * mdecoder)
return TRUE;
}
static boolean tsmf_gstreamer_decodeEx(ITSMFDecoder * decoder, const uint8 * data, uint32 data_size, uint32 extensions,
static BOOL tsmf_gstreamer_decodeEx(ITSMFDecoder * decoder, const uint8 * data, uint32 data_size, uint32 extensions,
uint64 start_time, uint64 end_time, uint64 duration)
{
TSMFGstreamerDecoder * mdecoder = (TSMFGstreamerDecoder *) decoder;

12
channels/tsmf/client/pulse/tsmf_pulse.c
View File

@ -67,7 +67,7 @@ static void tsmf_pulse_context_state_callback(pa_context* context, void* userdat
}
}
static boolean tsmf_pulse_connect(TSMFPulseAudioDevice* pulse)
static BOOL tsmf_pulse_connect(TSMFPulseAudioDevice* pulse)
{
pa_context_state_t state;
@ -114,7 +114,7 @@ static boolean tsmf_pulse_connect(TSMFPulseAudioDevice* pulse)
}
}
static boolean tsmf_pulse_open(ITSMFAudioDevice* audio, const char* device)
static BOOL tsmf_pulse_open(ITSMFAudioDevice* audio, const char* device)
{
TSMFPulseAudioDevice* pulse = (TSMFPulseAudioDevice*) audio;
@ -198,7 +198,7 @@ static void tsmf_pulse_stream_request_callback(pa_stream* stream, size_t length,
pa_threaded_mainloop_signal(pulse->mainloop, 0);
}
static boolean tsmf_pulse_close_stream(TSMFPulseAudioDevice* pulse)
static BOOL tsmf_pulse_close_stream(TSMFPulseAudioDevice* pulse)
{
if (!pulse->context || !pulse->stream)
return FALSE;
@ -217,7 +217,7 @@ static boolean tsmf_pulse_close_stream(TSMFPulseAudioDevice* pulse)
return TRUE;
}
static boolean tsmf_pulse_open_stream(TSMFPulseAudioDevice* pulse)
static BOOL tsmf_pulse_open_stream(TSMFPulseAudioDevice* pulse)
{
pa_stream_state_t state;
pa_buffer_attr buffer_attr = { 0 };
@ -283,7 +283,7 @@ static boolean tsmf_pulse_open_stream(TSMFPulseAudioDevice* pulse)
}
}
static boolean tsmf_pulse_set_format(ITSMFAudioDevice* audio,
static BOOL tsmf_pulse_set_format(ITSMFAudioDevice* audio,
uint32 sample_rate, uint32 channels, uint32 bits_per_sample)
{
TSMFPulseAudioDevice* pulse = (TSMFPulseAudioDevice*) audio;
@ -298,7 +298,7 @@ static boolean tsmf_pulse_set_format(ITSMFAudioDevice* audio,
return tsmf_pulse_open_stream(pulse);
}
static boolean tsmf_pulse_play(ITSMFAudioDevice* audio, uint8* data, uint32 data_size)
static BOOL tsmf_pulse_play(ITSMFAudioDevice* audio, uint8* data, uint32 data_size)
{
TSMFPulseAudioDevice* pulse = (TSMFPulseAudioDevice*) audio;
uint8* src;

6
channels/tsmf/client/tsmf_audio.h
View File

@ -27,11 +27,11 @@ typedef struct _ITSMFAudioDevice ITSMFAudioDevice;
struct _ITSMFAudioDevice
{
/* Open the audio device. */
boolean (*Open) (ITSMFAudioDevice* audio, const char* device);
BOOL (*Open) (ITSMFAudioDevice* audio, const char* device);
/* Set the audio data format. */
boolean (*SetFormat) (ITSMFAudioDevice* audio, uint32 sample_rate, uint32 channels, uint32 bits_per_sample);
BOOL (*SetFormat) (ITSMFAudioDevice* audio, uint32 sample_rate, uint32 channels, uint32 bits_per_sample);
/* Play audio data. */
boolean (*Play) (ITSMFAudioDevice* audio, uint8* data, uint32 data_size);
BOOL (*Play) (ITSMFAudioDevice* audio, uint8* data, uint32 data_size);
/* Get the latency of the last written sample, in 100ns */
uint64 (*GetLatency) (ITSMFAudioDevice* audio);
/* Change the playback volume level */

10
channels/tsmf/client/tsmf_codec.c
View File

@ -284,7 +284,7 @@ static void tsmf_print_guid(const uint8* guid)
}
/* http://msdn.microsoft.com/en-us/library/dd318229.aspx */
static uint32 tsmf_codec_parse_BITMAPINFOHEADER(TS_AM_MEDIA_TYPE* mediatype, STREAM* s, boolean bypass)
static uint32 tsmf_codec_parse_BITMAPINFOHEADER(TS_AM_MEDIA_TYPE* mediatype, STREAM* s, BOOL bypass)
{
uint32 biSize;
uint32 biWidth;
@ -367,11 +367,11 @@ typedef struct tagVIDEOINFOHEADER {
return 48;
}
boolean tsmf_codec_parse_media_type(TS_AM_MEDIA_TYPE* mediatype, STREAM* s)
BOOL tsmf_codec_parse_media_type(TS_AM_MEDIA_TYPE* mediatype, STREAM* s)
{
int i;
uint32 cbFormat;
boolean ret = TRUE;
BOOL ret = TRUE;
memset(mediatype, 0, sizeof(TS_AM_MEDIA_TYPE));
@ -514,10 +514,10 @@ boolean tsmf_codec_parse_media_type(TS_AM_MEDIA_TYPE* mediatype, STREAM* s)
return ret;
}
boolean tsmf_codec_check_media_type(STREAM* s)
BOOL tsmf_codec_check_media_type(STREAM* s)
{
uint8* m;
boolean ret;
BOOL ret;
TS_AM_MEDIA_TYPE mediatype;
stream_get_mark(s, m);

4
channels/tsmf/client/tsmf_codec.h
View File

@ -22,8 +22,8 @@
#include "tsmf_types.h"
boolean tsmf_codec_parse_media_type(TS_AM_MEDIA_TYPE* mediatype, STREAM* s);
boolean tsmf_codec_check_media_type(STREAM* s);
BOOL tsmf_codec_parse_media_type(TS_AM_MEDIA_TYPE* mediatype, STREAM* s);
BOOL tsmf_codec_check_media_type(STREAM* s);
#endif

6
channels/tsmf/client/tsmf_decoder.h
View File

@ -36,15 +36,15 @@ typedef struct _ITSMFDecoder ITSMFDecoder;
struct _ITSMFDecoder
{
/* Set the decoder format. Return true if supported. */
boolean (*SetFormat) (ITSMFDecoder* decoder, TS_AM_MEDIA_TYPE* media_type);
BOOL (*SetFormat) (ITSMFDecoder* decoder, TS_AM_MEDIA_TYPE* media_type);
/* Decode a sample. */
boolean (*Decode) (ITSMFDecoder* decoder, const uint8* data, uint32 data_size, uint32 extensions);
BOOL (*Decode) (ITSMFDecoder* decoder, const uint8* data, uint32 data_size, uint32 extensions);
/* Get the decoded data */
uint8* (*GetDecodedData) (ITSMFDecoder* decoder, uint32* size);
/* Get the pixel format of decoded video frame */
uint32 (*GetDecodedFormat) (ITSMFDecoder* decoder);
/* Get the width and height of decoded video frame */
boolean (*GetDecodedDimension) (ITSMFDecoder* decoder, uint32* width, uint32* height);
BOOL (*GetDecodedDimension) (ITSMFDecoder* decoder, uint32* width, uint32* height);
/* Free the decoder */
void (*Free) (ITSMFDecoder * decoder);
/* Optional Contol function */

2
channels/tsmf/client/tsmf_ifman.h
View File

@ -34,7 +34,7 @@ struct _TSMF_IFMAN
STREAM* input;
uint32 input_size;
STREAM* output;
boolean output_pending;
BOOL output_pending;
uint32 output_interface_id;
};

2
channels/tsmf/client/tsmf_main.c
View File

@ -96,7 +96,7 @@ void tsmf_playback_ack(IWTSVirtualChannelCallback* pChannelCallback,
stream_free(s);
}
boolean tsmf_push_event(IWTSVirtualChannelCallback* pChannelCallback,
BOOL tsmf_push_event(IWTSVirtualChannelCallback* pChannelCallback,
RDP_EVENT* event)
{
int error;

2
channels/tsmf/client/tsmf_main.h
View File

@ -22,7 +22,7 @@
void tsmf_playback_ack(IWTSVirtualChannelCallback* pChannelCallback,
uint32 message_id, uint64 duration, uint32 data_size);
boolean tsmf_push_event(IWTSVirtualChannelCallback* pChannelCallback,
BOOL tsmf_push_event(IWTSVirtualChannelCallback* pChannelCallback,
RDP_EVENT* event);
#endif

4
channels/tsmf/client/tsmf_media.c
View File

@ -154,7 +154,7 @@ static TSMF_SAMPLE* tsmf_stream_pop_sample(TSMF_STREAM* stream, int sync)
TSMF_STREAM* s;
LIST_ITEM* item;
TSMF_SAMPLE* sample;
boolean pending = FALSE;
BOOL pending = FALSE;
TSMF_PRESENTATION* presentation = stream->presentation;
if (list_size(stream->sample_list) == 0)
@ -455,7 +455,7 @@ static void tsmf_sample_playback_audio(TSMF_SAMPLE* sample)
static void tsmf_sample_playback(TSMF_SAMPLE* sample)
{
boolean ret = FALSE;
BOOL ret = FALSE;
uint32 width;
uint32 height;
uint32 pixfmt = 0;

2
channels/urbdrc/client/urbdrc_main.c
View File

@ -1031,7 +1031,7 @@ static int urbdrc_load_udevman_plugin(IWTSPlugin* pPlugin, const char* name, RDP
static int urbdrc_process_plugin_data(IWTSPlugin* pPlugin, RDP_PLUGIN_DATA* data)
{
boolean ret;
BOOL ret;
if (data->data[0] && (strcmp((char*)data->data[0], "urbdrc") == 0 || strstr((char*) data->data[0], "/urbdrc.") != NULL))
{

6
client/DirectFB/df_event.c
View File

@ -154,7 +154,7 @@ void df_keyboard_init()
}
void df_send_mouse_button_event(rdpInput* input, boolean down, uint32 button, uint16 x, uint16 y)
void df_send_mouse_button_event(rdpInput* input, BOOL down, uint32 button, uint16 x, uint16 y)
{
uint16 flags;
@ -188,7 +188,7 @@ void df_send_mouse_wheel_event(rdpInput* input, sint16 axisrel, uint16 x, uint16
input->MouseEvent(input, flags, x, y);
}
void df_send_keyboard_event(rdpInput* input, boolean down, uint8 keycode, uint8 function)
void df_send_keyboard_event(rdpInput* input, BOOL down, uint8 keycode, uint8 function)
{
uint8 vkcode;
RDP_SCANCODE rdp_scancode;
@ -205,7 +205,7 @@ void df_send_keyboard_event(rdpInput* input, boolean down, uint8 keycode, uint8
freerdp_input_send_keyboard_event_ex(input, down, rdp_scancode);
}
boolean df_event_process(freerdp* instance, DFBEvent* event)
BOOL df_event_process(freerdp* instance, DFBEvent* event)
{
int flags;
rdpGdi* gdi;

2
client/DirectFB/df_event.h
View File

@ -23,6 +23,6 @@
#include "dfreerdp.h"
void df_keyboard_init();
boolean df_event_process(freerdp* instance, DFBEvent* event);
BOOL df_event_process(freerdp* instance, DFBEvent* event);
#endif /* __DF_EVENT_H */

12
client/DirectFB/dfreerdp.c
View File

@ -85,7 +85,7 @@ void df_end_paint(rdpContext* context)
dfi->primary->Blit(dfi->primary, dfi->surface, &(dfi->update_rect), dfi->update_rect.x, dfi->update_rect.y);
}
boolean df_get_fds(freerdp* instance, void** rfds, int* rcount, void** wfds, int* wcount)
BOOL df_get_fds(freerdp* instance, void** rfds, int* rcount, void** wfds, int* wcount)
{
dfInfo* dfi;
@ -97,7 +97,7 @@ boolean df_get_fds(freerdp* instance, void** rfds, int* rcount, void** wfds, int
return TRUE;
}
boolean df_check_fds(freerdp* instance, fd_set* set)
BOOL df_check_fds(freerdp* instance, fd_set* set)
{
dfInfo* dfi;
@ -112,10 +112,10 @@ boolean df_check_fds(freerdp* instance, fd_set* set)
return TRUE;
}
boolean df_pre_connect(freerdp* instance)
BOOL df_pre_connect(freerdp* instance)
{
dfInfo* dfi;
boolean bitmap_cache;
BOOL bitmap_cache;
dfContext* context;
rdpSettings* settings;
@ -164,7 +164,7 @@ boolean df_pre_connect(freerdp* instance)
return TRUE;
}
boolean df_post_connect(freerdp* instance)
BOOL df_post_connect(freerdp* instance)
{
rdpGdi* gdi;
dfInfo* dfi;
@ -231,7 +231,7 @@ static int df_process_plugin_args(rdpSettings* settings, const char* name,
return 1;
}
boolean df_verify_certificate(freerdp* instance, char* subject, char* issuer, char* fingerprint)
BOOL df_verify_certificate(freerdp* instance, char* subject, char* issuer, char* fingerprint)
{
printf("Certificate details:\n");
printf("\tSubject: %s\n", subject);

14
client/Mac/MRDPRailView.h
View File

@ -11,9 +11,9 @@
NSBitmapImageRep * bmiRep;
NSPoint savedDragLocation;
char * pixelData;
boolean mouseInClientArea;
boolean titleBarClicked;
boolean gestureEventInProgress;
BOOL mouseInClientArea;
BOOL titleBarClicked;
BOOL gestureEventInProgress;
int width;
int height;
int savedWindowId;
@ -31,15 +31,15 @@
int kdcapslock;
@public
boolean isMoveSizeInProgress;
boolean saveInitialDragLoc;
boolean skipMoveWindowOnce;
BOOL isMoveSizeInProgress;
BOOL saveInitialDragLoc;
BOOL skipMoveWindowOnce;
int localMoveType;
}
@property (assign) MRDPRailWindow * mrdpRailWindow;
@property (assign) int windowIndex;
@property (assign) boolean activateWindow;
@property (assign) BOOL activateWindow;
- (void) windowDidMove:(NSNotification *) notification;
- (void) updateDisplay;

2
client/Mac/MRDPRailView.m
View File

@ -18,7 +18,7 @@ extern struct kkey g_keys[];
- (void) updateDisplay
{
boolean moveWindow = NO;
BOOL moveWindow = NO;
NSRect srcRectOuter;
NSRect destRectOuter;

18
client/Mac/MRDPView.h
View File

@ -43,13 +43,13 @@
// RAIL stuff
MRDPWindow *currentWindow;
NSPoint savedDragLocation;
boolean mouseInClientArea;
boolean isRemoteApp;
boolean firstCreateWindow;
boolean isMoveSizeInProgress;
boolean skipResizeOnce;
boolean saveInitialDragLoc;
boolean skipMoveWindowOnce;
BOOL mouseInClientArea;
BOOL isRemoteApp;
BOOL firstCreateWindow;
BOOL isMoveSizeInProgress;
BOOL skipResizeOnce;
BOOL saveInitialDragLoc;
BOOL skipMoveWindowOnce;
// store state info for some keys
int kdlshift;
@ -99,8 +99,8 @@ void pointer_set(rdpContext* context, rdpPointer* pointer);
void pointer_setNull(rdpContext* context);
void pointer_setDefault(rdpContext* context);
int rdp_connect();
boolean mac_pre_connect(freerdp *inst);
boolean mac_post_connect(freerdp *inst);
BOOL mac_pre_connect(freerdp *inst);
BOOL mac_post_connect(freerdp *inst);
void mac_context_new(freerdp *inst, rdpContext *context);
void mac_context_free(freerdp *inst, rdpContext *context);
void mac_set_bounds(rdpContext *context, rdpBounds *bounds);

12
client/Mac/MRDPView.m
View File

@ -1014,7 +1014,7 @@ int rdp_connect()
* @return true if successful. false otherwise.
************************************************************************/
boolean mac_pre_connect(freerdp *inst)
BOOL mac_pre_connect(freerdp *inst)
{
char *cptr;
int len;
@ -1174,7 +1174,7 @@ boolean mac_pre_connect(freerdp *inst)
// in order to achieve this, we need to modify the cmd line args entered by the user;
if (g_mrdpview->isRemoteApp) {
boolean gotGeometry = NO;
BOOL gotGeometry = NO;
// get dimensions of screen that has keyboard focus;
// we use these dimensions when connecting to RDP server
@ -1238,7 +1238,7 @@ boolean mac_pre_connect(freerdp *inst)
*
************************************************************************/
boolean mac_post_connect(freerdp *inst)
BOOL mac_post_connect(freerdp *inst)
{
uint32 flags;
rdpPointer rdp_pointer;
@ -1915,9 +1915,9 @@ void mac_process_rail_event(freerdp *inst, RDP_EVENT *event)
void mac_rail_CreateWindow(rdpRail *rail, rdpWindow *window)
{
boolean centerWindow = NO;
boolean moveWindow = NO;
boolean displayAsModal = NO;
BOOL centerWindow = NO;
BOOL moveWindow = NO;
BOOL displayAsModal = NO;
NSMutableArray * ma = g_mrdpview->windows;
// make sure window fits resolution

4
client/Sample/freerdp.c
View File

@ -144,7 +144,7 @@ void tf_process_channel_event(rdpChannels* channels, freerdp* instance)
}
}
boolean tf_pre_connect(freerdp* instance)
BOOL tf_pre_connect(freerdp* instance)
{
tfInfo* tfi;
tfContext* context;
@ -184,7 +184,7 @@ boolean tf_pre_connect(freerdp* instance)
return TRUE;
}
boolean tf_post_connect(freerdp* instance)
BOOL tf_post_connect(freerdp* instance)
{
rdpGdi* gdi;

8
client/Windows/wf_cliprdr.c
View File

@ -83,22 +83,22 @@ void wf_process_cliprdr_event(wfInfo* wfi, RDP_EVENT* event)
}
}
boolean wf_cliprdr_process_selection_notify(wfInfo* wfi, HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
BOOL wf_cliprdr_process_selection_notify(wfInfo* wfi, HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
{
return TRUE;
}
boolean wf_cliprdr_process_selection_request(wfInfo* wfi, HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
BOOL wf_cliprdr_process_selection_request(wfInfo* wfi, HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
{
return TRUE;
}
boolean wf_cliprdr_process_selection_clear(wfInfo* wfi, HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
BOOL wf_cliprdr_process_selection_clear(wfInfo* wfi, HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
{
return TRUE;
}
boolean wf_cliprdr_process_property_notify(wfInfo* wfi, HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
BOOL wf_cliprdr_process_property_notify(wfInfo* wfi, HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
{
return TRUE;
}

8
client/Windows/wf_cliprdr.h
View File

@ -24,10 +24,10 @@
void wf_cliprdr_init(wfInfo* wfi, rdpChannels* chanman);
void wf_cliprdr_uninit(wfInfo* wfi);
void wf_process_cliprdr_event(wfInfo* wfi, RDP_EVENT* event);
boolean wf_cliprdr_process_selection_notify(wfInfo* wfi, HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
boolean wf_cliprdr_process_selection_request(wfInfo* wfi, HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
boolean wf_cliprdr_process_selection_clear(wfInfo* wfi, HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
boolean wf_cliprdr_process_property_notify(wfInfo* wfi, HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
BOOL wf_cliprdr_process_selection_notify(wfInfo* wfi, HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
BOOL wf_cliprdr_process_selection_request(wfInfo* wfi, HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
BOOL wf_cliprdr_process_selection_clear(wfInfo* wfi, HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
BOOL wf_cliprdr_process_property_notify(wfInfo* wfi, HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
void wf_cliprdr_check_owner(wfInfo* wfi);
#endif /* __WF_CLIPRDR_H */

2
client/Windows/wf_event.c
View File

@ -127,7 +127,7 @@ LRESULT CALLBACK wf_event_proc(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam
int x, y, w, h;
PAINTSTRUCT ps;
rdpInput* input;
boolean processed;
BOOL processed;
processed = TRUE;
ptr = GetWindowLongPtr(hWnd, GWLP_USERDATA);

2
client/Windows/wf_gdi.c
View File

@ -59,7 +59,7 @@ const uint8 wf_rop2_table[] =
R2_WHITE, /* 1 */
};
boolean wf_set_rop2(HDC hdc, int rop2)
BOOL wf_set_rop2(HDC hdc, int rop2)
{
if ((rop2 < 0x01) || (rop2 > 0x10))
{

6
client/Windows/wf_graphics.c
View File

@ -143,7 +143,7 @@ void wf_Bitmap_Paint(rdpContext* context, rdpBitmap* bitmap)
}
void wf_Bitmap_Decompress(rdpContext* context, rdpBitmap* bitmap,
uint8* data, int width, int height, int bpp, int length, boolean compressed, int codec_id)
uint8* data, int width, int height, int bpp, int length, BOOL compressed, int codec_id)
{
uint16 size;
@ -156,7 +156,7 @@ void wf_Bitmap_Decompress(rdpContext* context, rdpBitmap* bitmap,
if (compressed)
{
boolean status;
BOOL status;
status = bitmap_decompress(data, bitmap->data, width, height, length, bpp, bpp);
@ -175,7 +175,7 @@ void wf_Bitmap_Decompress(rdpContext* context, rdpBitmap* bitmap,
bitmap->bpp = bpp;
}
void wf_Bitmap_SetSurface(rdpContext* context, rdpBitmap* bitmap, boolean primary)
void wf_Bitmap_SetSurface(rdpContext* context, rdpBitmap* bitmap, BOOL primary)
{
wfInfo* wfi = ((wfContext*) context)->wfi;

2
client/Windows/wf_rail.c
View File

@ -41,7 +41,7 @@ void wf_rail_send_client_system_command(wfInfo* wfi, uint32 windowId, uint16 com
{
}
void wf_rail_send_activate(wfInfo* wfi, HWND window, boolean enabled)
void wf_rail_send_activate(wfInfo* wfi, HWND window, BOOL enabled)
{
}

2
client/Windows/wf_rail.h
View File

@ -24,7 +24,7 @@
void wf_rail_paint(wfInfo* wfi, rdpRail* rail, sint32 uleft, sint32 utop, uint32 uright, uint32 ubottom);
void wf_rail_register_callbacks(wfInfo* wfi, rdpRail* rail);
void wf_rail_send_client_system_command(wfInfo* wfi, uint32 windowId, uint16 command);
void wf_rail_send_activate(wfInfo* wfi, HWND window, boolean enabled);
void wf_rail_send_activate(wfInfo* wfi, HWND window, BOOL enabled);
void wf_process_rail_event(wfInfo* wfi, rdpChannels* chanman, RDP_EVENT* event);
void wf_rail_adjust_position(wfInfo* wfi, rdpWindow *window);
void wf_rail_end_local_move(wfInfo* wfi, rdpWindow *window);

10
client/Windows/wfreerdp.c
View File

@ -139,7 +139,7 @@ void wf_hw_end_paint(rdpContext* context)
}
boolean wf_pre_connect(freerdp* instance)
BOOL wf_pre_connect(freerdp* instance)
{
int i1;
wfInfo* wfi;
@ -262,7 +262,7 @@ uint32 wfi_detect_cpu()
return cpu_opt;
}
boolean wf_post_connect(freerdp* instance)
BOOL wf_post_connect(freerdp* instance)
{
rdpGdi* gdi;
wfInfo* wfi;
@ -395,7 +395,7 @@ boolean wf_post_connect(freerdp* instance)
return TRUE;
}
boolean wf_verify_certificate(freerdp* instance, char* subject, char* issuer, char* fingerprint)
BOOL wf_verify_certificate(freerdp* instance, char* subject, char* issuer, char* fingerprint)
{
#if 0
DWORD mode;
@ -441,12 +441,12 @@ void wf_process_channel_event(rdpChannels* channels, freerdp* instance)
freerdp_event_free(event);
}
boolean wf_get_fds(freerdp* instance, void** rfds, int* rcount, void** wfds, int* wcount)
BOOL wf_get_fds(freerdp* instance, void** rfds, int* rcount, void** wfds, int* wcount)
{
return TRUE;
}
boolean wf_check_fds(freerdp* instance)
BOOL wf_check_fds(freerdp* instance)
{
return TRUE;
}

2
client/Windows/wfreerdp.h
View File

@ -88,7 +88,7 @@ struct wf_info
RFX_CONTEXT* rfx_context;
NSC_CONTEXT* nsc_context;
boolean sw_gdi;
BOOL sw_gdi;
};
#endif

22
client/X11/xf_cliprdr.c
View File

@ -65,11 +65,11 @@ struct clipboard_context
/* client->server data */
Window owner;
int request_index;
boolean sync;
BOOL sync;
/* INCR mechanism */
Atom incr_atom;
boolean incr_starts;
BOOL incr_starts;
uint8* incr_data;
int incr_data_length;
};
@ -230,7 +230,7 @@ static void be2le(uint8* data, int size)
}
}
static boolean xf_cliprdr_is_self_owned(xfInfo* xfi)
static BOOL xf_cliprdr_is_self_owned(xfInfo* xfi)
{
Atom type;
uint32 id = 0;
@ -638,7 +638,7 @@ static uint8* xf_cliprdr_process_requested_html(uint8* data, int* size)
return outbuf;
}
static void xf_cliprdr_process_requested_data(xfInfo* xfi, boolean has_data, uint8* data, int size)
static void xf_cliprdr_process_requested_data(xfInfo* xfi, BOOL has_data, uint8* data, int size)
{
uint8* outbuf;
clipboardContext* cb = (clipboardContext*) xfi->clipboard_context;
@ -691,12 +691,12 @@ static void xf_cliprdr_process_requested_data(xfInfo* xfi, boolean has_data, uin
xf_cliprdr_send_format_list(xfi);
}
static boolean xf_cliprdr_get_requested_data(xfInfo* xfi, Atom target)
static BOOL xf_cliprdr_get_requested_data(xfInfo* xfi, Atom target)
{
Atom type;
int format;
uint8* data = NULL;
boolean has_data = FALSE;
BOOL has_data = FALSE;
unsigned long length, bytes_left, dummy;
clipboardContext* cb = (clipboardContext*) xfi->clipboard_context;
@ -1039,7 +1039,7 @@ void xf_process_cliprdr_event(xfInfo* xfi, RDP_EVENT* event)
}
}
boolean xf_cliprdr_process_selection_notify(xfInfo* xfi, XEvent* xevent)
BOOL xf_cliprdr_process_selection_notify(xfInfo* xfi, XEvent* xevent)
{
clipboardContext* cb = (clipboardContext*) xfi->clipboard_context;
@ -1063,7 +1063,7 @@ boolean xf_cliprdr_process_selection_notify(xfInfo* xfi, XEvent* xevent)
}
}
boolean xf_cliprdr_process_selection_request(xfInfo* xfi, XEvent* xevent)
BOOL xf_cliprdr_process_selection_request(xfInfo* xfi, XEvent* xevent)
{
int i;
int fmt;
@ -1072,7 +1072,7 @@ boolean xf_cliprdr_process_selection_request(xfInfo* xfi, XEvent* xevent)
XEvent* respond;
uint32 alt_format;
uint8* data = NULL;
boolean delay_respond;
BOOL delay_respond;
unsigned long length, bytes_left;
clipboardContext* cb = (clipboardContext*) xfi->clipboard_context;
@ -1174,7 +1174,7 @@ boolean xf_cliprdr_process_selection_request(xfInfo* xfi, XEvent* xevent)
return TRUE;
}
boolean xf_cliprdr_process_selection_clear(xfInfo* xfi, XEvent* xevent)
BOOL xf_cliprdr_process_selection_clear(xfInfo* xfi, XEvent* xevent)
{
clipboardContext* cb = (clipboardContext*) xfi->clipboard_context;
@ -1186,7 +1186,7 @@ boolean xf_cliprdr_process_selection_clear(xfInfo* xfi, XEvent* xevent)
return TRUE;
}
boolean xf_cliprdr_process_property_notify(xfInfo* xfi, XEvent* xevent)
BOOL xf_cliprdr_process_property_notify(xfInfo* xfi, XEvent* xevent)
{
clipboardContext* cb = (clipboardContext*) xfi->clipboard_context;

8
client/X11/xf_cliprdr.h
View File

@ -25,10 +25,10 @@
void xf_cliprdr_init(xfInfo* xfi, rdpChannels* chanman);
void xf_cliprdr_uninit(xfInfo* xfi);
void xf_process_cliprdr_event(xfInfo* xfi, RDP_EVENT* event);
boolean xf_cliprdr_process_selection_notify(xfInfo* xfi, XEvent* xevent);
boolean xf_cliprdr_process_selection_request(xfInfo* xfi, XEvent* xevent);
boolean xf_cliprdr_process_selection_clear(xfInfo* xfi, XEvent* xevent);
boolean xf_cliprdr_process_property_notify(xfInfo* xfi, XEvent* xevent);
BOOL xf_cliprdr_process_selection_notify(xfInfo* xfi, XEvent* xevent);
BOOL xf_cliprdr_process_selection_request(xfInfo* xfi, XEvent* xevent);
BOOL xf_cliprdr_process_selection_clear(xfInfo* xfi, XEvent* xevent);
BOOL xf_cliprdr_process_property_notify(xfInfo* xfi, XEvent* xevent);
void xf_cliprdr_check_owner(xfInfo* xfi);
#ifdef WITH_DEBUG_X11_CLIPRDR

60
client/X11/xf_event.c
View File

@ -73,7 +73,7 @@ static const char* const X11_EVENT_STRINGS[] =
};
#endif
static boolean xf_event_Expose(xfInfo* xfi, XEvent* event, boolean app)
static BOOL xf_event_Expose(xfInfo* xfi, XEvent* event, BOOL app)
{
int x, y;
int w, h;
@ -105,13 +105,13 @@ static boolean xf_event_Expose(xfInfo* xfi, XEvent* event, boolean app)
return TRUE;
}
static boolean xf_event_VisibilityNotify(xfInfo* xfi, XEvent* event, boolean app)
static BOOL xf_event_VisibilityNotify(xfInfo* xfi, XEvent* event, BOOL app)
{
xfi->unobscured = event->xvisibility.state == VisibilityUnobscured;
return TRUE;
}
static boolean xf_event_MotionNotify(xfInfo* xfi, XEvent* event, boolean app)
static BOOL xf_event_MotionNotify(xfInfo* xfi, XEvent* event, BOOL app)
{
rdpInput* input;
int x, y;
@ -150,13 +150,13 @@ static boolean xf_event_MotionNotify(xfInfo* xfi, XEvent* event, boolean app)
return TRUE;
}
static boolean xf_event_ButtonPress(xfInfo* xfi, XEvent* event, boolean app)
static BOOL xf_event_ButtonPress(xfInfo* xfi, XEvent* event, BOOL app)
{
int x, y;
int flags;
Window childWindow;
boolean wheel;
boolean extended;
BOOL wheel;
BOOL extended;
rdpInput* input;
input = xfi->instance->input;
@ -253,12 +253,12 @@ static boolean xf_event_ButtonPress(xfInfo* xfi, XEvent* event, boolean app)
return TRUE;
}
static boolean xf_event_ButtonRelease(xfInfo* xfi, XEvent* event, boolean app)
static BOOL xf_event_ButtonRelease(xfInfo* xfi, XEvent* event, BOOL app)
{
int x, y;
int flags;
Window childWindow;
boolean extended;
BOOL extended;
rdpInput* input;
input = xfi->instance->input;
@ -335,7 +335,7 @@ static boolean xf_event_ButtonRelease(xfInfo* xfi, XEvent* event, boolean app)
return TRUE;
}
static boolean xf_event_KeyPress(xfInfo* xfi, XEvent* event, boolean app)
static BOOL xf_event_KeyPress(xfInfo* xfi, XEvent* event, BOOL app)
{
KeySym keysym;
char str[256];
@ -352,7 +352,7 @@ static boolean xf_event_KeyPress(xfInfo* xfi, XEvent* event, boolean app)
return TRUE;
}
static boolean xf_event_KeyRelease(xfInfo* xfi, XEvent* event, boolean app)
static BOOL xf_event_KeyRelease(xfInfo* xfi, XEvent* event, BOOL app)
{
XEvent next_event;
@ -374,7 +374,7 @@ static boolean xf_event_KeyRelease(xfInfo* xfi, XEvent* event, boolean app)
return TRUE;
}
static boolean xf_event_FocusIn(xfInfo* xfi, XEvent* event, boolean app)
static BOOL xf_event_FocusIn(xfInfo* xfi, XEvent* event, BOOL app)
{
if (event->xfocus.mode == NotifyGrab)
return TRUE;
@ -405,7 +405,7 @@ static boolean xf_event_FocusIn(xfInfo* xfi, XEvent* event, boolean app)
return TRUE;
}
static boolean xf_event_FocusOut(xfInfo* xfi, XEvent* event, boolean app)
static BOOL xf_event_FocusOut(xfInfo* xfi, XEvent* event, BOOL app)
{
if (event->xfocus.mode == NotifyUngrab)
return TRUE;
@ -423,7 +423,7 @@ static boolean xf_event_FocusOut(xfInfo* xfi, XEvent* event, boolean app)
return TRUE;
}
static boolean xf_event_MappingNotify(xfInfo* xfi, XEvent* event, boolean app)
static BOOL xf_event_MappingNotify(xfInfo* xfi, XEvent* event, BOOL app)
{
if (event->xmapping.request == MappingModifier)
{
@ -434,7 +434,7 @@ static boolean xf_event_MappingNotify(xfInfo* xfi, XEvent* event, boolean app)
return TRUE;
}
static boolean xf_event_ClientMessage(xfInfo* xfi, XEvent* event, boolean app)
static BOOL xf_event_ClientMessage(xfInfo* xfi, XEvent* event, BOOL app)
{
if ((event->xclient.message_type == xfi->WM_PROTOCOLS)
&& ((Atom) event->xclient.data.l[0] == xfi->WM_DELETE_WINDOW))
@ -464,7 +464,7 @@ static boolean xf_event_ClientMessage(xfInfo* xfi, XEvent* event, boolean app)
return TRUE;
}
static boolean xf_event_EnterNotify(xfInfo* xfi, XEvent* event, boolean app)
static BOOL xf_event_EnterNotify(xfInfo* xfi, XEvent* event, BOOL app)
{
if (app != TRUE)
{
@ -495,7 +495,7 @@ static boolean xf_event_EnterNotify(xfInfo* xfi, XEvent* event, boolean app)
return TRUE;
}
static boolean xf_event_LeaveNotify(xfInfo* xfi, XEvent* event, boolean app)
static BOOL xf_event_LeaveNotify(xfInfo* xfi, XEvent* event, BOOL app)
{
if (app != TRUE)
{
@ -506,7 +506,7 @@ static boolean xf_event_LeaveNotify(xfInfo* xfi, XEvent* event, boolean app)
return TRUE;
}
static boolean xf_event_ConfigureNotify(xfInfo* xfi, XEvent* event, boolean app)
static BOOL xf_event_ConfigureNotify(xfInfo* xfi, XEvent* event, BOOL app)
{
rdpWindow* window;
rdpRail* rail = ((rdpContext*) xfi->context)->rail;
@ -564,7 +564,7 @@ static boolean xf_event_ConfigureNotify(xfInfo* xfi, XEvent* event, boolean app)
return True;
}
static boolean xf_event_MapNotify(xfInfo* xfi, XEvent* event, boolean app)
static BOOL xf_event_MapNotify(xfInfo* xfi, XEvent* event, BOOL app)
{
RECTANGLE_16 rect;
rdpWindow* window;
@ -602,7 +602,7 @@ static boolean xf_event_MapNotify(xfInfo* xfi, XEvent* event, boolean app)
return TRUE;
}
static boolean xf_event_UnmapNotify(xfInfo* xfi, XEvent* event, boolean app)
static BOOL xf_event_UnmapNotify(xfInfo* xfi, XEvent* event, BOOL app)
{
rdpWindow* window;
rdpUpdate* update = xfi->instance->update;
@ -632,7 +632,7 @@ static boolean xf_event_UnmapNotify(xfInfo* xfi, XEvent* event, boolean app)
return TRUE;
}
static boolean xf_event_SelectionNotify(xfInfo* xfi, XEvent* event, boolean app)
static BOOL xf_event_SelectionNotify(xfInfo* xfi, XEvent* event, BOOL app)
{
if (app != TRUE)
{
@ -643,7 +643,7 @@ static boolean xf_event_SelectionNotify(xfInfo* xfi, XEvent* event, boolean app)
return TRUE;
}
static boolean xf_event_SelectionRequest(xfInfo* xfi, XEvent* event, boolean app)
static BOOL xf_event_SelectionRequest(xfInfo* xfi, XEvent* event, BOOL app)
{
if (app != TRUE)
{
@ -654,7 +654,7 @@ static boolean xf_event_SelectionRequest(xfInfo* xfi, XEvent* event, boolean app
return TRUE;
}
static boolean xf_event_SelectionClear(xfInfo* xfi, XEvent* event, boolean app)
static BOOL xf_event_SelectionClear(xfInfo* xfi, XEvent* event, BOOL app)
{
if (app != TRUE)
{
@ -665,7 +665,7 @@ static boolean xf_event_SelectionClear(xfInfo* xfi, XEvent* event, boolean app)
return TRUE;
}
static boolean xf_event_PropertyNotify(xfInfo* xfi, XEvent* event, boolean app)
static BOOL xf_event_PropertyNotify(xfInfo* xfi, XEvent* event, BOOL app)
{
//This section handles sending the appropriate commands to the rail server
//when the window has been minimized, maximized, restored locally
@ -683,10 +683,10 @@ static boolean xf_event_PropertyNotify(xfInfo* xfi, XEvent* event, boolean app)
if ((((Atom)event->xproperty.atom == xfi->_NET_WM_STATE) && (event->xproperty.state != PropertyDelete)) ||
(((Atom)event->xproperty.atom == xfi->WM_STATE) && (event->xproperty.state != PropertyDelete)))
{
boolean status;
boolean maxVert = FALSE;
boolean maxHorz = FALSE;
boolean minimized = FALSE;
BOOL status;
BOOL maxVert = FALSE;
BOOL maxHorz = FALSE;
BOOL minimized = FALSE;
unsigned long nitems;
unsigned long bytes;
unsigned char* prop;
@ -765,7 +765,7 @@ static boolean xf_event_PropertyNotify(xfInfo* xfi, XEvent* event, boolean app)
return TRUE;
}
static boolean xf_event_suppress_events(xfInfo *xfi, rdpWindow *window, XEvent*event)
static BOOL xf_event_suppress_events(xfInfo *xfi, rdpWindow *window, XEvent*event)
{
if (! xfi->remote_app)
return FALSE;
@ -850,9 +850,9 @@ static boolean xf_event_suppress_events(xfInfo *xfi, rdpWindow *window, XEvent*e
}
boolean xf_event_process(freerdp* instance, XEvent* event)
BOOL xf_event_process(freerdp* instance, XEvent* event)
{
boolean status = TRUE;
BOOL status = TRUE;
xfInfo* xfi = ((xfContext*) instance->context)->xfi;
rdpRail* rail = ((rdpContext*) xfi->context)->rail;
rdpWindow* window;

2
client/X11/xf_event.h
View File

@ -24,7 +24,7 @@
#include "xfreerdp.h"
boolean xf_event_process(freerdp* instance, XEvent* event);
BOOL xf_event_process(freerdp* instance, XEvent* event);
void xf_event_SendClientEvent(xfInfo *xfi, xfWindow* window, Atom atom, unsigned int numArgs, ...);
#endif /* __XF_EVENT_H */

4
client/X11/xf_gdi.c
View File

@ -55,7 +55,7 @@ static const uint8 xf_rop2_table[] =
GXset /* 1 */
};
boolean xf_set_rop2(xfInfo* xfi, int rop2)
BOOL xf_set_rop2(xfInfo* xfi, int rop2)
{
if ((rop2 < 0x01) || (rop2 > 0x10))
{
@ -67,7 +67,7 @@ boolean xf_set_rop2(xfInfo* xfi, int rop2)
return TRUE;
}
boolean xf_set_rop3(xfInfo* xfi, int rop3)
BOOL xf_set_rop3(xfInfo* xfi, int rop3)
{
int function = -1;

6
client/X11/xf_graphics.c
View File

@ -113,7 +113,7 @@ void xf_Bitmap_Paint(rdpContext* context, rdpBitmap* bitmap)
void xf_Bitmap_Decompress(rdpContext* context, rdpBitmap* bitmap,
uint8* data, int width, int height, int bpp, int length,
boolean compressed, int codec_id)
BOOL compressed, int codec_id)
{
uint16 size;
RFX_MESSAGE* msg;
@ -122,7 +122,7 @@ void xf_Bitmap_Decompress(rdpContext* context, rdpBitmap* bitmap,
int yindex;
int xindex;
xfInfo* xfi;
boolean status;
BOOL status;
size = width * height * (bpp + 7) / 8;
@ -189,7 +189,7 @@ void xf_Bitmap_Decompress(rdpContext* context, rdpBitmap* bitmap,
bitmap->bpp = bpp;
}
void xf_Bitmap_SetSurface(rdpContext* context, rdpBitmap* bitmap, boolean primary)
void xf_Bitmap_SetSurface(rdpContext* context, rdpBitmap* bitmap, BOOL primary)
{
xfInfo* xfi = ((xfContext*) context)->xfi;

10
client/X11/xf_keyboard.c
View File

@ -40,7 +40,7 @@ void xf_kbd_init(xfInfo* xfi)
void xf_kbd_clear(xfInfo* xfi)
{
memset(xfi->pressed_keys, 0, 256 * sizeof(boolean));
memset(xfi->pressed_keys, 0, 256 * sizeof(BOOL));
}
void xf_kbd_set_keypress(xfInfo* xfi, uint8 keycode, KeySym keysym)
@ -75,13 +75,13 @@ void xf_kbd_release_all_keypress(xfInfo* xfi)
}
}
boolean xf_kbd_key_pressed(xfInfo* xfi, KeySym keysym)
BOOL xf_kbd_key_pressed(xfInfo* xfi, KeySym keysym)
{
KeyCode keycode = XKeysymToKeycode(xfi->display, keysym);
return (xfi->pressed_keys[keycode] == keysym);
}
void xf_kbd_send_key(xfInfo* xfi, boolean down, uint8 keycode)
void xf_kbd_send_key(xfInfo* xfi, BOOL down, uint8 keycode)
{
RDP_SCANCODE rdp_scancode;
rdpInput* input;
@ -137,7 +137,7 @@ int xf_kbd_read_keyboard_state(xfInfo* xfi)
return state;
}
boolean xf_kbd_get_key_state(xfInfo* xfi, int state, int keysym)
BOOL xf_kbd_get_key_state(xfInfo* xfi, int state, int keysym)
{
int offset;
int modifierpos, key, keysymMask = 0;
@ -194,7 +194,7 @@ void xf_kbd_focus_in(xfInfo* xfi)
input->SynchronizeEvent(input, syncFlags);
}
boolean xf_kbd_handle_special_keys(xfInfo* xfi, KeySym keysym)
BOOL xf_kbd_handle_special_keys(xfInfo* xfi, KeySym keysym)
{
if (keysym == XK_Return)
{

8
client/X11/xf_keyboard.h
View File

@ -29,12 +29,12 @@ void xf_kbd_clear(xfInfo* xfi);
void xf_kbd_set_keypress(xfInfo* xfi, uint8 keycode, KeySym keysym);
void xf_kbd_unset_keypress(xfInfo* xfi, uint8 keycode);
void xf_kbd_release_all_keypress(xfInfo* xfi);
boolean xf_kbd_key_pressed(xfInfo* xfi, KeySym keysym);
void xf_kbd_send_key(xfInfo* xfi, boolean down, uint8 keycode);
BOOL xf_kbd_key_pressed(xfInfo* xfi, KeySym keysym);
void xf_kbd_send_key(xfInfo* xfi, BOOL down, uint8 keycode);
int xf_kbd_read_keyboard_state(xfInfo* xfi);
boolean xf_kbd_get_key_state(xfInfo* xfi, int state, int keysym);
BOOL xf_kbd_get_key_state(xfInfo* xfi, int state, int keysym);
int xf_kbd_get_toggle_keys_state(xfInfo* xfi);
void xf_kbd_focus_in(xfInfo* xfi);
boolean xf_kbd_handle_special_keys(xfInfo* xfi, KeySym keysym);
BOOL xf_kbd_handle_special_keys(xfInfo* xfi, KeySym keysym);
#endif /* __XF_KEYBOARD_H */

2
client/X11/xf_monitor.c
View File

@ -35,7 +35,7 @@
/* See MSDN Section on Multiple Display Monitors: http://msdn.microsoft.com/en-us/library/dd145071 */
boolean xf_detect_monitors(xfInfo* xfi, rdpSettings* settings)
BOOL xf_detect_monitors(xfInfo* xfi, rdpSettings* settings)
{
int i;
VIRTUAL_SCREEN* vscreen;

4
client/X11/xf_monitor.h
View File

@ -27,7 +27,7 @@ struct _MONITOR_INFO
{
RECTANGLE_16 area;
RECTANGLE_16 workarea;
boolean primary;
BOOL primary;
};
typedef struct _MONITOR_INFO MONITOR_INFO;
@ -42,6 +42,6 @@ typedef struct _VIRTUAL_SCREEN VIRTUAL_SCREEN;
#include "xfreerdp.h"
boolean xf_detect_monitors(xfInfo* xfi, rdpSettings* settings);
BOOL xf_detect_monitors(xfInfo* xfi, rdpSettings* settings);
#endif /* __XF_MONITOR_H */

4
client/X11/xf_rail.c
View File

@ -56,7 +56,7 @@ void xf_rail_paint(xfInfo* xfi, rdpRail* rail, sint32 uleft, sint32 utop, uint32
{
xfWindow* xfw;
rdpWindow* window;
boolean intersect;
BOOL intersect;
uint32 iwidth, iheight;
sint32 ileft, itop;
uint32 iright, ibottom;
@ -263,7 +263,7 @@ static void xf_send_rail_client_event(rdpChannels* channels, uint16 event_type,
}
}
void xf_rail_send_activate(xfInfo* xfi, Window xwindow, boolean enabled)
void xf_rail_send_activate(xfInfo* xfi, Window xwindow, BOOL enabled)
{
rdpRail* rail;
rdpChannels* channels;

2
client/X11/xf_rail.h
View File

@ -25,7 +25,7 @@
void xf_rail_paint(xfInfo* xfi, rdpRail* rail, sint32 uleft, sint32 utop, uint32 uright, uint32 ubottom);
void xf_rail_register_callbacks(xfInfo* xfi, rdpRail* rail);
void xf_rail_send_client_system_command(xfInfo* xfi, uint32 windowId, uint16 command);
void xf_rail_send_activate(xfInfo* xfi, Window xwindow, boolean enabled);
void xf_rail_send_activate(xfInfo* xfi, Window xwindow, BOOL enabled);
void xf_process_rail_event(xfInfo* xfi, rdpChannels* chanman, RDP_EVENT* event);
void xf_rail_adjust_position(xfInfo* xfi, rdpWindow *window);
void xf_rail_end_local_move(xfInfo* xfi, rdpWindow *window);

4
client/X11/xf_tsmf.c
View File

@ -180,7 +180,7 @@ void xf_tsmf_uninit(xfInfo* xfi)
}
}
static boolean
static BOOL
xf_tsmf_is_format_supported(xfXvContext* xv, uint32 pixfmt)
{
int i;
@ -204,7 +204,7 @@ static void xf_process_tsmf_video_frame_event(xfInfo* xfi, RDP_VIDEO_FRAME_EVENT
uint8* data2;
uint32 pixfmt;
uint32 xvpixfmt;
boolean converti420yv12 = FALSE;
BOOL converti420yv12 = FALSE;
XvImage * image;
int colorkey = 0;
XShmSegmentInfo shminfo;

24
client/X11/xf_window.c
View File

@ -117,7 +117,7 @@ void xf_SendClientEvent(xfInfo* xfi, xfWindow* window, Atom atom, unsigned int n
va_end(argp);
}
void xf_SetWindowFullscreen(xfInfo* xfi, xfWindow* window, boolean fullscreen)
void xf_SetWindowFullscreen(xfInfo* xfi, xfWindow* window, BOOL fullscreen)
{
if (fullscreen)
{
@ -132,7 +132,7 @@ void xf_SetWindowFullscreen(xfInfo* xfi, xfWindow* window, boolean fullscreen)
/* http://tronche.com/gui/x/xlib/window-information/XGetWindowProperty.html */
boolean xf_GetWindowProperty(xfInfo* xfi, Window window, Atom property, int length,
BOOL xf_GetWindowProperty(xfInfo* xfi, Window window, Atom property, int length,
unsigned long* nitems, unsigned long* bytes, uint8** prop)
{
int status;
@ -158,9 +158,9 @@ boolean xf_GetWindowProperty(xfInfo* xfi, Window window, Atom property, int leng
return TRUE;
}
boolean xf_GetCurrentDesktop(xfInfo* xfi)
BOOL xf_GetCurrentDesktop(xfInfo* xfi)
{
boolean status;
BOOL status;
unsigned long nitems;
unsigned long bytes;
unsigned char* prop;
@ -178,10 +178,10 @@ boolean xf_GetCurrentDesktop(xfInfo* xfi)
return TRUE;
}
boolean xf_GetWorkArea(xfInfo* xfi)
BOOL xf_GetWorkArea(xfInfo* xfi)
{
long* plong;
boolean status;
BOOL status;
unsigned long nitems;
unsigned long bytes;
unsigned char* prop;
@ -213,7 +213,7 @@ boolean xf_GetWorkArea(xfInfo* xfi)
return TRUE;
}
void xf_SetWindowDecorations(xfInfo* xfi, xfWindow* window, boolean show)
void xf_SetWindowDecorations(xfInfo* xfi, xfWindow* window, BOOL show)
{
PropMotifWmHints hints;
@ -304,7 +304,7 @@ static void xf_SetWindowPID(xfInfo* xfi, xfWindow* window, pid_t pid)
32, PropModeReplace, (unsigned char *)&pid, 1);
}
xfWindow* xf_CreateDesktopWindow(xfInfo* xfi, char* name, int width, int height, boolean decorations)
xfWindow* xf_CreateDesktopWindow(xfInfo* xfi, char* name, int width, int height, BOOL decorations)
{
xfWindow* window;
XEvent xevent;
@ -651,7 +651,7 @@ void xf_EndLocalMoveSize(xfInfo *xfi, xfWindow *window)
void xf_MoveWindow(xfInfo* xfi, xfWindow* window, int x, int y, int width, int height)
{
boolean resize = FALSE;
BOOL resize = FALSE;
if ((width * height) < 1)
return;
@ -881,11 +881,11 @@ void xf_UpdateWindowArea(xfInfo* xfi, xfWindow* window, int x, int y, int width,
XFlush(xfi->display);
}
boolean xf_IsWindowBorder(xfInfo* xfi, xfWindow* xfw, int x, int y)
BOOL xf_IsWindowBorder(xfInfo* xfi, xfWindow* xfw, int x, int y)
{
rdpWindow* wnd;
boolean clientArea = FALSE;
boolean windowArea = FALSE;
BOOL clientArea = FALSE;
BOOL windowArea = FALSE;
wnd = xfw->window;

24
client/X11/xf_window.h
View File

@ -71,26 +71,26 @@ struct xf_window
int width;
int height;
Window handle;
boolean fullscreen;
boolean decorations;
BOOL fullscreen;
BOOL decorations;
rdpWindow* window;
boolean is_mapped;
boolean is_transient;
BOOL is_mapped;
BOOL is_transient;
xfLocalMove local_move;
uint8 rail_state;
boolean rail_ignore_configure;
BOOL rail_ignore_configure;
};
void xf_ewmhints_init(xfInfo* xfi);
boolean xf_GetCurrentDesktop(xfInfo* xfi);
boolean xf_GetWorkArea(xfInfo* xfi);
BOOL xf_GetCurrentDesktop(xfInfo* xfi);
BOOL xf_GetWorkArea(xfInfo* xfi);
void xf_SetWindowFullscreen(xfInfo* xfi, xfWindow* window, boolean fullscreen);
void xf_SetWindowDecorations(xfInfo* xfi, xfWindow* window, boolean show);
void xf_SetWindowFullscreen(xfInfo* xfi, xfWindow* window, BOOL fullscreen);
void xf_SetWindowDecorations(xfInfo* xfi, xfWindow* window, BOOL show);
void xf_SetWindowUnlisted(xfInfo* xfi, xfWindow* window);
xfWindow* xf_CreateDesktopWindow(xfInfo* xfi, char* name, int width, int height, boolean decorations);
xfWindow* xf_CreateDesktopWindow(xfInfo* xfi, char* name, int width, int height, BOOL decorations);
void xf_ResizeDesktopWindow(xfInfo* xfi, xfWindow* window, int width, int height);
xfWindow* xf_CreateWindow(xfInfo* xfi, rdpWindow* wnd, int x, int y, int width, int height, uint32 id);
@ -102,11 +102,11 @@ void xf_SetWindowRects(xfInfo* xfi, xfWindow* window, RECTANGLE_16* rects, int n
void xf_SetWindowVisibilityRects(xfInfo* xfi, xfWindow* window, RECTANGLE_16* rects, int nrects);
void xf_SetWindowStyle(xfInfo* xfi, xfWindow* window, uint32 style, uint32 ex_style);
void xf_UpdateWindowArea(xfInfo* xfi, xfWindow* window, int x, int y, int width, int height);
boolean xf_IsWindowBorder(xfInfo* xfi, xfWindow* xfw, int x, int y);
BOOL xf_IsWindowBorder(xfInfo* xfi, xfWindow* xfw, int x, int y);
void xf_DestroyWindow(xfInfo* xfi, xfWindow* window);
rdpWindow* xf_rdpWindowFromWindow(xfInfo* xfi, Window wnd);
boolean xf_GetWindowProperty(xfInfo* xfi, Window window, Atom property, int length,
BOOL xf_GetWindowProperty(xfInfo* xfi, Window window, Atom property, int length,
unsigned long* nitems, unsigned long* bytes, uint8** prop);
void xf_SetWindowMinMaxInfo(xfInfo* xfi, xfWindow* window, int maxWidth, int maxHeight,

20
client/X11/xfreerdp.c
View File

@ -226,7 +226,7 @@ void xf_hw_end_paint(rdpContext* context)
void xf_hw_desktop_resize(rdpContext* context)
{
xfInfo* xfi;
boolean same;
BOOL same;
rdpSettings* settings;
xfi = ((xfContext*) context)->xfi;
@ -263,7 +263,7 @@ void xf_hw_desktop_resize(rdpContext* context)
}
}
boolean xf_get_fds(freerdp* instance, void** rfds, int* rcount, void** wfds, int* wcount)
BOOL xf_get_fds(freerdp* instance, void** rfds, int* rcount, void** wfds, int* wcount)
{
xfInfo* xfi = ((xfContext*) instance->context)->xfi;
@ -273,7 +273,7 @@ boolean xf_get_fds(freerdp* instance, void** rfds, int* rcount, void** wfds, int
return TRUE;
}
boolean xf_process_x_events(freerdp* instance)
BOOL xf_process_x_events(freerdp* instance)
{
XEvent xevent;
xfInfo* xfi = ((xfContext*) instance->context)->xfi;
@ -351,7 +351,7 @@ void xf_toggle_fullscreen(xfInfo* xfi)
XFreePixmap(xfi->display, contents);
}
boolean xf_get_pixmap_info(xfInfo* xfi)
BOOL xf_get_pixmap_info(xfInfo* xfi)
{
int i;
int vi_count;
@ -477,10 +477,10 @@ int _xf_error_handler(Display* d, XErrorEvent* ev)
* @return TRUE if successful. FALSE otherwise.
* Can exit with error code XF_EXIT_PARSE_ARGUMENTS if there is an error in the parameters.
*/
boolean xf_pre_connect(freerdp* instance)
BOOL xf_pre_connect(freerdp* instance)
{
xfInfo* xfi;
boolean bitmap_cache;
BOOL bitmap_cache;
rdpSettings* settings;
int arg_parse_result;
@ -667,7 +667,7 @@ uint32 xf_detect_cpu()
* It will be called only if the connection was initialized properly, and will continue the initialization based on the
* newly created connection.
*/
boolean xf_post_connect(freerdp* instance)
BOOL xf_post_connect(freerdp* instance)
{
#ifdef WITH_SSE2
uint32 cpu;
@ -810,7 +810,7 @@ boolean xf_post_connect(freerdp* instance)
* @param domain - unused
* @return TRUE if a password was successfully entered. See freerdp_passphrase_read() for more details.
*/
boolean xf_authenticate(freerdp* instance, char** username, char** password, char** domain)
BOOL xf_authenticate(freerdp* instance, char** username, char** password, char** domain)
{
// FIXME: seems this callback may be called when 'username' is not known.
// But it doesn't do anything to fix it...
@ -832,7 +832,7 @@ boolean xf_authenticate(freerdp* instance, char** username, char** password, cha
* @param fingerprint
* @return TRUE if the certificate is trusted. FALSE otherwise.
*/
boolean xf_verify_certificate(freerdp* instance, char* subject, char* issuer, char* fingerprint)
BOOL xf_verify_certificate(freerdp* instance, char* subject, char* issuer, char* fingerprint)
{
char answer;
@ -1117,7 +1117,7 @@ int xfreerdp_run(freerdp* instance)
memset(wfds, 0, sizeof(wfds));
memset(&timeout, 0, sizeof(struct timeval));
boolean status = freerdp_connect(instance);
BOOL status = freerdp_connect(instance);
/* Connection succeeded. --authonly ? */
if (instance->settings->authentication_only) {
freerdp_disconnect(instance);

36
client/X11/xfreerdp.h
View File

@ -101,40 +101,40 @@ struct xf_info
Colormap colormap;
int screen_number;
int scanline_pad;
boolean big_endian;
boolean fullscreen;
boolean grab_keyboard;
boolean unobscured;
boolean decorations;
boolean debug;
BOOL big_endian;
BOOL fullscreen;
BOOL grab_keyboard;
BOOL unobscured;
BOOL decorations;
BOOL debug;
xfWindow* window;
xfWorkArea workArea;
int current_desktop;
boolean remote_app;
boolean disconnect;
BOOL remote_app;
BOOL disconnect;
HCLRCONV clrconv;
Window parent_window;
HGDI_DC hdc;
boolean sw_gdi;
BOOL sw_gdi;
uint8* primary_buffer;
boolean frame_begin;
BOOL frame_begin;
uint16 frame_x1;
uint16 frame_y1;
uint16 frame_x2;
uint16 frame_y2;
boolean focused;
boolean mouse_active;
boolean mouse_motion;
boolean suppress_output;
boolean fullscreen_toggle;
BOOL focused;
BOOL mouse_active;
BOOL mouse_motion;
BOOL suppress_output;
BOOL fullscreen_toggle;
uint32 keyboard_layout_id;
boolean pressed_keys[256];
BOOL pressed_keys[256];
XModifierKeymap* modifier_map;
XSetWindowAttributes attribs;
boolean complex_regions;
BOOL complex_regions;
VIRTUAL_SCREEN vscreen;
uint8* bmp_codec_none;
uint8* bmp_codec_nsc;
@ -170,7 +170,7 @@ struct xf_info
void xf_create_window(xfInfo* xfi);
void xf_toggle_fullscreen(xfInfo* xfi);
boolean xf_post_connect(freerdp* instance);
BOOL xf_post_connect(freerdp* instance);
enum XF_EXIT_CODE
{

2
cunit/test_freerdp.c
View File

@ -104,7 +104,7 @@ void assert_stream(STREAM* s, uint8* data, int length, const char* func, int lin
}
}
typedef boolean (*pInitTestSuite)(void);
typedef BOOL (*pInitTestSuite)(void);
struct _test_suite
{

4
include/freerdp/channels/channels.h
View File

@ -42,9 +42,9 @@ FREERDP_API int freerdp_channels_post_connect(rdpChannels* channels, freerdp* in
FREERDP_API int freerdp_channels_data(freerdp* instance, int channel_id, void* data, int data_size,
int flags, int total_size);
FREERDP_API int freerdp_channels_send_event(rdpChannels* channels, RDP_EVENT* event);
FREERDP_API boolean freerdp_channels_get_fds(rdpChannels* channels, freerdp* instance, void** read_fds,
FREERDP_API BOOL freerdp_channels_get_fds(rdpChannels* channels, freerdp* instance, void** read_fds,
int* read_count, void** write_fds, int* write_count);
FREERDP_API boolean freerdp_channels_check_fds(rdpChannels* channels, freerdp* instance);
FREERDP_API BOOL freerdp_channels_check_fds(rdpChannels* channels, freerdp* instance);
FREERDP_API RDP_EVENT* freerdp_channels_pop_event(rdpChannels* channels);
FREERDP_API void freerdp_channels_close(rdpChannels* channels, freerdp* instance);

10
include/freerdp/channels/wtsvc.h
View File

@ -53,7 +53,7 @@ FREERDP_API WTSVirtualChannelManager* WTSCreateVirtualChannelManager(freerdp_pee
FREERDP_API void WTSDestroyVirtualChannelManager(WTSVirtualChannelManager* vcm);
FREERDP_API void WTSVirtualChannelManagerGetFileDescriptor(WTSVirtualChannelManager* vcm,
void** fds, int* fds_count);
FREERDP_API boolean WTSVirtualChannelManagerCheckFileDescriptor(WTSVirtualChannelManager* vcm);
FREERDP_API BOOL WTSVirtualChannelManagerCheckFileDescriptor(WTSVirtualChannelManager* vcm);
/**
* Opens a static or dynamic virtual channel and return the handle. If the
@ -76,7 +76,7 @@ FREERDP_API void* WTSVirtualChannelOpenEx(
* Servers use this function to gain access to a virtual channel file handle
* that can be used for asynchronous I/O.
*/
FREERDP_API boolean WTSVirtualChannelQuery(
FREERDP_API BOOL WTSVirtualChannelQuery(
/* __in */ void* hChannelHandle,
/* __in */ WTS_VIRTUAL_CLASS WtsVirtualClass,
/* __out */ void** ppBuffer,
@ -105,7 +105,7 @@ FREERDP_API void WTSFreeMemory(
* The caller should use the file handle returned by WTSVirtualChannelQuery to
* determine whether a packet has arrived.
*/
FREERDP_API boolean WTSVirtualChannelRead(
FREERDP_API BOOL WTSVirtualChannelRead(
/* __in */ void* hChannelHandle,
/* __in */ uint32 TimeOut,
/* __out */ uint8* Buffer,
@ -115,7 +115,7 @@ FREERDP_API boolean WTSVirtualChannelRead(
/**
* Writes data to the server end of a virtual channel.
*/
FREERDP_API boolean WTSVirtualChannelWrite(
FREERDP_API BOOL WTSVirtualChannelWrite(
/* __in */ void* hChannelHandle,
/* __in */ uint8* Buffer,
/* __in */ uint32 Length,
@ -124,7 +124,7 @@ FREERDP_API boolean WTSVirtualChannelWrite(
/**
* Closes an open virtual channel handle.
*/
FREERDP_API boolean WTSVirtualChannelClose(
FREERDP_API BOOL WTSVirtualChannelClose(
/* __in */ void* hChannelHandle);
#endif /* __FREERDP_WTSVC_H */

2
include/freerdp/codec/bitmap.h
View File

@ -23,6 +23,6 @@
#include <freerdp/api.h>
#include <freerdp/types.h>
FREERDP_API boolean bitmap_decompress(uint8* srcData, uint8* dstData, int width, int height, int size, int srcBpp, int dstBpp);
FREERDP_API BOOL bitmap_decompress(uint8* srcData, uint8* dstData, int width, int height, int size, int srcBpp, int dstBpp);
#endif /* __BITMAP_H */

2
include/freerdp/codec/jpeg.h
View File

@ -22,7 +22,7 @@
#include <freerdp/types.h>
boolean
BOOL
jpeg_decompress(uint8* input, uint8* output, int width, int height, int size, int bpp);
#endif /* __BITMAP_H */

6
include/freerdp/codec/mppc_enc.h
View File

@ -42,9 +42,9 @@ struct rdp_mppc_enc
uint16* hash_table;
};
FREERDP_API boolean compress_rdp(struct rdp_mppc_enc* enc, uint8* srcData, int len);
FREERDP_API boolean compress_rdp_4(struct rdp_mppc_enc* enc, uint8* srcData, int len);
FREERDP_API boolean compress_rdp_5(struct rdp_mppc_enc* enc, uint8* srcData, int len);
FREERDP_API BOOL compress_rdp(struct rdp_mppc_enc* enc, uint8* srcData, int len);
FREERDP_API BOOL compress_rdp_4(struct rdp_mppc_enc* enc, uint8* srcData, int len);
FREERDP_API BOOL compress_rdp_5(struct rdp_mppc_enc* enc, uint8* srcData, int len);
FREERDP_API struct rdp_mppc_enc* mppc_enc_new(int protocol_type);
FREERDP_API void mppc_enc_free(struct rdp_mppc_enc* enc);

2
include/freerdp/codec/rfx.h
View File

@ -93,7 +93,7 @@ struct _RFX_CONTEXT
/* temporary data within a frame */
uint32 frame_idx;
boolean header_processed;
BOOL header_processed;
uint8 num_quants;
uint32* quants;
uint8 quant_idx_y;

28
include/freerdp/crypto/ber.h
View File

@ -55,30 +55,30 @@ FREERDP_API void ber_read_length(STREAM* s, int* length);
FREERDP_API int ber_write_length(STREAM* s, int length);
FREERDP_API int _ber_skip_length(int length);
FREERDP_API int ber_get_content_length(int length);
FREERDP_API boolean ber_read_universal_tag(STREAM* s, uint8 tag, boolean pc);
FREERDP_API void ber_write_universal_tag(STREAM* s, uint8 tag, boolean pc);
FREERDP_API boolean ber_read_application_tag(STREAM* s, uint8 tag, int* length);
FREERDP_API BOOL ber_read_universal_tag(STREAM* s, uint8 tag, BOOL pc);
FREERDP_API void ber_write_universal_tag(STREAM* s, uint8 tag, BOOL pc);
FREERDP_API BOOL ber_read_application_tag(STREAM* s, uint8 tag, int* length);
FREERDP_API void ber_write_application_tag(STREAM* s, uint8 tag, int length);
FREERDP_API boolean ber_read_application_tag(STREAM* s, uint8 tag, int* length);
FREERDP_API boolean ber_read_enumerated(STREAM* s, uint8* enumerated, uint8 count);
FREERDP_API BOOL ber_read_application_tag(STREAM* s, uint8 tag, int* length);
FREERDP_API BOOL ber_read_enumerated(STREAM* s, uint8* enumerated, uint8 count);
FREERDP_API void ber_write_enumerated(STREAM* s, uint8 enumerated, uint8 count);
FREERDP_API boolean ber_read_contextual_tag(STREAM* s, uint8 tag, int* length, boolean pc);
FREERDP_API int ber_write_contextual_tag(STREAM* s, uint8 tag, int length, boolean pc);
FREERDP_API BOOL ber_read_contextual_tag(STREAM* s, uint8 tag, int* length, BOOL pc);
FREERDP_API int ber_write_contextual_tag(STREAM* s, uint8 tag, int length, BOOL pc);
FREERDP_API int ber_skip_contextual_tag(int length);
FREERDP_API boolean ber_read_sequence_tag(STREAM* s, int* length);
FREERDP_API BOOL ber_read_sequence_tag(STREAM* s, int* length);
FREERDP_API int ber_write_sequence_tag(STREAM* s, int length);
FREERDP_API int ber_skip_sequence(int length);
FREERDP_API int ber_skip_sequence_tag(int length);
FREERDP_API boolean ber_read_bit_string(STREAM* s, int* length, uint8* padding);
FREERDP_API BOOL ber_read_bit_string(STREAM* s, int* length, uint8* padding);
FREERDP_API void ber_write_octet_string(STREAM* s, const uint8* oct_str, int length);
FREERDP_API boolean ber_read_octet_string_tag(STREAM* s, int* length);
FREERDP_API BOOL ber_read_octet_string_tag(STREAM* s, int* length);
FREERDP_API int ber_write_octet_string_tag(STREAM* s, int length);
FREERDP_API int ber_skip_octet_string(int length);
FREERDP_API boolean ber_read_boolean(STREAM* s, boolean* value);
FREERDP_API void ber_write_boolean(STREAM* s, boolean value);
FREERDP_API boolean ber_read_integer(STREAM* s, uint32* value);
FREERDP_API BOOL ber_read_BOOL(STREAM* s, BOOL* value);
FREERDP_API void ber_write_BOOL(STREAM* s, BOOL value);
FREERDP_API BOOL ber_read_integer(STREAM* s, uint32* value);
FREERDP_API int ber_write_integer(STREAM* s, uint32 value);
FREERDP_API boolean ber_read_integer_length(STREAM* s, int* length);
FREERDP_API BOOL ber_read_integer_length(STREAM* s, int* length);
FREERDP_API int ber_skip_integer(uint32 value);
#endif /* FREERDP_CRYPTO_BER_H */

4
include/freerdp/crypto/crypto.h
View File

@ -125,9 +125,9 @@ FREERDP_API char* crypto_cert_issuer(X509* xcert);
FREERDP_API void crypto_cert_print_info(X509* xcert);
FREERDP_API void crypto_cert_free(CryptoCert cert);
FREERDP_API boolean x509_verify_certificate(CryptoCert cert, char* certificate_store_path);
FREERDP_API BOOL x509_verify_certificate(CryptoCert cert, char* certificate_store_path);
FREERDP_API rdpCertificateData* crypto_get_certificate_data(X509* xcert, char* hostname);
FREERDP_API boolean crypto_cert_get_public_key(CryptoCert cert, BYTE** PublicKey, DWORD* PublicKeyLength);
FREERDP_API BOOL crypto_cert_get_public_key(CryptoCert cert, BYTE** PublicKey, DWORD* PublicKeyLength);
#define TSSK_KEY_LENGTH 64
extern const uint8 tssk_modulus[];

2
include/freerdp/crypto/der.h
View File

@ -30,7 +30,7 @@ FREERDP_API int der_skip_octet_string(int length);
FREERDP_API int der_skip_sequence_tag(int length);
FREERDP_API int der_write_sequence_tag(STREAM* s, int length);
FREERDP_API int der_skip_contextual_tag(int length);
FREERDP_API int der_write_contextual_tag(STREAM* s, uint8 tag, int length, boolean pc);
FREERDP_API int der_write_contextual_tag(STREAM* s, uint8 tag, int length, BOOL pc);
FREERDP_API void der_write_octet_string(STREAM* s, uint8* oct_str, int length);
#endif /* FREERDP_CRYPTO_DER_H */

42
include/freerdp/crypto/er.h
View File

@ -55,34 +55,34 @@
#define ER_PC(_pc) (_pc ? ER_CONSTRUCT : ER_PRIMITIVE)
FREERDP_API void er_read_length(STREAM* s, int* length);
FREERDP_API int er_write_length(STREAM* s, int length, boolean flag);
FREERDP_API int er_write_length(STREAM* s, int length, BOOL flag);
FREERDP_API int _er_skip_length(int length);
FREERDP_API int er_get_content_length(int length);
FREERDP_API boolean er_read_universal_tag(STREAM* s, uint8 tag, boolean pc);
FREERDP_API void er_write_universal_tag(STREAM* s, uint8 tag, boolean pc);
FREERDP_API boolean er_read_application_tag(STREAM* s, uint8 tag, int* length);
FREERDP_API void er_write_application_tag(STREAM* s, uint8 tag, int length, boolean flag);
FREERDP_API boolean er_read_application_tag(STREAM* s, uint8 tag, int* length);
FREERDP_API boolean er_read_enumerated(STREAM* s, uint8* enumerated, uint8 count);
FREERDP_API void er_write_enumerated(STREAM* s, uint8 enumerated, uint8 count, boolean flag);
FREERDP_API boolean er_read_contextual_tag(STREAM* s, uint8 tag, int* length, boolean pc);
FREERDP_API int er_write_contextual_tag(STREAM* s, uint8 tag, int length, boolean pc, boolean flag);
FREERDP_API BOOL er_read_universal_tag(STREAM* s, uint8 tag, BOOL pc);
FREERDP_API void er_write_universal_tag(STREAM* s, uint8 tag, BOOL pc);
FREERDP_API BOOL er_read_application_tag(STREAM* s, uint8 tag, int* length);
FREERDP_API void er_write_application_tag(STREAM* s, uint8 tag, int length, BOOL flag);
FREERDP_API BOOL er_read_application_tag(STREAM* s, uint8 tag, int* length);
FREERDP_API BOOL er_read_enumerated(STREAM* s, uint8* enumerated, uint8 count);
FREERDP_API void er_write_enumerated(STREAM* s, uint8 enumerated, uint8 count, BOOL flag);
FREERDP_API BOOL er_read_contextual_tag(STREAM* s, uint8 tag, int* length, BOOL pc);
FREERDP_API int er_write_contextual_tag(STREAM* s, uint8 tag, int length, BOOL pc, BOOL flag);
FREERDP_API int er_skip_contextual_tag(int length);
FREERDP_API boolean er_read_sequence_tag(STREAM* s, int* length);
FREERDP_API int er_write_sequence_tag(STREAM* s, int length, boolean flag);
FREERDP_API BOOL er_read_sequence_tag(STREAM* s, int* length);
FREERDP_API int er_write_sequence_tag(STREAM* s, int length, BOOL flag);
FREERDP_API int er_skip_sequence(int length);
FREERDP_API int er_skip_sequence_tag(int length);
FREERDP_API boolean er_read_bit_string(STREAM* s, int* length, uint8* padding);
FREERDP_API boolean er_write_bit_string_tag(STREAM* s, uint32 length, uint8 padding, boolean flag);
FREERDP_API boolean er_read_octet_string(STREAM* s, int* length);
FREERDP_API void er_write_octet_string(STREAM* s, uint8* oct_str, int length, boolean flag);
FREERDP_API int er_write_octet_string_tag(STREAM* s, int length, boolean flag);
FREERDP_API BOOL er_read_bit_string(STREAM* s, int* length, uint8* padding);
FREERDP_API BOOL er_write_bit_string_tag(STREAM* s, uint32 length, uint8 padding, BOOL flag);
FREERDP_API BOOL er_read_octet_string(STREAM* s, int* length);
FREERDP_API void er_write_octet_string(STREAM* s, uint8* oct_str, int length, BOOL flag);
FREERDP_API int er_write_octet_string_tag(STREAM* s, int length, BOOL flag);
FREERDP_API int er_skip_octet_string(int length);
FREERDP_API boolean er_read_boolean(STREAM* s, boolean* value);
FREERDP_API void er_write_boolean(STREAM* s, boolean value);
FREERDP_API boolean er_read_integer(STREAM* s, uint32* value);
FREERDP_API BOOL er_read_BOOL(STREAM* s, BOOL* value);
FREERDP_API void er_write_BOOL(STREAM* s, BOOL value);
FREERDP_API BOOL er_read_integer(STREAM* s, uint32* value);
FREERDP_API int er_write_integer(STREAM* s, sint32 value);
FREERDP_API boolean er_read_integer_length(STREAM* s, int* length);
FREERDP_API BOOL er_read_integer_length(STREAM* s, int* length);
FREERDP_API int er_skip_integer(sint32 value);
#endif /* FREERDP_CRYPTO_ER_H */

2
include/freerdp/crypto/nla.h
View File

@ -36,7 +36,7 @@ typedef struct rdp_credssp rdpCredssp;
struct rdp_credssp
{
rdpTls* tls;
boolean server;
BOOL server;
int send_seq_num;
int recv_seq_num;
freerdp* instance;

22
include/freerdp/crypto/per.h
View File

@ -23,27 +23,27 @@
#include <freerdp/api.h>
#include <freerdp/utils/stream.h>
FREERDP_API boolean per_read_length(STREAM* s, uint16* length);
FREERDP_API BOOL per_read_length(STREAM* s, uint16* length);
FREERDP_API void per_write_length(STREAM* s, int length);
FREERDP_API boolean per_read_choice(STREAM* s, uint8* choice);
FREERDP_API BOOL per_read_choice(STREAM* s, uint8* choice);
FREERDP_API void per_write_choice(STREAM* s, uint8 choice);
FREERDP_API boolean per_read_selection(STREAM* s, uint8* selection);
FREERDP_API BOOL per_read_selection(STREAM* s, uint8* selection);
FREERDP_API void per_write_selection(STREAM* s, uint8 selection);
FREERDP_API boolean per_read_number_of_sets(STREAM* s, uint8* number);
FREERDP_API BOOL per_read_number_of_sets(STREAM* s, uint8* number);
FREERDP_API void per_write_number_of_sets(STREAM* s, uint8 number);
FREERDP_API boolean per_read_padding(STREAM* s, int length);
FREERDP_API BOOL per_read_padding(STREAM* s, int length);
FREERDP_API void per_write_padding(STREAM* s, int length);
FREERDP_API boolean per_read_integer(STREAM* s, uint32* integer);
FREERDP_API boolean per_read_integer16(STREAM* s, uint16* integer, uint16 min);
FREERDP_API BOOL per_read_integer(STREAM* s, uint32* integer);
FREERDP_API BOOL per_read_integer16(STREAM* s, uint16* integer, uint16 min);
FREERDP_API void per_write_integer(STREAM* s, uint32 integer);
FREERDP_API void per_write_integer16(STREAM* s, uint16 integer, uint16 min);
FREERDP_API boolean per_read_enumerated(STREAM* s, uint8* enumerated, uint8 count);
FREERDP_API BOOL per_read_enumerated(STREAM* s, uint8* enumerated, uint8 count);
FREERDP_API void per_write_enumerated(STREAM* s, uint8 enumerated, uint8 count);
FREERDP_API void per_write_object_identifier(STREAM* s, uint8 oid[6]);
FREERDP_API boolean per_read_object_identifier(STREAM* s, uint8 oid[6]);
FREERDP_API boolean per_read_octet_string(STREAM* s, uint8* oct_str, int length, int min);
FREERDP_API BOOL per_read_object_identifier(STREAM* s, uint8 oid[6]);
FREERDP_API BOOL per_read_octet_string(STREAM* s, uint8* oct_str, int length, int min);
FREERDP_API void per_write_octet_string(STREAM* s, uint8* oct_str, int length, int min);
FREERDP_API boolean per_read_numeric_string(STREAM* s, int min);
FREERDP_API BOOL per_read_numeric_string(STREAM* s, int min);
FREERDP_API void per_write_numeric_string(STREAM* s, uint8* num_str, int length, int min);
#endif /* FREERDP_CRYPTO_PER_H */

10
include/freerdp/crypto/tls.h
View File

@ -43,9 +43,9 @@ struct rdp_tls
rdpCertificateStore* certificate_store;
};
FREERDP_API boolean tls_connect(rdpTls* tls);
FREERDP_API boolean tls_accept(rdpTls* tls, const char* cert_file, const char* privatekey_file);
FREERDP_API boolean tls_disconnect(rdpTls* tls);
FREERDP_API BOOL tls_connect(rdpTls* tls);
FREERDP_API BOOL tls_accept(rdpTls* tls, const char* cert_file, const char* privatekey_file);
FREERDP_API BOOL tls_disconnect(rdpTls* tls);
FREERDP_API int tls_read(rdpTls* tls, uint8* data, int length);
FREERDP_API int tls_write(rdpTls* tls, uint8* data, int length);
@ -53,11 +53,11 @@ FREERDP_API int tls_write(rdpTls* tls, uint8* data, int length);
FREERDP_API int tls_read_all(rdpTls* tls, uint8* data, int length);
FREERDP_API int tls_write_all(rdpTls* tls, uint8* data, int length);
FREERDP_API boolean tls_verify_certificate(rdpTls* tls, CryptoCert cert, char* hostname);
FREERDP_API BOOL tls_verify_certificate(rdpTls* tls, CryptoCert cert, char* hostname);
FREERDP_API void tls_print_certificate_error(char* hostname, char* fingerprint);
FREERDP_API void tls_print_certificate_name_mismatch_error(char* hostname, char* common_name, char** alt_names, int alt_names_count);
FREERDP_API boolean tls_print_error(char* func, SSL* connection, int value);
FREERDP_API BOOL tls_print_error(char* func, SSL* connection, int value);
FREERDP_API rdpTls* tls_new(rdpSettings* settings);
FREERDP_API void tls_free(rdpTls* tls);

20
include/freerdp/freerdp.h
View File

@ -48,11 +48,11 @@ extern "C" {
typedef void (*pContextNew)(freerdp* instance, rdpContext* context);
typedef void (*pContextFree)(freerdp* instance, rdpContext* context);
typedef boolean (*pPreConnect)(freerdp* instance);
typedef boolean (*pPostConnect)(freerdp* instance);
typedef boolean (*pAuthenticate)(freerdp* instance, char** username, char** password, char** domain);
typedef boolean (*pVerifyCertificate)(freerdp* instance, char* subject, char* issuer, char* fingerprint);
typedef boolean (*pVerifyChangedCertificate)(freerdp* instance, char* subject, char* issuer, char* new_fingerprint, char* old_fingerprint);
typedef BOOL (*pPreConnect)(freerdp* instance);
typedef BOOL (*pPostConnect)(freerdp* instance);
typedef BOOL (*pAuthenticate)(freerdp* instance, char** username, char** password, char** domain);
typedef BOOL (*pVerifyCertificate)(freerdp* instance, char* subject, char* issuer, char* fingerprint);
typedef BOOL (*pVerifyChangedCertificate)(freerdp* instance, char* subject, char* issuer, char* new_fingerprint, char* old_fingerprint);
typedef int (*pSendChannelData)(freerdp* instance, int channelId, uint8* data, int size);
typedef int (*pReceiveChannelData)(freerdp* instance, int channelId, uint8* data, int size, int flags, int total_size);
@ -184,12 +184,12 @@ struct rdp_freerdp
FREERDP_API void freerdp_context_new(freerdp* instance);
FREERDP_API void freerdp_context_free(freerdp* instance);
FREERDP_API boolean freerdp_connect(freerdp* instance);
FREERDP_API boolean freerdp_shall_disconnect(freerdp* instance);
FREERDP_API boolean freerdp_disconnect(freerdp* instance);
FREERDP_API BOOL freerdp_connect(freerdp* instance);
FREERDP_API BOOL freerdp_shall_disconnect(freerdp* instance);
FREERDP_API BOOL freerdp_disconnect(freerdp* instance);
FREERDP_API boolean freerdp_get_fds(freerdp* instance, void** rfds, int* rcount, void** wfds, int* wcount);
FREERDP_API boolean freerdp_check_fds(freerdp* instance);
FREERDP_API BOOL freerdp_get_fds(freerdp* instance, void** rfds, int* rcount, void** wfds, int* wcount);
FREERDP_API BOOL freerdp_check_fds(freerdp* instance);
FREERDP_API uint32 freerdp_error_info(freerdp* instance);

12
include/freerdp/graphics.h
View File

@ -36,8 +36,8 @@ typedef void (*pBitmap_Free)(rdpContext* context, rdpBitmap* bitmap);
typedef void (*pBitmap_Paint)(rdpContext* context, rdpBitmap* bitmap);
typedef void (*pBitmap_Decompress)(rdpContext* context, rdpBitmap* bitmap,
uint8* data, int width, int height, int bpp, int length,
boolean compressed, int codec_id);
typedef void (*pBitmap_SetSurface)(rdpContext* context, rdpBitmap* bitmap, boolean primary);
BOOL compressed, int codec_id);
typedef void (*pBitmap_SetSurface)(rdpContext* context, rdpBitmap* bitmap, BOOL primary);
struct rdp_bitmap
{
@ -61,8 +61,8 @@ struct rdp_bitmap
uint8* data; /* 25 */
uint32 paddingB[32 - 26]; /* 26 */
boolean compressed; /* 32 */
boolean ephemeral; /* 33 */
BOOL compressed; /* 32 */
BOOL ephemeral; /* 33 */
uint32 paddingC[64 - 34]; /* 34 */
};
@ -71,11 +71,11 @@ FREERDP_API void Bitmap_New(rdpContext* context, rdpBitmap* bitmap);
FREERDP_API void Bitmap_Free(rdpContext* context, rdpBitmap* bitmap);
FREERDP_API void Bitmap_Register(rdpContext* context, rdpBitmap* bitmap);
FREERDP_API void Bitmap_Decompress(rdpContext* context, rdpBitmap* bitmap,
uint8* data, int width, int height, int bpp, int length, boolean compressed);
uint8* data, int width, int height, int bpp, int length, BOOL compressed);
FREERDP_API void Bitmap_SetRectangle(rdpContext* context, rdpBitmap* bitmap,
uint16 left, uint16 top, uint16 right, uint16 bottom);
FREERDP_API void Bitmap_SetDimensions(rdpContext* context, rdpBitmap* bitmap, uint16 width, uint16 height);
FREERDP_API void Bitmap_SetSurface(rdpContext* context, rdpBitmap* bitmap, boolean primary);
FREERDP_API void Bitmap_SetSurface(rdpContext* context, rdpBitmap* bitmap, BOOL primary);
/* Pointer Class */

2
include/freerdp/input.h
View File

@ -76,7 +76,7 @@ struct rdp_input
FREERDP_API void freerdp_input_send_synchronize_event(rdpInput* input, uint32 flags);
FREERDP_API void freerdp_input_send_keyboard_event(rdpInput* input, uint16 flags, uint16 code);
FREERDP_API void freerdp_input_send_keyboard_event_ex(rdpInput* input, boolean down, uint32 rdp_scancode);
FREERDP_API void freerdp_input_send_keyboard_event_ex(rdpInput* input, BOOL down, uint32 rdp_scancode);
FREERDP_API void freerdp_input_send_unicode_keyboard_event(rdpInput* input, uint16 flags, uint16 code);
FREERDP_API void freerdp_input_send_mouse_event(rdpInput* input, uint16 flags, uint16 x, uint16 y);
FREERDP_API void freerdp_input_send_extended_mouse_event(rdpInput* input, uint16 flags, uint16 x, uint16 y);

8
include/freerdp/listener.h
View File

@ -31,10 +31,10 @@ typedef struct rdp_freerdp_listener freerdp_listener;
extern "C" {
#endif
typedef boolean (*psListenerOpen)(freerdp_listener* instance, const char* bind_address, uint16 port);
typedef boolean (*psListenerOpenLocal)(freerdp_listener* instance, const char* path);
typedef boolean (*psListenerGetFileDescriptor)(freerdp_listener* instance, void** rfds, int* rcount);
typedef boolean (*psListenerCheckFileDescriptor)(freerdp_listener* instance);
typedef BOOL (*psListenerOpen)(freerdp_listener* instance, const char* bind_address, uint16 port);
typedef BOOL (*psListenerOpenLocal)(freerdp_listener* instance, const char* path);
typedef BOOL (*psListenerGetFileDescriptor)(freerdp_listener* instance, void** rfds, int* rcount);
typedef BOOL (*psListenerCheckFileDescriptor)(freerdp_listener* instance);
typedef void (*psListenerClose)(freerdp_listener* instance);
typedef void (*psPeerAccepted)(freerdp_listener* instance, freerdp_peer* client);

2
include/freerdp/locale/keyboard.h
View File

@ -202,7 +202,7 @@ FREERDP_API uint32 freerdp_keyboard_init(uint32 keyboardLayoutId);
FREERDP_API RDP_KEYBOARD_LAYOUT* freerdp_keyboard_get_layouts(uint32 types);
FREERDP_API const char* freerdp_keyboard_get_layout_name_from_id(uint32 keyboardLayoutId);
FREERDP_API RDP_SCANCODE freerdp_keyboard_get_rdp_scancode_from_x11_keycode(uint32 keycode);
FREERDP_API uint32 freerdp_keyboard_get_x11_keycode_from_rdp_scancode(uint32 scancode, boolean extended);
FREERDP_API uint32 freerdp_keyboard_get_x11_keycode_from_rdp_scancode(uint32 scancode, BOOL extended);
FREERDP_API RDP_SCANCODE freerdp_keyboard_get_rdp_scancode_from_virtual_key_code(uint32 vkcode);
#endif /* __FREERDP_LOCALE_KEYBOARD_H */

24
include/freerdp/peer.h
View File

@ -31,15 +31,15 @@
typedef void (*psPeerContextNew)(freerdp_peer* client, rdpContext* context);
typedef void (*psPeerContextFree)(freerdp_peer* client, rdpContext* context);
typedef boolean (*psPeerInitialize)(freerdp_peer* client);
typedef boolean (*psPeerGetFileDescriptor)(freerdp_peer* client, void** rfds, int* rcount);
typedef boolean (*psPeerCheckFileDescriptor)(freerdp_peer* client);
typedef boolean (*psPeerClose)(freerdp_peer* client);
typedef BOOL (*psPeerInitialize)(freerdp_peer* client);
typedef BOOL (*psPeerGetFileDescriptor)(freerdp_peer* client, void** rfds, int* rcount);
typedef BOOL (*psPeerCheckFileDescriptor)(freerdp_peer* client);
typedef BOOL (*psPeerClose)(freerdp_peer* client);
typedef void (*psPeerDisconnect)(freerdp_peer* client);
typedef boolean (*psPeerCapabilities)(freerdp_peer* client);
typedef boolean (*psPeerPostConnect)(freerdp_peer* client);
typedef boolean (*psPeerActivate)(freerdp_peer* client);
typedef boolean (*psPeerLogon)(freerdp_peer* client, SEC_WINNT_AUTH_IDENTITY* identity, boolean automatic);
typedef BOOL (*psPeerCapabilities)(freerdp_peer* client);
typedef BOOL (*psPeerPostConnect)(freerdp_peer* client);
typedef BOOL (*psPeerActivate)(freerdp_peer* client);
typedef BOOL (*psPeerLogon)(freerdp_peer* client, SEC_WINNT_AUTH_IDENTITY* identity, BOOL automatic);
typedef int (*psPeerSendChannelData)(freerdp_peer* client, int channelId, uint8* data, int size);
typedef int (*psPeerReceiveChannelData)(freerdp_peer* client, int channelId, uint8* data, int size, int flags, int total_size);
@ -73,10 +73,10 @@ struct rdp_freerdp_peer
psPeerReceiveChannelData ReceiveChannelData;
uint32 ack_frame_id;
boolean local;
boolean connected;
boolean activated;
boolean authenticated;
BOOL local;
BOOL connected;
BOOL activated;
BOOL authenticated;
SEC_WINNT_AUTH_IDENTITY identity;
};

4
include/freerdp/primary.h
View File

@ -56,7 +56,7 @@ struct _ORDER_INFO
sint32 deltaBoundTop;
sint32 deltaBoundRight;
sint32 deltaBoundBottom;
boolean deltaCoordinates;
BOOL deltaCoordinates;
};
typedef struct _ORDER_INFO ORDER_INFO;
@ -330,7 +330,7 @@ struct _FAST_INDEX_ORDER
sint32 opTop;
sint32 opRight;
sint32 opBottom;
boolean opaqueRect;
BOOL opaqueRect;
sint32 x;
sint32 y;
uint32 cbData;

16
include/freerdp/rail.h
View File

@ -201,23 +201,23 @@ struct _RAIL_SYSPARAM_ORDER
{
uint32 param;
uint32 params;
boolean dragFullWindows;
boolean keyboardCues;
boolean keyboardPref;
boolean mouseButtonSwap;
BOOL dragFullWindows;
BOOL keyboardCues;
BOOL keyboardPref;
BOOL mouseButtonSwap;
RECTANGLE_16 workArea;
RECTANGLE_16 displayChange;
RECTANGLE_16 taskbarPos;
HIGH_CONTRAST highContrast;
boolean setScreenSaveActive;
boolean setScreenSaveSecure;
BOOL setScreenSaveActive;
BOOL setScreenSaveSecure;
};
typedef struct _RAIL_SYSPARAM_ORDER RAIL_SYSPARAM_ORDER;
struct _RAIL_ACTIVATE_ORDER
{
uint32 windowId;
boolean enabled;
BOOL enabled;
};
typedef struct _RAIL_ACTIVATE_ORDER RAIL_ACTIVATE_ORDER;
@ -261,7 +261,7 @@ typedef struct _RAIL_MINMAXINFO_ORDER RAIL_MINMAXINFO_ORDER;
struct _RAIL_LOCALMOVESIZE_ORDER
{
uint32 windowId;
boolean isMoveSizeStart;
BOOL isMoveSizeStart;
uint16 moveSizeType;
uint16 posX;
uint16 posY;

2
include/freerdp/rail/icon.h
View File

@ -34,7 +34,7 @@ typedef struct rdp_icon_cache rdpIconCache;
struct rdp_icon
{
ICON_INFO* entry;
boolean big;
BOOL big;
void* extra;
};

2
include/freerdp/rail/window_list.h
View File

@ -39,7 +39,7 @@ struct rdp_window_list
};
FREERDP_API void window_list_rewind(rdpWindowList* list);
FREERDP_API boolean window_list_has_next(rdpWindowList* list);
FREERDP_API BOOL window_list_has_next(rdpWindowList* list);
FREERDP_API rdpWindow* window_list_get_next(rdpWindowList* list);
FREERDP_API rdpWindow* window_list_get_by_id(rdpWindowList* list, uint32 windowId);

6
include/freerdp/secondary.h
View File

@ -74,7 +74,7 @@ struct _CACHE_BITMAP_ORDER
uint32 bitmapHeight;
uint32 bitmapLength;
uint32 cacheIndex;
boolean compressed;
BOOL compressed;
uint8 bitmapComprHdr[8];
uint8* bitmapDataStream;
};
@ -91,7 +91,7 @@ struct _CACHE_BITMAP_V2_ORDER
uint32 bitmapHeight;
uint32 bitmapLength;
uint32 cacheIndex;
boolean compressed;
BOOL compressed;
uint32 cbCompFirstRowSize;
uint32 cbCompMainBodySize;
uint32 cbScanWidth;
@ -210,7 +210,7 @@ struct rdp_secondary_update
/* internal */
boolean glyph_v2;
BOOL glyph_v2;
CACHE_BITMAP_ORDER cache_bitmap_order;
CACHE_BITMAP_V2_ORDER cache_bitmap_v2_order;
CACHE_BITMAP_V3_ORDER cache_bitmap_v3_order;

4
include/freerdp/server/audin.h
View File

@ -26,8 +26,8 @@
typedef struct _audin_server_context audin_server_context;
typedef void (*psAudinServerSelectFormat)(audin_server_context* context, int client_format_index);
typedef boolean (*psAudinServerOpen)(audin_server_context* context);
typedef boolean (*psAudinServerClose)(audin_server_context* context);
typedef BOOL (*psAudinServerOpen)(audin_server_context* context);
typedef BOOL (*psAudinServerClose)(audin_server_context* context);
typedef void (*psAudinServerOpening)(audin_server_context* context);
typedef void (*psAudinServerOpenResult)(audin_server_context* context, uint32 result);

Some files were not shown because too many files have changed in this diff Show More