/**

 * FreeRDP: A Remote Desktop Protocol Implementation

 * X11 Client Interface

 *

 * Copyright 2013 Marc-Andre Moreau <marcandre.moreau@gmail.com>

 * Copyright 2013 Corey Clayton <can.of.tuna@gmail.com>

 * Copyright 2014 Thincast Technologies GmbH

 * Copyright 2014 Norbert Federa <norbert.federa@thincast.com>

 * Copyright 2016 Armin Novak <armin.novak@thincast.com>

 * Copyright 2016 Thincast Technologies GmbH

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *     http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <assert.h>

#include <float.h>

#include <X11/Xlib.h>

#include <X11/Xutil.h>

#include <X11/Xatom.h>

#ifdef WITH_XRENDER

#include <X11/extensions/Xrender.h>

#include <math.h>

#endif

#ifdef WITH_XI

#include <X11/extensions/XInput.h>

#include <X11/extensions/XInput2.h>

#endif

#ifdef WITH_XCURSOR

#include <X11/Xcursor/Xcursor.h>

#endif

#ifdef WITH_XINERAMA

#include <X11/extensions/Xinerama.h>

#endif

#include <X11/XKBlib.h>

#include <errno.h>

#include <stdio.h>

#include <stdlib.h>

#include <locale.h>

#include <unistd.h>

#include <string.h>

#include <termios.h>

#include <pthread.h>

#include <sys/wait.h>

#include <sys/types.h>

#include <sys/select.h>

#include <freerdp/freerdp.h>

#include <freerdp/constants.h>

#include <freerdp/codec/nsc.h>

#include <freerdp/codec/rfx.h>

#include <freerdp/codec/color.h>

#include <freerdp/codec/bitmap.h>

#include <freerdp/utils/signal.h>

#include <freerdp/utils/passphrase.h>

#include <freerdp/client/cliprdr.h>

#include <freerdp/client/channels.h>

#include <freerdp/client/file.h>

#include <freerdp/client/cmdline.h>

#include <winpr/crt.h>

#include <winpr/synch.h>

#include <winpr/file.h>

#include <winpr/print.h>

#include <winpr/sysinfo.h>

#include <X11/XKBlib.h>

#include "xf_gdi.h"

#include "xf_rail.h"

#if defined(CHANNEL_TSMF_CLIENT)

#include "xf_tsmf.h"

#endif

#include "xf_event.h"

#include "xf_input.h"

#include "xf_cliprdr.h"

#include "xf_disp.h"

#include "xf_video.h"

#include "xf_monitor.h"

#include "xf_graphics.h"

#include "xf_keyboard.h"

#include "xf_input.h"

#include "xf_channels.h"

#include "xfreerdp.h"

#include <freerdp/log.h>

#define TAG CLIENT_TAG("x11")

#define MIN_PIXEL_DIFF 0.001

static int (*_def_error_handler)(Display*, XErrorEvent*);

static int _xf_error_handler(Display* d, XErrorEvent* ev);

static void xf_check_extensions(xfContext* context);

static void xf_window_free(xfContext* xfc);

static BOOL xf_get_pixmap_info(xfContext* xfc);

#ifdef WITH_XRENDER

static void xf_draw_screen_scaled(xfContext* xfc, int x, int y, int w, int h)

{

	XTransform transform;

	Picture windowPicture;

	Picture primaryPicture;

	XRenderPictureAttributes pa;

	XRenderPictFormat* picFormat;

	double xScalingFactor;

	double yScalingFactor;

	int x2;

	int y2;

	const char* filter;

	rdpSettings* settings = xfc->context.settings;

	if (xfc->scaledWidth <= 0 || xfc->scaledHeight <= 0)

	{

		WLog_ERR(TAG, "the current window dimensions are invalid");

		return;

	}

	if (settings->DesktopWidth <= 0 || settings->DesktopHeight <= 0)

	{

		WLog_ERR(TAG, "the window dimensions are invalid");

		return;

	}

	xScalingFactor = settings->DesktopWidth / (double)xfc->scaledWidth;

	yScalingFactor = settings->DesktopHeight / (double)xfc->scaledHeight;

	XSetFillStyle(xfc->display, xfc->gc, FillSolid);

	XSetForeground(xfc->display, xfc->gc, 0);

	/* Black out possible space between desktop and window borders */

	{

		XRectangle box1 = { 0, 0, xfc->window->width, xfc->window->height };

		XRectangle box2 = { xfc->offset_x, xfc->offset_y, xfc->scaledWidth, xfc->scaledHeight };

		Region reg1 = XCreateRegion();

		Region reg2 = XCreateRegion();

		XUnionRectWithRegion(&box1, reg1, reg1);

		XUnionRectWithRegion(&box2, reg2, reg2);

		if (XSubtractRegion(reg1, reg2, reg1) && !XEmptyRegion(reg1))

		{

			XSetRegion(xfc->display, xfc->gc, reg1);

			XFillRectangle(xfc->display, xfc->window->handle, xfc->gc, 0, 0, xfc->window->width,

			               xfc->window->height);

			XSetClipMask(xfc->display, xfc->gc, None);

		}

		XDestroyRegion(reg1);

		XDestroyRegion(reg2);

	}

	picFormat = XRenderFindVisualFormat(xfc->display, xfc->visual);

	pa.subwindow_mode = IncludeInferiors;

	primaryPicture =

	    XRenderCreatePicture(xfc->display, xfc->primary, picFormat, CPSubwindowMode, &pa);

	windowPicture =

	    XRenderCreatePicture(xfc->display, xfc->window->handle, picFormat, CPSubwindowMode, &pa);

	/* avoid blurry filter when scaling factor is 2x, 3x, etc

	 * useful when the client has high-dpi monitor */

	filter = FilterBilinear;

	if (fabs(xScalingFactor - yScalingFactor) < MIN_PIXEL_DIFF)

	{

		const double inverseX = 1.0 / xScalingFactor;

		const double inverseRoundedX = round(inverseX);

		const double absInverse = fabs(inverseX - inverseRoundedX);

		if (absInverse < MIN_PIXEL_DIFF)

			filter = FilterNearest;

	}

	XRenderSetPictureFilter(xfc->display, primaryPicture, filter, 0, 0);

	transform.matrix[0][0] = XDoubleToFixed(xScalingFactor);

	transform.matrix[0][1] = XDoubleToFixed(0.0);

	transform.matrix[0][2] = XDoubleToFixed(0.0);

	transform.matrix[1][0] = XDoubleToFixed(0.0);

	transform.matrix[1][1] = XDoubleToFixed(yScalingFactor);

	transform.matrix[1][2] = XDoubleToFixed(0.0);

	transform.matrix[2][0] = XDoubleToFixed(0.0);

	transform.matrix[2][1] = XDoubleToFixed(0.0);

	transform.matrix[2][2] = XDoubleToFixed(1.0);

	/* calculate and fix up scaled coordinates */

	x2 = x + w;

	y2 = y + h;

	x = floor(x / xScalingFactor) - 1;

	y = floor(y / yScalingFactor) - 1;

	w = ceil(x2 / xScalingFactor) + 1 - x;

	h = ceil(y2 / yScalingFactor) + 1 - y;

	XRenderSetPictureTransform(xfc->display, primaryPicture, &transform);

	XRenderComposite(xfc->display, PictOpSrc, primaryPicture, 0, windowPicture, x, y, 0, 0,

	                 xfc->offset_x + x, xfc->offset_y + y, w, h);

	XRenderFreePicture(xfc->display, primaryPicture);

	XRenderFreePicture(xfc->display, windowPicture);

}

