/**
* FreeRDP: A Remote Desktop Protocol Implementation
* Windows Float Bar
*
* Copyright 2013 Zhang Zhaolong <zhangzl2013@126.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <winpr/crt.h>
#include <winpr/windows.h>
#include "resource.h"
#include "wf_client.h"
#include "wf_floatbar.h"
#include "wf_gdi.h"
#pragma comment(lib, "Msimg32.lib")
#define TAG CLIENT_TAG("windows.floatbar")
typedef struct _Button Button;
/* TIMERs */
#define TIMER_HIDE 1
#define TIMER_ANIMAT_SHOW 2
#define TIMER_ANIMAT_HIDE 3
/* Button Type */
#define BUTTON_LOCKPIN 0
#define BUTTON_MINIMIZE 1
#define BUTTON_RESTORE 2
#define BUTTON_CLOSE 3
#define BTN_MAX 4
/* bmp size */
#define BACKGROUND_W 576
#define BACKGROUND_H 27
#define BUTTON_OFFSET 5
#define BUTTON_Y 2
#define BUTTON_WIDTH 23
#define BUTTON_HEIGHT 21
#define BUTTON_SPACING 1
#define LOCK_X (BACKGROUND_H + BUTTON_OFFSET)
#define CLOSE_X ((BACKGROUND_W - (BACKGROUND_H + BUTTON_OFFSET)) - BUTTON_WIDTH)
#define RESTORE_X (CLOSE_X - (BUTTON_WIDTH + BUTTON_SPACING))
#define MINIMIZE_X (RESTORE_X - (BUTTON_WIDTH + BUTTON_SPACING))
#define TEXT_X (BACKGROUND_H + ((BUTTON_WIDTH + BUTTON_SPACING) * 3) + 5)
struct _Button
{
wfFloatBar* floatbar;
int type;
int x, y, h, w;
int active;
HBITMAP bmp;
HBITMAP bmp_act;
/* Lock Specified */
HBITMAP locked_bmp;
HBITMAP locked_bmp_act;
HBITMAP unlocked_bmp;
HBITMAP unlocked_bmp_act;
};
struct _FloatBar
{
HINSTANCE root_window;
DWORD flags;
HWND parent;
HWND hwnd;
RECT rect;
LONG width;
LONG height;
LONG offset;
wfContext* wfc;
Button* buttons[BTN_MAX];
BOOL shown;
BOOL locked;
HDC hdcmem;
RECT textRect;
UINT_PTR animating;
};
static BOOL floatbar_kill_timers(wfFloatBar* floatbar)
{
size_t x;
UINT_PTR timers[] = { TIMER_HIDE, TIMER_ANIMAT_HIDE, TIMER_ANIMAT_SHOW };
if (!floatbar)
return FALSE;
for (x = 0; x < ARRAYSIZE(timers); x++)
KillTimer(floatbar->hwnd, timers[x]);
floatbar->animating = 0;
return TRUE;
}
static BOOL floatbar_animation(wfFloatBar* const floatbar, const BOOL show)
{
UINT_PTR timer = show ? TIMER_ANIMAT_SHOW : TIMER_ANIMAT_HIDE;
if (!floatbar)
return FALSE;
if (floatbar->shown == show)
return TRUE;
if (floatbar->animating == timer)
return TRUE;
floatbar->animating = timer;
if (SetTimer(floatbar->hwnd, timer, USER_TIMER_MINIMUM, NULL) == NULL)
{
DWORD err = GetLastError();
WLog_ERR(TAG, "SetTimer failed with %08" PRIx32, err);
return FALSE;
}
return TRUE;
}
static BOOL floatbar_trigger_hide(wfFloatBar* floatbar)
{
if (!floatbar_kill_timers(floatbar))
return FALSE;
if (!floatbar->locked && floatbar->shown)
{
if (SetTimer(floatbar->hwnd, TIMER_HIDE, 3000, NULL) == NULL)
{
DWORD err = GetLastError();
WLog_ERR(TAG, "SetTimer failed with %08" PRIx32, err);
return FALSE;
}
}
return TRUE;
}
static BOOL floatbar_hide(wfFloatBar* floatbar)
{
if (!floatbar_kill_timers(floatbar))
return FALSE;
floatbar->offset = floatbar->height - 2;
if (!MoveWindow(floatbar->hwnd, floatbar->rect.left, -floatbar->offset, floatbar->width,
floatbar->height, TRUE))
{
DWORD err = GetLastError();
WLog_ERR(TAG, "MoveWindow failed with %08" PRIx32, err);
return FALSE;
}
floatbar->shown = FALSE;
if (!floatbar_trigger_hide(floatbar))
return FALSE;
return TRUE;
}
static BOOL floatbar_show(wfFloatBar* floatbar)
{
if (!floatbar_kill_timers(floatbar))
return FALSE;
floatbar->offset = 0;
if (!MoveWindow(floatbar->hwnd, floatbar->rect.left, -floatbar->offset, floatbar->width,
floatbar->height, TRUE))
{
DWORD err = GetLastError();
WLog_ERR(TAG, "MoveWindow failed with %08" PRIx32, err);
return FALSE;
}
floatbar->shown = TRUE;
if (!floatbar_trigger_hide(floatbar))
return FALSE;
return TRUE;
}
static BOOL button_set_locked(Button* button, BOOL locked)
{
if (locked)
{
button->bmp = button->locked_bmp;
button->bmp_act = button->locked_bmp_act;
}
else
{
button->bmp = button->unlocked_bmp;
button->bmp_act = button->unlocked_bmp_act;
}
InvalidateRect(button->floatbar->hwnd, NULL, FALSE);
UpdateWindow(button->floatbar->hwnd);
return TRUE;
}
static BOOL update_locked_state(wfFloatBar* floatbar)
{
Button* button;
if (!floatbar)
return FALSE;
button = floatbar->buttons[3];
if (!button_set_locked(button, floatbar->locked))
return FALSE;
return TRUE;
}
static int button_hit(Button* const button)
{
wfFloatBar* const floatbar = button->floatbar;
switch (button->type)
{
case BUTTON_LOCKPIN:
floatbar->locked = !floatbar->locked;
update_locked_state(floatbar);
break;
case BUTTON_MINIMIZE:
ShowWindow(floatbar->parent, SW_MINIMIZE);
break;
case BUTTON_RESTORE:
wf_toggle_fullscreen(floatbar->wfc);
break;
case BUTTON_CLOSE:
SendMessage(floatbar->parent, WM_DESTROY, 0, 0);
break;
default:
return 0;
}
return 0;
}
static int button_paint(const Button* const button, const HDC hdc)
{
if (button != NULL)
{
wfFloatBar* floatbar = button->floatbar;
BLENDFUNCTION bf;
SelectObject(floatbar->hdcmem, button->active ? button->bmp_act : button->bmp);
bf.BlendOp = AC_SRC_OVER;
bf.BlendFlags = 0;
bf.SourceConstantAlpha = 255;
bf.AlphaFormat = AC_SRC_ALPHA;
AlphaBlend(hdc, button->x, button->y, button->w, button->h, floatbar->hdcmem, 0, 0,
button->w, button->h, bf);
}
return 0;
}
static Button* floatbar_create_button(wfFloatBar* const floatbar, const int type, const int resid,
const int resid_act, const int x, const int y, const int h,
const int w)
{
Button* button = (Button*)calloc(1, sizeof(Button));
if (!button)
return NULL;
button->floatbar = floatbar;
button->type = type;
button->x = x;
button->y = y;
button->w = w;
button->h = h;
button->active = FALSE;
button->bmp = (HBITMAP)LoadImage(floatbar->root_window, MAKEINTRESOURCE(resid), IMAGE_BITMAP, 0,
0, LR_DEFAULTCOLOR);
button->bmp_act = (HBITMAP)LoadImage(floatbar->root_window, MAKEINTRESOURCE(resid_act),
IMAGE_BITMAP, 0, 0, LR_DEFAULTCOLOR);
return button;
}
static Button* floatbar_create_lock_button(wfFloatBar* const floatbar, const int unlock_resid,
const int unlock_resid_act, const int lock_resid,
const int lock_resid_act, const int x, const int y,
const int h, const int w)
{
Button* button = floatbar_create_button(floatbar, BUTTON_LOCKPIN, unlock_resid,
unlock_resid_act, x, y, h, w);
if (!button)
return NULL;
button->unlocked_bmp = button->bmp;
button->unlocked_bmp_act = button->bmp_act;
button->locked_bmp = (HBITMAP)LoadImage(floatbar->wfc->hInstance, MAKEINTRESOURCE(lock_resid),
IMAGE_BITMAP, 0, 0, LR_DEFAULTCOLOR);
button->locked_bmp_act =
(HBITMAP)LoadImage(floatbar->wfc->hInstance, MAKEINTRESOURCE(lock_resid_act), IMAGE_BITMAP,
0, 0, LR_DEFAULTCOLOR);
return button;
}
static Button* floatbar_get_button(const wfFloatBar* const floatbar, const int x, const int y)
{
int i;
if ((y > BUTTON_Y) && (y < BUTTON_Y + BUTTON_HEIGHT))
{
for (i = 0; i < BTN_MAX; i++)
{
if ((floatbar->buttons[i] != NULL) && (x > floatbar->buttons[i]->x) &&
(x < floatbar->buttons[i]->x + floatbar->buttons[i]->w))
{
return floatbar->buttons[i];
}
}
}
return NULL;
}
static BOOL floatbar_paint(wfFloatBar* const floatbar, const HDC hdc)
{
int i;
HPEN hpen;
HGDIOBJECT orig;
/* paint background */
GRADIENT_RECT gradientRect = { 0, 1 };
COLORREF rgbTop = RGB(117, 154, 198);
COLORREF rgbBottom = RGB(6, 55, 120);
const int top = 0;
int left = 0;
int bottom = BACKGROUND_H - 1;
int right = BACKGROUND_W - 1;
const int angleOffset = BACKGROUND_H - 1;
TRIVERTEX triVertext[2] = { left,
top,
GetRValue(rgbTop) << 8,
GetGValue(rgbTop) << 8,
GetBValue(rgbTop) << 8,
0x0000,
right,
bottom,
GetRValue(rgbBottom) << 8,
GetGValue(rgbBottom) << 8,
GetBValue(rgbBottom) << 8,
0x0000 };
if (!floatbar)
return FALSE;
GradientFill(hdc, triVertext, 2, &gradientRect, 1, GRADIENT_FILL_RECT_V);
/* paint shadow */
hpen = CreatePen(PS_SOLID, 1, RGB(71, 71, 71));
orig = SelectObject(hdc, hpen);
MoveToEx(hdc, left, top, NULL);
LineTo(hdc, left + angleOffset, bottom);
LineTo(hdc, right - angleOffset, bottom);
LineTo(hdc, right + 1, top - 1);
DeleteObject(hpen);
hpen = CreatePen(PS_SOLID, 1, RGB(107, 141, 184));
SelectObject(hdc, hpen);
left += 1;
bottom -= 1;
right -= 1;
MoveToEx(hdc, left, top, NULL);
LineTo(hdc, left + (angleOffset - 1), bottom);
LineTo(hdc, right - (angleOffset - 1), bottom);
LineTo(hdc, right + 1, top - 1);
DeleteObject(hpen);
SelectObject(hdc, orig);
DrawText(hdc, floatbar->wfc->window_title, wcslen(floatbar->wfc->window_title),
&floatbar->textRect,
DT_CENTER | DT_VCENTER | DT_END_ELLIPSIS | DT_NOPREFIX | DT_SINGLELINE);
/* paint buttons */
for (i = 0; i < BTN_MAX; i++)
button_paint(floatbar->buttons[i], hdc);
return TRUE;
}
static LRESULT CALLBACK floatbar_proc(const HWND hWnd, const UINT Msg, const WPARAM wParam,
const LPARAM lParam)
{
static int dragging = FALSE;
static int lbtn_dwn = FALSE;
static int btn_dwn_x = 0;
static wfFloatBar* floatbar;
static TRACKMOUSEEVENT tme;
PAINTSTRUCT ps;
Button* button;
HDC hdc;
int pos_x;
int pos_y;
NONCLIENTMETRICS ncm;
int xScreen = GetSystemMetrics(SM_CXSCREEN);
switch (Msg)
{
case WM_CREATE:
floatbar = ((wfFloatBar*)((CREATESTRUCT*)lParam)->lpCreateParams);
floatbar->hwnd = hWnd;
GetWindowRect(floatbar->hwnd, &floatbar->rect);
floatbar->width = floatbar->rect.right - floatbar->rect.left;
floatbar->height = floatbar->rect.bottom - floatbar->rect.top;
hdc = GetDC(hWnd);
floatbar->hdcmem = CreateCompatibleDC(hdc);
ReleaseDC(hWnd, hdc);
tme.cbSize = sizeof(TRACKMOUSEEVENT);
tme.dwFlags = TME_LEAVE;
tme.hwndTrack = hWnd;
tme.dwHoverTime = HOVER_DEFAULT;
// Use caption font, white, draw transparent
GetClientRect(hWnd, &floatbar->textRect);
InflateRect(&floatbar->textRect, -TEXT_X, 0);
SetBkMode(hdc, TRANSPARENT);
SetTextColor(hdc, RGB(255, 255, 255));
ncm.cbSize = sizeof(NONCLIENTMETRICS);
SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(NONCLIENTMETRICS), &ncm, 0);
SelectObject(hdc, CreateFontIndirect(&ncm.lfCaptionFont));
floatbar_trigger_hide(floatbar);
break;
case WM_PAINT:
hdc = BeginPaint(hWnd, &ps);
floatbar_paint(floatbar, hdc);
EndPaint(hWnd, &ps);
break;
case WM_LBUTTONDOWN:
pos_x = lParam & 0xffff;
pos_y = (lParam >> 16) & 0xffff;
button = floatbar_get_button(floatbar, pos_x, pos_y);
if (!button)
{
SetCapture(hWnd);
dragging = TRUE;
btn_dwn_x = lParam & 0xffff;
}
else
lbtn_dwn = TRUE;
break;
case WM_LBUTTONUP:
pos_x = lParam & 0xffff;
pos_y = (lParam >> 16) & 0xffff;
ReleaseCapture();
dragging = FALSE;
if (lbtn_dwn)
{
button = floatbar_get_button(floatbar, pos_x, pos_y);
if (button)
button_hit(button);
lbtn_dwn = FALSE;
}
break;
case WM_MOUSEMOVE:
pos_x = lParam & 0xffff;
pos_y = (lParam >> 16) & 0xffff;
if (!floatbar->locked)
floatbar_animation(floatbar, TRUE);
if (dragging)
{
floatbar->rect.left = floatbar->rect.left + (lParam & 0xffff) - btn_dwn_x;
if (floatbar->rect.left < 0)
floatbar->rect.left = 0;
else if (floatbar->rect.left > xScreen - floatbar->width)
floatbar->rect.left = xScreen - floatbar->width;
MoveWindow(hWnd, floatbar->rect.left, 0, floatbar->width, floatbar->height, TRUE);
}
else
{
int i;
for (i = 0; i < BTN_MAX; i++)
{
if (floatbar->buttons[i] != NULL)
{
floatbar->buttons[i]->active = FALSE;
}
}
button = floatbar_get_button(floatbar, pos_x, pos_y);
if (button)
button->active = TRUE;
InvalidateRect(hWnd, NULL, FALSE);
UpdateWindow(hWnd);
}
TrackMouseEvent(&tme);
break;
case WM_CAPTURECHANGED:
dragging = FALSE;
break;
case WM_MOUSELEAVE:
{
int i;
for (i = 0; i < BTN_MAX; i++)
{
if (floatbar->buttons[i] != NULL)
{
floatbar->buttons[i]->active = FALSE;
}
}
InvalidateRect(hWnd, NULL, FALSE);
UpdateWindow(hWnd);
floatbar_trigger_hide(floatbar);
break;
}
case WM_TIMER:
switch (wParam)
{
case TIMER_HIDE:
floatbar_animation(floatbar, FALSE);
break;
case TIMER_ANIMAT_SHOW:
{
floatbar->offset--;
MoveWindow(floatbar->hwnd, floatbar->rect.left, -floatbar->offset,
floatbar->width, floatbar->height, TRUE);
if (floatbar->offset <= 0)
floatbar_show(floatbar);
break;
}
case TIMER_ANIMAT_HIDE:
{
floatbar->offset++;
MoveWindow(floatbar->hwnd, floatbar->rect.left, -floatbar->offset,
floatbar->width, floatbar->height, TRUE);
if (floatbar->offset >= floatbar->height - 2)
floatbar_hide(floatbar);
break;
}
default:
break;
}
break;
case WM_DESTROY:
DeleteDC(floatbar->hdcmem);
PostQuitMessage(0);
break;
default:
return DefWindowProc(hWnd, Msg, wParam, lParam);
}
return 0;
}
static BOOL floatbar_window_create(wfFloatBar* floatbar)
{
WNDCLASSEX wnd_cls;
HWND barWnd;
HRGN hRgn;
POINT pt[4];
RECT rect;
LONG x;
if (!floatbar)
return FALSE;
if (!GetWindowRect(floatbar->parent, &rect))
return FALSE;
x = (rect.right - rect.left - BACKGROUND_W) / 2;
wnd_cls.cbSize = sizeof(WNDCLASSEX);
wnd_cls.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
wnd_cls.lpfnWndProc = floatbar_proc;
wnd_cls.cbClsExtra = 0;
wnd_cls.cbWndExtra = 0;
wnd_cls.hIcon = LoadIcon(NULL, IDI_APPLICATION);
wnd_cls.hCursor = LoadCursor(floatbar->root_window, IDC_ARROW);
wnd_cls.hbrBackground = NULL;
wnd_cls.lpszMenuName = NULL;
wnd_cls.lpszClassName = L"floatbar";
wnd_cls.hInstance = floatbar->root_window;
wnd_cls.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
RegisterClassEx(&wnd_cls);
barWnd = CreateWindowEx(WS_EX_TOPMOST, L"floatbar", L"floatbar", WS_CHILD, x, 0, BACKGROUND_W,
BACKGROUND_H, floatbar->parent, NULL, floatbar->root_window, floatbar);
if (barWnd == NULL)
return FALSE;
pt[0].x = 0;
pt[0].y = 0;
pt[1].x = BACKGROUND_W;
pt[1].y = 0;
pt[2].x = BACKGROUND_W - BACKGROUND_H;
pt[2].y = BACKGROUND_H;
pt[3].x = BACKGROUND_H;
pt[3].y = BACKGROUND_H;
hRgn = CreatePolygonRgn(pt, 4, ALTERNATE);
SetWindowRgn(barWnd, hRgn, TRUE);
return TRUE;
}
void wf_floatbar_free(wfFloatBar* floatbar)
{
if (!floatbar)
return;
free(floatbar);
}
wfFloatBar* wf_floatbar_new(wfContext* wfc, HINSTANCE window, DWORD flags)
{
wfFloatBar* floatbar;
/* Floatbar not enabled */
if ((flags & 0x0001) == 0)
return NULL;
if (!wfc)
return NULL;
// TODO: Disable for remote app
floatbar = (wfFloatBar*)calloc(1, sizeof(wfFloatBar));
if (!floatbar)
return NULL;
floatbar->root_window = window;
floatbar->flags = flags;
floatbar->wfc = wfc;
floatbar->locked = (flags & 0x0002) != 0;
floatbar->shown = (flags & 0x0006) != 0; /* If it is loked or shown show it */
floatbar->hwnd = NULL;
floatbar->parent = wfc->hwnd;
floatbar->hdcmem = NULL;
if (wfc->fullscreen_toggle)
{
floatbar->buttons[0] =
floatbar_create_button(floatbar, BUTTON_MINIMIZE, IDB_MINIMIZE, IDB_MINIMIZE_ACT,
MINIMIZE_X, BUTTON_Y, BUTTON_HEIGHT, BUTTON_WIDTH);
floatbar->buttons[1] =
floatbar_create_button(floatbar, BUTTON_RESTORE, IDB_RESTORE, IDB_RESTORE_ACT,
RESTORE_X, BUTTON_Y, BUTTON_HEIGHT, BUTTON_WIDTH);
}
else
{
floatbar->buttons[0] = NULL;
floatbar->buttons[1] = NULL;
}
floatbar->buttons[2] = floatbar_create_button(floatbar, BUTTON_CLOSE, IDB_CLOSE, IDB_CLOSE_ACT,
CLOSE_X, BUTTON_Y, BUTTON_HEIGHT, BUTTON_WIDTH);
floatbar->buttons[3] =
floatbar_create_lock_button(floatbar, IDB_UNLOCK, IDB_UNLOCK_ACT, IDB_LOCK, IDB_LOCK_ACT,
LOCK_X, BUTTON_Y, BUTTON_HEIGHT, BUTTON_WIDTH);
if (!floatbar_window_create(floatbar))
goto fail;
if (!update_locked_state(floatbar))
goto fail;
if (!wf_floatbar_toggle_fullscreen(floatbar, wfc->context.settings->Fullscreen))
goto fail;
return floatbar;
fail:
wf_floatbar_free(floatbar);
return NULL;
}
BOOL wf_floatbar_toggle_fullscreen(wfFloatBar* floatbar, BOOL fullscreen)
{
BOOL show_fs, show_wn;
if (!floatbar)
return FALSE;
show_fs = (floatbar->flags & 0x0010) != 0;
show_wn = (floatbar->flags & 0x0020) != 0;
if ((show_fs && fullscreen) || (show_wn && !fullscreen))
{
ShowWindow(floatbar->hwnd, SW_SHOWNORMAL);
Sleep(10);
if (floatbar->shown)
floatbar_show(floatbar);
else
floatbar_hide(floatbar);
}
else
{
ShowWindow(floatbar->hwnd, SW_HIDE);
}
return TRUE;
}