BOOL xf_picture_transform_required(xfContext* xfc)

{

	rdpSettings* settings = xfc->context.settings;

	if ((xfc->offset_x != 0) || (xfc->offset_y != 0) ||

	    (xfc->scaledWidth != (INT64)settings->DesktopWidth) ||

	    (xfc->scaledHeight != (INT64)settings->DesktopHeight))

	{

		return TRUE;

	}

	return FALSE;

}

#endif /* WITH_XRENDER defined */

void xf_draw_screen_(xfContext* xfc, int x, int y, int w, int h, const char* fkt, const char* file,

                     int line)

{

	if (!xfc)

	{

		WLog_DBG(TAG, "[%s] called from [%s] xfc=%p", __FUNCTION__, fkt, xfc);

		return;

	}

	if (w == 0 || h == 0)

	{

		WLog_WARN(TAG, "invalid width and/or height specified: w=%d h=%d", w, h);

		return;

	}

#ifdef WITH_XRENDER

	if (xf_picture_transform_required(xfc))

	{

		xf_draw_screen_scaled(xfc, x, y, w, h);

		return;

	}

#endif

	XCopyArea(xfc->display, xfc->primary, xfc->window->handle, xfc->gc, x, y, w, h, x, y);

}

static BOOL xf_desktop_resize(rdpContext* context)

{

	rdpSettings* settings;

	xfContext* xfc = (xfContext*)context;

	settings = context->settings;

	if (xfc->primary)

	{

		BOOL same = (xfc->primary == xfc->drawing) ? TRUE : FALSE;

		XFreePixmap(xfc->display, xfc->primary);

		if (!(xfc->primary = XCreatePixmap(xfc->display, xfc->drawable, settings->DesktopWidth,

		                                   settings->DesktopHeight, xfc->depth)))

			return FALSE;

		if (same)

			xfc->drawing = xfc->primary;

	}

#ifdef WITH_XRENDER

	if (!xfc->context.settings->SmartSizing)

	{

		xfc->scaledWidth = settings->DesktopWidth;

		xfc->scaledHeight = settings->DesktopHeight;

	}

#endif

	if (!xfc->fullscreen)

	{

		xf_ResizeDesktopWindow(xfc, xfc->window, settings->DesktopWidth, settings->DesktopHeight);

	}

	else

	{

#ifdef WITH_XRENDER

		if (!xfc->context.settings->SmartSizing)

#endif

		{

			/* Update the saved width and height values the window will be

			 * resized to when toggling out of fullscreen */

			xfc->savedWidth = settings->DesktopWidth;

			xfc->savedHeight = settings->DesktopHeight;

		}

		XSetFunction(xfc->display, xfc->gc, GXcopy);

		XSetFillStyle(xfc->display, xfc->gc, FillSolid);

		XSetForeground(xfc->display, xfc->gc, 0);

		XFillRectangle(xfc->display, xfc->drawable, xfc->gc, 0, 0, xfc->window->width,

		               xfc->window->height);

	}

	return TRUE;

}

static BOOL xf_sw_end_paint(rdpContext* context)

{

	int i;

	INT32 x, y;

	UINT32 w, h;

	int ninvalid;

	HGDI_RGN cinvalid;

	xfContext* xfc = (xfContext*)context;

	rdpGdi* gdi = context->gdi;

	if (gdi->suppressOutput)

		return TRUE;

	x = gdi->primary->hdc->hwnd->invalid->x;

	y = gdi->primary->hdc->hwnd->invalid->y;

	w = gdi->primary->hdc->hwnd->invalid->w;

	h = gdi->primary->hdc->hwnd->invalid->h;

	ninvalid = gdi->primary->hdc->hwnd->ninvalid;

	cinvalid = gdi->primary->hdc->hwnd->cinvalid;

	if (!xfc->remote_app)

	{

		if (!xfc->complex_regions)

		{

			if (gdi->primary->hdc->hwnd->invalid->null)

				return TRUE;

			xf_lock_x11(xfc);

			XPutImage(xfc->display, xfc->primary, xfc->gc, xfc->image, x, y, x, y, w, h);

			xf_draw_screen(xfc, x, y, w, h);

			xf_unlock_x11(xfc);

		}

		else

		{

			if (gdi->primary->hdc->hwnd->ninvalid < 1)

				return TRUE;

			xf_lock_x11(xfc);

			for (i = 0; i < ninvalid; i++)

			{

				x = cinvalid[i].x;

				y = cinvalid[i].y;

				w = cinvalid[i].w;

				h = cinvalid[i].h;

				XPutImage(xfc->display, xfc->primary, xfc->gc, xfc->image, x, y, x, y, w, h);

				xf_draw_screen(xfc, x, y, w, h);

			}

			XFlush(xfc->display);

			xf_unlock_x11(xfc);

		}

	}

	else

	{

		if (gdi->primary->hdc->hwnd->invalid->null)

			return TRUE;

		xf_lock_x11(xfc);

		xf_rail_paint(xfc, x, y, x + w, y + h);

		xf_unlock_x11(xfc);

	}

	gdi->primary->hdc->hwnd->invalid->null = TRUE;

	gdi->primary->hdc->hwnd->ninvalid = 0;

	return TRUE;

}

static BOOL xf_sw_desktop_resize(rdpContext* context)

{

	rdpGdi* gdi = context->gdi;

	xfContext* xfc = (xfContext*)context;

	rdpSettings* settings = context->settings;

	BOOL ret = FALSE;

	xf_lock_x11(xfc);

	if (!gdi_resize(gdi, settings->DesktopWidth, settings->DesktopHeight))

		goto out;

	if (xfc->image)

	{

		xfc->image->data = NULL;

		XDestroyImage(xfc->image);

	}

	if (!(xfc->image = XCreateImage(xfc->display, xfc->visual, xfc->depth, ZPixmap, 0,

	                                (char*)gdi->primary_buffer, gdi->width, gdi->height,

	                                xfc->scanline_pad, gdi->stride)))

	{

		goto out;

	}

	xfc->image->byte_order = LSBFirst;

	xfc->image->bitmap_bit_order = LSBFirst;

	ret = xf_desktop_resize(context);

out:

	xf_unlock_x11(xfc);

	return ret;

}

static BOOL xf_hw_end_paint(rdpContext* context)

{

	INT32 x, y;

	UINT32 w, h;

	xfContext* xfc = (xfContext*)context;

	if (xfc->context.gdi->suppressOutput)

		return TRUE;

	if (!xfc->remote_app)

	{

		if (!xfc->complex_regions)

		{

			if (xfc->hdc->hwnd->invalid->null)

				return TRUE;

			x = xfc->hdc->hwnd->invalid->x;

			y = xfc->hdc->hwnd->invalid->y;

			w = xfc->hdc->hwnd->invalid->w;

			h = xfc->hdc->hwnd->invalid->h;

			xf_lock_x11(xfc);

			xf_draw_screen(xfc, x, y, w, h);

			xf_unlock_x11(xfc);

		}

		else

		{

			int i;

			int ninvalid;

			HGDI_RGN cinvalid;

			if (xfc->hdc->hwnd->ninvalid < 1)

				return TRUE;

			ninvalid = xfc->hdc->hwnd->ninvalid;

			cinvalid = xfc->hdc->hwnd->cinvalid;

			xf_lock_x11(xfc);

			for (i = 0; i < ninvalid; i++)

			{

				x = cinvalid[i].x;

				y = cinvalid[i].y;

				w = cinvalid[i].w;

				h = cinvalid[i].h;

				xf_draw_screen(xfc, x, y, w, h);

			}

			XFlush(xfc->display);

			xf_unlock_x11(xfc);

		}

	}

	else

	{

		if (xfc->hdc->hwnd->invalid->null)

			return TRUE;

		x = xfc->hdc->hwnd->invalid->x;

		y = xfc->hdc->hwnd->invalid->y;

		w = xfc->hdc->hwnd->invalid->w;

		h = xfc->hdc->hwnd->invalid->h;

		xf_lock_x11(xfc);

		xf_rail_paint(xfc, x, y, x + w, y + h);

		xf_unlock_x11(xfc);

	}

	xfc->hdc->hwnd->invalid->null = TRUE;

	xfc->hdc->hwnd->ninvalid = 0;

	return TRUE;

}

static BOOL xf_hw_desktop_resize(rdpContext* context)

{

	rdpGdi* gdi = context->gdi;

	xfContext* xfc = (xfContext*)context;

	rdpSettings* settings = context->settings;

	BOOL ret = FALSE;

	xf_lock_x11(xfc);

	if (!gdi_resize(gdi, settings->DesktopWidth, settings->DesktopHeight))

		goto out;

	ret = xf_desktop_resize(context);

out:

	xf_unlock_x11(xfc);

	return ret;

}

static BOOL xf_process_x_events(freerdp* instance)

{

	BOOL status;

	XEvent xevent;

	int pending_status;

	xfContext* xfc = (xfContext*)instance->context;

	status = TRUE;

	pending_status = TRUE;

	while (pending_status)

	{

		xf_lock_x11(xfc);

		pending_status = XPending(xfc->display);

		if (pending_status)

		{

			ZeroMemory(&xevent, sizeof(xevent));

			XNextEvent(xfc->display, &xevent);

			status = xf_event_process(instance, &xevent);

		}

		xf_unlock_x11(xfc);

		if (!status)

			break;

	}

	return status;

}

static char* xf_window_get_title(rdpSettings* settings)

{

	BOOL port;

	char* windowTitle;

	size_t size;

	char* name;

	const char* prefix = "FreeRDP:";

	if (!settings)

		return NULL;

	name = settings->ServerHostname;

	if (settings->WindowTitle)

		return _strdup(settings->WindowTitle);

	port = (settings->ServerPort != 3389);

	/* Just assume a window title is never longer than a filename... */

	size = strnlen(name, MAX_PATH) + 16;

	windowTitle = calloc(size, sizeof(char));

	if (!windowTitle)

		return NULL;

	if (!port)

		sprintf_s(windowTitle, size, "%s %s", prefix, name);

	else

		sprintf_s(windowTitle, size, "%s %s:%i", prefix, name, settings->ServerPort);

	return windowTitle;

}

BOOL xf_create_window(xfContext* xfc)

{

	XGCValues gcv;

	XEvent xevent;

	int width, height;

	char* windowTitle;

	rdpGdi* gdi;

	rdpSettings* settings;

	settings = xfc->context.settings;

	gdi = xfc->context.gdi;

	ZeroMemory(&xevent, sizeof(xevent));

	width = settings->DesktopWidth;

	height = settings->DesktopHeight;

	if (!xfc->hdc)

		if (!(xfc->hdc = gdi_CreateDC(gdi->dstFormat)))

			return FALSE;

	if (!xfc->remote_app)

	{

		xfc->attribs.background_pixel = BlackPixelOfScreen(xfc->screen);

		xfc->attribs.border_pixel = WhitePixelOfScreen(xfc->screen);

		xfc->attribs.backing_store = xfc->primary ? NotUseful : Always;

		xfc->attribs.override_redirect = False;

		xfc->attribs.colormap = xfc->colormap;

		xfc->attribs.bit_gravity = NorthWestGravity;

		xfc->attribs.win_gravity = NorthWestGravity;

#ifdef WITH_XRENDER

		xfc->offset_x = 0;

		xfc->offset_y = 0;

#endif

		windowTitle = xf_window_get_title(settings);

		if (!windowTitle)

			return FALSE;

#ifdef WITH_XRENDER

		if (settings->SmartSizing && !xfc->fullscreen)

		{

			if (settings->SmartSizingWidth)

				width = settings->SmartSizingWidth;

			if (settings->SmartSizingHeight)

				height = settings->SmartSizingHeight;

			xfc->scaledWidth = width;

			xfc->scaledHeight = height;

		}

#endif

		xfc->window = xf_CreateDesktopWindow(xfc, windowTitle, width, height);

		free(windowTitle);

		if (xfc->fullscreen)

			xf_SetWindowFullscreen(xfc, xfc->window, xfc->fullscreen);

		xfc->unobscured = (xevent.xvisibility.state == VisibilityUnobscured);

		XSetWMProtocols(xfc->display, xfc->window->handle, &(xfc->WM_DELETE_WINDOW), 1);

		xfc->drawable = xfc->window->handle;

	}

	else

	{

		xfc->drawable = xf_CreateDummyWindow(xfc);

	}

	ZeroMemory(&gcv, sizeof(gcv));

	if (xfc->modifierMap)

		XFreeModifiermap(xfc->modifierMap);

	xfc->modifierMap = XGetModifierMapping(xfc->display);

	if (!xfc->gc)

		xfc->gc = XCreateGC(xfc->display, xfc->drawable, GCGraphicsExposures, &gcv;;

	if (!xfc->primary)

		xfc->primary = XCreatePixmap(xfc->display, xfc->drawable, settings->DesktopWidth,

		                             settings->DesktopHeight, xfc->depth);

	xfc->drawing = xfc->primary;

	if (!xfc->bitmap_mono)

		xfc->bitmap_mono = XCreatePixmap(xfc->display, xfc->drawable, 8, 8, 1);

	if (!xfc->gc_mono)

		xfc->gc_mono = XCreateGC(xfc->display, xfc->bitmap_mono, GCGraphicsExposures, &gcv;;

	XSetFunction(xfc->display, xfc->gc, GXcopy);

	XSetFillStyle(xfc->display, xfc->gc, FillSolid);

	XSetForeground(xfc->display, xfc->gc, BlackPixelOfScreen(xfc->screen));

	XFillRectangle(xfc->display, xfc->primary, xfc->gc, 0, 0, settings->DesktopWidth,

	               settings->DesktopHeight);

	XFlush(xfc->display);

	if (!xfc->image)

	{

		rdpGdi* gdi = xfc->context.gdi;

		xfc->image = XCreateImage(xfc->display, xfc->visual, xfc->depth, ZPixmap, 0,

		                          (char*)gdi->primary_buffer, settings->DesktopWidth,

		                          settings->DesktopHeight, xfc->scanline_pad, gdi->stride);

		xfc->image->byte_order = LSBFirst;

		xfc->image->bitmap_bit_order = LSBFirst;

	}

	return TRUE;

}

static void xf_window_free(xfContext* xfc)

{

	if (xfc->window)

	{

		xf_DestroyDesktopWindow(xfc, xfc->window);

		xfc->window = NULL;

	}

	if (xfc->hdc)

	{

		gdi_DeleteDC(xfc->hdc);

		xfc->hdc = NULL;

	}

#if defined(CHANNEL_TSMF_CLIENT)

	if (xfc->xv_context)

	{

		xf_tsmf_uninit(xfc, NULL);

		xfc->xv_context = NULL;

	}

#endif

	if (xfc->image)

	{

		xfc->image->data = NULL;

		XDestroyImage(xfc->image);

		xfc->image = NULL;

	}

	if (xfc->bitmap_mono)

	{

		XFreePixmap(xfc->display, xfc->bitmap_mono);

		xfc->bitmap_mono = 0;

	}

	if (xfc->gc_mono)

	{

		XFreeGC(xfc->display, xfc->gc_mono);

		xfc->gc_mono = 0;

	}

	if (xfc->primary)

	{

		XFreePixmap(xfc->display, xfc->primary);

		xfc->primary = 0;

	}

	if (xfc->gc)

	{

		XFreeGC(xfc->display, xfc->gc);

		xfc->gc = 0;

	}

	if (xfc->modifierMap)

	{

		XFreeModifiermap(xfc->modifierMap);

		xfc->modifierMap = NULL;

	}

}

void xf_toggle_fullscreen(xfContext* xfc)

{

	WindowStateChangeEventArgs e;

	rdpContext* context = (rdpContext*)xfc;

	rdpSettings* settings = context->settings;

	/*

	  when debugging, ungrab keyboard when toggling fullscreen

	  to allow keyboard usage on the debugger

	*/

	if (xfc->debug)

	{

		XUngrabKeyboard(xfc->display, CurrentTime);

	}

	xfc->fullscreen = (xfc->fullscreen) ? FALSE : TRUE;

	xfc->decorations = (xfc->fullscreen) ? FALSE : settings->Decorations;

	xf_SetWindowFullscreen(xfc, xfc->window, xfc->fullscreen);

	EventArgsInit(&e, "xfreerdp");

	e.state = xfc->fullscreen ? FREERDP_WINDOW_STATE_FULLSCREEN : 0;

	PubSub_OnWindowStateChange(context->pubSub, context, &e);

}

BOOL xf_toggle_control(xfContext* xfc)

{

	EncomspClientContext* encomsp;

	ENCOMSP_CHANGE_PARTICIPANT_CONTROL_LEVEL_PDU pdu;

	encomsp = xfc->encomsp;

	if (!encomsp)

		return FALSE;

	pdu.ParticipantId = 0;

	pdu.Flags = ENCOMSP_REQUEST_VIEW;

	if (!xfc->controlToggle)

		pdu.Flags |= ENCOMSP_REQUEST_INTERACT;

	encomsp->ChangeParticipantControlLevel(encomsp, &pdu);

	xfc->controlToggle = !xfc->controlToggle;

	return TRUE;

}

/**

 * Function description

 *

 * @return 0 on success, otherwise a Win32 error code

 */

static UINT

xf_encomsp_participant_created(EncomspClientContext* context,

                               const ENCOMSP_PARTICIPANT_CREATED_PDU* participantCreated)

{

	xfContext* xfc;

	rdpSettings* settings;

	BOOL request;

	if (!context || !context->custom || !participantCreated)

		return ERROR_INVALID_PARAMETER;

	xfc = context->custom;

	settings = xfc->context.settings;

	if (!settings)

		return ERROR_INVALID_PARAMETER;

	request = freerdp_settings_get_bool(settings, FreeRDP_RemoteAssistanceRequestControl);

	if (request && (participantCreated->Flags & ENCOMSP_MAY_VIEW) &&

	    !(participantCreated->Flags & ENCOMSP_MAY_INTERACT))

		xf_toggle_control(xfc);

	return CHANNEL_RC_OK;

}

void xf_encomsp_init(xfContext* xfc, EncomspClientContext* encomsp)

{

	xfc->encomsp = encomsp;

	encomsp->custom = (void*)xfc;

	encomsp->ParticipantCreated = xf_encomsp_participant_created;

}

void xf_encomsp_uninit(xfContext* xfc, EncomspClientContext* encomsp)

{

	WINPR_UNUSED(encomsp);

	xfc->encomsp = NULL;

}

void xf_lock_x11_(xfContext* xfc, const char* fkt)

{

	if (!xfc->UseXThreads)

		WaitForSingleObject(xfc->mutex, INFINITE);

	else

		XLockDisplay(xfc->display);

	if (xfc->locked)

		WLog_WARN(TAG, "%s:\t[%" PRIu32 "] recursive lock from %s", __FUNCTION__, xfc->locked, fkt);

	xfc->locked++;

	WLog_VRB(TAG, "%s:\t[%" PRIu32 "] from %s", __FUNCTION__, xfc->locked, fkt);

}

void xf_unlock_x11_(xfContext* xfc, const char* fkt)

{

	if (xfc->locked == 0)

		WLog_WARN(TAG, "X11: trying to unlock although not locked!");

	WLog_VRB(TAG, "%s:\t[%" PRIu32 "] from %s", __FUNCTION__, xfc->locked - 1, fkt);

	if (!xfc->UseXThreads)

		ReleaseMutex(xfc->mutex);

	else

		XUnlockDisplay(xfc->display);

	xfc->locked--;

}

static BOOL xf_get_pixmap_info(xfContext* xfc)

{

	int i;

	int vi_count;

	int pf_count;

	XVisualInfo* vi;

	XVisualInfo* vis;

	XVisualInfo tpl;

	XPixmapFormatValues* pf;

	XPixmapFormatValues* pfs;

	XWindowAttributes window_attributes;

	assert(xfc->display);

	pfs = XListPixmapFormats(xfc->display, &pf_count);

	if (!pfs)

	{

		WLog_ERR(TAG, "XListPixmapFormats failed");

		return 1;

	}

	for (i = 0; i < pf_count; i++)

	{

		pf = pfs + i;

		if (pf->depth == xfc->depth)

		{

			xfc->scanline_pad = pf->scanline_pad;

			break;

		}

	}

	XFree(pfs);

	ZeroMemory(&tpl, sizeof(tpl));

	tpl.class = TrueColor;

	tpl.screen = xfc->screen_number;

	if (XGetWindowAttributes(xfc->display, RootWindowOfScreen(xfc->screen), &window_attributes) ==

	    0)

	{

		WLog_ERR(TAG, "XGetWindowAttributes failed");

		return FALSE;

	}

	vis = XGetVisualInfo(xfc->display, VisualClassMask | VisualScreenMask, &tpl, &vi_count);