Cool_Tools/winamp
1
0
Fork 0
mirror of https://github.com/WinampDesktop/winamp.git synced 2024-12-18 19:55:52 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity
09cb3a54ed
winamp/Src/Plugins/Library/ml_devices/listWidget.cpp
Jef 20d28e80a5 Initial community commit
2024-09-24 14:54:57 +02:00

4096 lines
98 KiB
C++
Raw Blame History

#include "main.h"
#include "./listWidget.h"
#include "./listWidgetInternal.h"
#include <vector>
#include <strsafe.h>
#define LISTWIDGET_OFFSET_LEFT_DLU 0
#define LISTWIDGET_OFFSET_TOP_DLU 1
#define LISTWIDGET_OFFSET_BOTTOM_DLU 2
#define LISTWIDGET_CATEGORY_OFFSET_TOP_DLU 0
#define LISTWIDGET_CATEGORY_OFFSET_LEFT_DLU 1
#define LISTWIDGET_CATEGORY_SPACING_DLU 2
#define LISTWIDGET_CATEGORY_SPACING_COLLAPSED_DLU 0
#define LISTWIDGET_ITEM_OFFSET_TOP_DLU 1
#define LISTWIDGET_ITEM_OFFSET_LEFT_DLU 2
#define LISTWIDGET_ITEM_SPACING_HORZ_DLU 2
#define LISTWIDGET_ITEM_SPACING_VERT_DLU 10
#define LISTWIDGET_ITEM_TITLE_MAX_LINES 3
#define LISTWIDGET_IMAGE_MIN_HEIGHT 48
#define LISTWIDGET_IMAGE_MAX_HEIGHT 256
#define LISTWIDGET_IMAGE_DEFAULT_HEIGHT 160//128
#define LISTWIDGET_IMAGE_DEFAULT_WIDTH 160//96
#define LISTWIDGETTIMER_SHOW_COMMANDS_ID 3
#define LISTWIDGETTIMER_SHOW_COMMANDS_DELAY 75
#define LISTWIDGETTIMER_PROGRESS_TICK_ID 4
#define LISTWIDGETTIMER_PROGRESS_TICK_DELAY 130
#define LISTWIDGETTIMER_EDIT_TITLE_ID 5
#define LISTWIDGET_CONNECTION_MIN_HEIGHT 20
#define LISTWIDGET_CONNECTION_MAX_HEIGHT 48
#define LISTWIDGET_CONNECTION_DEFAULT_HEIGHT 36
#define LISTWIDGET_PRIMARYCOMMAND_MIN_HEIGHT 16
#define LISTWIDGET_PRIMARYCOMMAND_MAX_HEIGHT 48
#define LISTWIDGET_PRIMARYCOMMAND_DEFAULT_HEIGHT 36
#define LISTWIDGET_SECONDARYCOMMAND_MIN_HEIGHT 14
#define LISTWIDGET_SECONDARYCOMMAND_MAX_HEIGHT 36
#define LISTWIDGET_SECONDARYCOMMAND_DEFAULT_HEIGHT 20
#define LISTWIDGET_ACTIVITY_MIN_HEIGHT 16
#define LISTWIDGET_ACTIVITY_MAX_HEIGHT 48
#define LISTWIDGET_ACTIVITY_DEFAULT_HEIGHT 36
#define LISTWIDGET_PROGRESS_MIN_HEIGHT 16
#define LISTWIDGET_PROGRESS_FRAME_COUNT 9/*12*/
typedef std::vector<ifc_device*> DeviceList;
static ListWidgetCategory *
ListWidget_CreateCategoryHelper(const char *name, int titleId, wchar_t *buffer, size_t bufferMax)
{
WASABI_API_LNGSTRINGW_BUF(titleId, buffer, bufferMax);
return ListWidget_CreateCategory(name,
buffer,
Config_ReadBool("CollapsedCategories", name, FALSE));
}
static void
ListWidget_CreateDefaultCategories(ListWidget *self)
{
ListWidgetCategory *category;
wchar_t buffer[512] = {0};
category = ListWidget_CreateCategoryHelper("attached", IDS_CATEGORY_ATTACHED, buffer, ARRAYSIZE(buffer));
if (NULL != category)
{
WASABI_API_LNGSTRINGW_BUF(IDS_CATEGORY_ATTACHED_EMPTY_TEXT, buffer, ARRAYSIZE(buffer));
ListWidget_SetCategoryEmptyText(category, buffer);
self->categories.push_back(category);
}
category = ListWidget_CreateCategoryHelper("discovered", IDS_CATEGORY_DISCOVERED, buffer, ARRAYSIZE(buffer));
if (NULL != category)
self->categories.push_back(category);
}
BOOL
ListWidget_GetViewOrigin(HWND hwnd, POINT *pt)
{
SCROLLINFO scrollInfo;
if (NULL == pt)
return FALSE;
scrollInfo.cbSize = sizeof(scrollInfo);
scrollInfo.fMask = SIF_POS;
if (FALSE == GetScrollInfo(hwnd, SB_HORZ, &scrollInfo))
return FALSE;
pt->x = -scrollInfo.nPos;
if (FALSE == GetScrollInfo(hwnd, SB_VERT, &scrollInfo))
return FALSE;
pt->y = -scrollInfo.nPos;
return TRUE;
}
static HBITMAP
ListWidget_CreateSpacebarBitmap(HBITMAP sourceBitmap, HWND hwnd, long width, long height)
{
HDC windowDC, sourceDC, resultDC;
HBITMAP resultBitmap;
BITMAP sourceInfo;
RECT resultRect, sourceRect;
if (NULL == sourceBitmap ||
sizeof(sourceInfo) != GetObject(sourceBitmap, sizeof(sourceInfo), &sourceInfo))
{
return FALSE;
}
windowDC = GetDCEx(hwnd, NULL, DCX_CACHE | DCX_NORESETATTRS);
if (NULL == windowDC)
return NULL;
sourceDC = CreateCompatibleDC(windowDC);
resultDC = CreateCompatibleDC(windowDC);
resultBitmap = CreateCompatibleBitmap(windowDC, width, height*2);
ReleaseDC(hwnd, windowDC);
if (NULL != sourceDC &&
NULL != resultDC &&
NULL != resultBitmap)
{
HBITMAP prevSourceBitmap, prevResultBitmap;
prevSourceBitmap = SelectBitmap(sourceDC, sourceBitmap);
prevResultBitmap = SelectBitmap(resultDC, resultBitmap);
SetRect(&resultRect, 0, 0, width, height);
SetRect(&sourceRect, 0, 0, sourceInfo.bmWidth, ABS(sourceInfo.bmHeight)/2);
Image_FillBorder(resultDC, &resultRect, sourceDC, &sourceRect, TRUE, 255);
OffsetRect(&resultRect, 0, height);
OffsetRect(&sourceRect, 0, RECTHEIGHT(sourceRect));
Image_FillBorder(resultDC, &resultRect, sourceDC, &sourceRect, TRUE, 255);
SelectBitmap(sourceDC, prevSourceBitmap);
SelectBitmap(resultDC, prevResultBitmap);
}
if (NULL != sourceDC)
DeleteDC(sourceDC);
if (NULL != resultDC)
DeleteDC(resultDC);
if (NULL != resultBitmap)
{
RECT imageRect;
SetRect(&imageRect, 0, 0, width, height);
Image_Premultiply(resultBitmap, &imageRect);
}
return resultBitmap;
}
HBITMAP
ListWidget_GetSpacebarBitmap(ListWidget *self, WidgetStyle *style, HWND hwnd, long width, long height)
{
if (NULL == self)
return NULL;
if (NULL != self->spacebarBitmap)
{
BITMAP bi;
if (sizeof(bi) != GetObject(self->spacebarBitmap, sizeof(bi), &bi) ||
bi.bmWidth != width ||
bi.bmHeight/2 != height)
{
DeleteObject(self->spacebarBitmap);
self->spacebarBitmap = NULL;
}
}
if (NULL == self->spacebarBitmap &&
NULL != style)
{
HBITMAP baseBitmap;
baseBitmap = Image_Load(MAKEINTRESOURCE(IDR_SPACEBAR_IMAGE), SRC_TYPE_PNG, 0, 0, 0);
//WIDGETSTYLE_IMAGE_BACK_COLOR(style),
// WIDGETSTYLE_IMAGE_FRONT_COLOR(style),
// WIDGETSTYLE_BACK_COLOR(style));
if (NULL != baseBitmap)
{
DIBSECTION bitmapData;
if (sizeof(bitmapData) == GetObjectW(baseBitmap, sizeof(bitmapData), &bitmapData))
{
BITMAP *bi;
long bitmapHeight;
void *pixels;
WORD backHue, backLuma, backSat, frontHue, frontLuma, frontSat;
bi = &bitmapData.dsBm;
bitmapHeight = ABS(bi->bmHeight);
pixels = ((BYTE*)bi->bmBits) + (bi->bmWidthBytes * (bitmapHeight - bitmapHeight/2));
ColorRGBToHLS(WIDGETSTYLE_IMAGE_BACK_COLOR(style), &backHue, &backLuma, &backSat);
ColorRGBToHLS(WIDGETSTYLE_IMAGE_FRONT_COLOR(style), &frontHue, &frontLuma, &frontSat);
if (backLuma > frontLuma)
{
COLORREF backColor;
frontLuma = 25;
backColor = ColorHLSToRGB(frontHue, frontLuma, frontSat);
Image_FilterEx(pixels, bi->bmWidth, bitmapHeight/2, bi->bmBitsPixel,
0,
backColor,
WIDGETSTYLE_IMAGE_BACK_COLOR(style),
WIDGETSTYLE_BACK_COLOR(style));
}
else
{
Image_FilterEx(pixels, bi->bmWidth, bitmapHeight/2, bi->bmBitsPixel,
0,
WIDGETSTYLE_IMAGE_BACK_COLOR(style),
WIDGETSTYLE_IMAGE_FRONT_COLOR(style),
WIDGETSTYLE_BACK_COLOR(style));
}
}
Image_Premultiply(baseBitmap, NULL);
self->spacebarBitmap = ListWidget_CreateSpacebarBitmap(baseBitmap, hwnd, width, height);
DeleteObject(baseBitmap);
}
}
return self->spacebarBitmap;
}
static HBITMAP
ListWidget_CreateBorderBitmap(HBITMAP sourceBitmap, HWND hwnd, long width, long height)
{
HDC windowDC, sourceDC, resultDC;
HBITMAP resultBitmap;
BITMAP sourceInfo;
RECT resultRect, sourceRect;
if (NULL == sourceBitmap ||
sizeof(sourceInfo) != GetObject(sourceBitmap, sizeof(sourceInfo), &sourceInfo))
{
return FALSE;
}
SetRect(&resultRect, 0, 0, width, height);
SetRect(&sourceRect, 0, 0, sourceInfo.bmWidth, ABS(sourceInfo.bmHeight));
windowDC = GetDCEx(hwnd, NULL, DCX_CACHE | DCX_NORESETATTRS);
if (NULL == windowDC)
return NULL;
sourceDC = CreateCompatibleDC(windowDC);
resultDC = CreateCompatibleDC(windowDC);
resultBitmap = CreateCompatibleBitmap(windowDC, width, height);
ReleaseDC(hwnd, windowDC);
if (NULL != sourceDC &&
NULL != resultDC &&
NULL != resultBitmap)
{
HBITMAP prevSourceBitmap, prevResultBitmap;
prevSourceBitmap = SelectBitmap(sourceDC, sourceBitmap);
prevResultBitmap = SelectBitmap(resultDC, resultBitmap);
Image_FillBorder(resultDC, &resultRect, sourceDC, &sourceRect, TRUE, 255);
SelectBitmap(sourceDC, prevSourceBitmap);
SelectBitmap(resultDC, prevResultBitmap);
}
if (NULL != sourceDC)
DeleteDC(sourceDC);
if (NULL != resultDC)
DeleteDC(resultDC);
return resultBitmap;
}
static HBITMAP
ListWidget_GetBorderBitmap(HBITMAP bitmap, const wchar_t *path, WidgetStyle *style,
HWND hwnd, long width, long height, BOOL disableSkin,
COLORREF colorBack, COLORREF colorFront)
{
if (NULL != bitmap)
{
BITMAP bi;
if (sizeof(bi) != GetObject(bitmap, sizeof(bi), &bi) ||
bi.bmWidth != width ||
bi.bmHeight != height)
{
DeleteObject(bitmap);
bitmap = NULL;
}
}
if (NULL == bitmap &&
NULL != style)
{
HBITMAP baseBitmap;
if (FALSE == disableSkin)
{
baseBitmap = Image_LoadSkinned(path,
SRC_TYPE_PNG,
IMAGE_FILTER_NORMAL,
0, 0,
colorBack, colorFront,
WIDGETSTYLE_BACK_COLOR(style));
}
else
{
baseBitmap = Image_Load(path, SRC_TYPE_PNG, 0, 0, 0);
}
if (NULL != baseBitmap)
{
Image_Premultiply(baseBitmap, NULL);
bitmap = ListWidget_CreateBorderBitmap(baseBitmap, hwnd, width, height);
DeleteObject(baseBitmap);
}
}
return bitmap;
}
HBITMAP
ListWidget_GetHoverBitmap(ListWidget *self, WidgetStyle *style, HWND hwnd, long width, long height)
{
if (NULL == self)
return NULL;
self->hoverBitmap = ListWidget_GetBorderBitmap(self->hoverBitmap,
MAKEINTRESOURCE(IDR_ITEM_HOVER_IMAGE),
style, hwnd, width, height, FALSE,
WIDGETSTYLE_SELECT_BACK_COLOR(style),
WIDGETSTYLE_SELECT_FRONT_COLOR(style));
return self->hoverBitmap;
}
HBITMAP
ListWidget_GetSelectBitmap(ListWidget *self, WidgetStyle *style, HWND hwnd, long width, long height)
{
if (NULL == self)
return NULL;
self->selectBitmap = ListWidget_GetBorderBitmap(self->selectBitmap,
MAKEINTRESOURCE(IDR_ITEM_SELECT_IMAGE),
style, hwnd, width, height, FALSE,
WIDGETSTYLE_SELECT_BACK_COLOR(style),
WIDGETSTYLE_SELECT_FRONT_COLOR(style));
return self->selectBitmap;
}
HBITMAP
ListWidget_GetInactiveSelectBitmap(ListWidget *self, WidgetStyle *style, HWND hwnd, long width, long height)
{
if (NULL == self)
return NULL;
self->inactiveSelectBitmap = ListWidget_GetBorderBitmap(self->inactiveSelectBitmap,
MAKEINTRESOURCE(IDR_ITEM_SELECT_IMAGE),
style, hwnd, width, height, FALSE,
WIDGETSTYLE_INACTIVE_SELECT_BACK_COLOR(style),
WIDGETSTYLE_INACTIVE_SELECT_FRONT_COLOR(style));
return self->inactiveSelectBitmap;
}
HBITMAP
ListWidget_GetLargeBadgeBitmap(ListWidget *self, WidgetStyle *style, HWND hwnd, long width, long height)
{
if (NULL == self)
return NULL;
self->largeBadgeBitmap = ListWidget_GetBorderBitmap(self->largeBadgeBitmap,
MAKEINTRESOURCE(IDR_COMMAND_BACKGROUND_IMAGE),
style, hwnd, width, height, TRUE,
WIDGETSTYLE_IMAGE_BACK_COLOR(style),
WIDGETSTYLE_IMAGE_FRONT_COLOR(style));
return self->largeBadgeBitmap;
}
HBITMAP
ListWidget_GetSmallBadgeBitmap(ListWidget *self, WidgetStyle *style, HWND hwnd, long width, long height)
{
if (NULL == self)
return NULL;
self->smallBadgeBitmap = ListWidget_GetBorderBitmap(self->smallBadgeBitmap,
MAKEINTRESOURCE(IDR_COMMAND_SECONDARY_BACKGROUND_IMAGE),
style, hwnd, width, height, TRUE,
WIDGETSTYLE_IMAGE_BACK_COLOR(style),
WIDGETSTYLE_IMAGE_FRONT_COLOR(style));
return self->smallBadgeBitmap;
}
HBITMAP
ListWidget_GetArrowsBitmap(ListWidget *self, WidgetStyle *style, HWND hwnd)
{
if (NULL == self)
return NULL;
if (NULL == self->arrowsBitmap &&
NULL != style)
{
self->arrowsBitmap = Image_LoadSkinned(MAKEINTRESOURCE(IDR_CATEGORY_ARROWS_IMAGE),
SRC_TYPE_PNG,
IMAGE_FILTER_NORMAL,
0, 0,
WIDGETSTYLE_CATEGORY_BACK_COLOR(style),
WIDGETSTYLE_CATEGORY_TEXT_COLOR(style),
WIDGETSTYLE_CATEGORY_BACK_COLOR(style));
if (NULL != self->arrowsBitmap)
Image_Premultiply(self->arrowsBitmap, NULL);
}
return self->arrowsBitmap;
}
HBITMAP
ListWidget_GetUnknownCommandLargeBitmap(ListWidget *self, WidgetStyle *style, long width, long height)
{
if (NULL == self)
return NULL;
if (NULL == self->unknownCommandLargeImage &&
NULL != style)
{
self->unknownCommandLargeImage = DeviceImageCache_GetImage(Plugin_GetImageCache(),
MAKEINTRESOURCE(IDR_UNKNOWN_COMMAND_LARGE_IMAGE),
width, height,
NULL, NULL);
}
return DeviceImage_GetBitmap(self->unknownCommandLargeImage, DeviceImage_Normal);
}
HBITMAP
ListWidget_GetUnknownCommandSmallBitmap(ListWidget *self, WidgetStyle *style, long width, long height)
{
if (NULL == self)
return NULL;
if (NULL == self->unknownCommandSmallImage &&
NULL != style)
{
self->unknownCommandSmallImage = DeviceImageCache_GetImage(Plugin_GetImageCache(),
MAKEINTRESOURCE(IDR_UNKNOWN_COMMAND_LARGE_IMAGE),
width, height,
NULL, NULL);
}
return DeviceImage_GetBitmap(self->unknownCommandSmallImage, DeviceImage_Normal);
}
HBITMAP
ListWidget_GetActivityProgressBitmap(ListWidget *self, WidgetStyle *style)
{
if (NULL == self)
return NULL;
if (NULL == self->activityProgressImage &&
NULL != style)
{
self->activityProgressImage = DeviceImageCache_GetImage(Plugin_GetImageCache(),
MAKEINTRESOURCE(IDR_PROGRESS_SMALL_IMAGE),
self->activityMetrics.progressWidth, self->activityMetrics.progressHeight * LISTWIDGET_PROGRESS_FRAME_COUNT,
NULL, NULL);
}
return DeviceImage_GetBitmap(self->activityProgressImage, DeviceImage_Normal);
}
HBITMAP
ListWidget_GetActivityBadgeBitmap(ListWidget *self, WidgetStyle *style, HWND hwnd, long width, long height)
{
if (NULL == self)
return NULL;
self->activityBadgeBitmap = ListWidget_GetBorderBitmap(self->activityBadgeBitmap,
MAKEINTRESOURCE(IDR_ACTION_BACKGROUND_IMAGE),
style, hwnd, width, height, TRUE,
WIDGETSTYLE_IMAGE_BACK_COLOR(style),
WIDGETSTYLE_IMAGE_FRONT_COLOR(style));
return self->activityBadgeBitmap;
}
static BOOL
ListWidget_UpdateCommandsLayout(ListWidget *self, HWND hwnd)
{
WidgetStyle *style;
ListWidgetItemMetric metrics;
RECT rect;
size_t index, indexMax;
long spacing;
if (NULL == self)
return FALSE;
style = WIDGET_GET_STYLE(hwnd);
if (NULL == style)
return FALSE;
if (0 == self->commandsCount)
return TRUE;
if (FALSE == ListWidget_GetItemMetrics(style, &metrics))
return FALSE;
indexMax = self->commandsCount;
if ((NULL == self->hoveredItem || NULL == self->hoveredItem->activity) &&
FALSE != ListWidget_GetCommandPrimary(self->commands[0]))
{
rect.bottom = self->imageSize.cy /*+ metrics.imageOffsetBottom*/;
rect.bottom += metrics.offsetTop + metrics.imageOffsetTop;
rect.top = rect.bottom - self->primaryCommandSize.cy;
rect.left = (self->itemWidth - self->primaryCommandSize.cx)/2;
rect.right = rect.left + self->primaryCommandSize.cx;
ListWidget_SetCommandRect(self->commands[0], &rect);
indexMax--;
}
rect.top = metrics.offsetTop + metrics.imageOffsetTop;
rect.bottom = rect.top + self->secondaryCommandSize.cy;
rect.right = self->itemWidth - metrics.offsetRight - metrics.imageOffsetRight;
rect.left = rect.right - self->secondaryCommandSize.cx;
spacing = self->secondaryCommandSize.cx/16 + 1;
for(index = 0; index < indexMax; index++)
{
ListWidget_SetCommandRect(self->commands[self->commandsCount - index - 1], &rect);
OffsetRect(&rect, -(self->secondaryCommandSize.cx + spacing), 0);
}
return TRUE;
}
static BOOL
ListWidget_UpdateActiveCommands(ListWidget *self, HWND hwnd)
{
ListWidgetCommand **clone;
size_t cloneSize, index;
BOOL invalidated;
POINT origin, pt;
RECT rect;
if (NULL == self)
return FALSE;
if (FALSE == ListWidget_GetViewOrigin(hwnd, &origin))
{
origin.x = 0;
origin.y = 0;
}
if (NULL == self->hoveredItem)
{
ListWidget_DestroyAllCommands(self->commands, self->commandsCount);
self->commandsCount = 0;
return TRUE;
}
origin.x += self->hoveredItem->rect.left;
origin.y += self->hoveredItem->rect.top;
invalidated = FALSE;
if (0 != self->commandsCount)
{
for(index = 0; index < self->commandsCount; index++)
{
if (FALSE != ListWidget_GetCommandRect(self->commands[index], &rect))
{
OffsetRect(&rect, origin.x, origin.y);
if (FALSE != InvalidateRect(hwnd, &rect, FALSE))
invalidated = TRUE;
}
}
clone = (ListWidgetCommand**)malloc(sizeof(ListWidgetCommand*) * self->commandsCount);
if (NULL != clone)
{
cloneSize = self->commandsCount;
CopyMemory(clone, self->commands, sizeof(ListWidgetCommand*) * cloneSize);
}
else
{
cloneSize = 0;
ListWidget_DestroyAllCommands(self->commands, self->commandsCount);
}
}
else
{
clone = NULL;
cloneSize = 0;
}
self->commandsCount = ListWidget_GetItemCommands(self->hoveredItem,
self->commands, self->commandsMax);
if (0 != self->commandsCount)
{
ListWidget_UpdateCommandsLayout(self, hwnd);
ListWidgetItem_SetInteractive(self->hoveredItem);
for(index = 0; index < self->commandsCount; index++)
{
if (FALSE != ListWidget_GetCommandRect(self->commands[index], &rect))
{
OffsetRect(&rect, origin.x, origin.y);
if (FALSE != InvalidateRect(hwnd, &rect, FALSE))
invalidated = TRUE;
}
}
}
else
ListWidgetItem_UnsetInteractive(self->hoveredItem);
if (NULL != clone)
{
ListWidget_DestroyAllCommands(clone, cloneSize);
free(clone);
}
if (FALSE != GetCursorPos(&pt))
{
ListWidgetItem *tooltipItem;
ListWidgetItemPart tooltipItemPart;
RECT tooltipItemPartRect;
tooltipItem = ListWidget_TooltipGetCurrent(self->tooltip, &tooltipItemPart, &tooltipItemPartRect);
MapWindowPoints(HWND_DESKTOP, hwnd, &pt, 1);
ListWidget_UpdateHoverEx(self, hwnd, &pt);
if (FALSE != ListWidget_TooltipGetChanged(self->tooltip, tooltipItem,
tooltipItemPart, &tooltipItemPartRect))
{
ListWidget_TooltipRelayMouseMessage(self->tooltip, WM_MOUSEMOVE, 0, &pt);
}
}
if (FALSE != invalidated)
UpdateWindow(hwnd);
return TRUE;
}
static void CALLBACK
ListWidget_ShowCommandTimerCb(HWND hwnd, UINT uMsg, UINT_PTR eventId, DWORD elpasedTime)
{
ListWidget *self;
KillTimer(hwnd, eventId);
self = WIDGET_GET_SELF(hwnd, ListWidget);
if (NULL == self)
return;
if (NULL != self->hoveredItem &&
FALSE == ListWidgetItem_IsInteractive(self->hoveredItem) &&
NULL == self->activeMenu)
{
ListWidget_UpdateActiveCommands(self, hwnd);
}
}
static void CALLBACK
ListWidget_ProgressTickCb(HWND hwnd, UINT uMsg, UINT_PTR eventId, DWORD elpasedTime)
{
ListWidget *self = WIDGET_GET_SELF(hwnd, ListWidget);
if (NULL == self)
{
KillTimer(hwnd, eventId);
return;
}
size_t index = self->activeItems.size();
if (index > 0)
{
POINT origin;
RECT rect;
ListWidgetItemMetric metrics, *metrics_ptr;
WidgetStyle *style;
if (FALSE == ListWidget_GetViewOrigin(hwnd, &origin))
{
origin.x = 0;
origin.y = 0;
}
style = WIDGET_GET_STYLE(hwnd);
if (NULL != style && FALSE != ListWidget_GetItemMetrics(style, &metrics))
metrics_ptr = &metrics;
else
metrics_ptr = NULL;
while(index--)
{
ListWidgetItem *item = self->activeItems[index];
item->activity->step++;
if (item->activity->step >= LISTWIDGET_PROGRESS_FRAME_COUNT)
item->activity->step = 1;
if (FALSE != ListWidget_GetItemActivityProgressRect(self, NULL, item, metrics_ptr, &rect))
{
OffsetRect(&rect, origin.x, origin.y);
InvalidateRect(hwnd, &rect, FALSE);
}
}
}
else
{
KillTimer(hwnd, eventId);
self->activityTimerEnabled = FALSE;
}
}
static void CALLBACK
ListWidget_BeginTitleEditTimerCb(HWND hwnd, UINT uMsg, UINT_PTR eventId, DWORD elpasedTime)
{
ListWidget *self;
self = WIDGET_GET_SELF(hwnd, ListWidget);
KillTimer(hwnd, eventId);
if (NULL != self &&
NULL != self->titleEditItem)
{
if (self->titleEditItem == self->selectedItem)
{
if (NULL != self->titleEditor)
{
DestroyWindow(self->titleEditor);
self->titleEditor = NULL;
}
self->titleEditor = ListWidget_BeginItemTitleEdit(self, hwnd, self->titleEditItem);
}
self->titleEditItem = NULL;
}
}
BOOL
ListWidget_UpdateHoverEx(ListWidget *self, HWND hwnd, const POINT *cursor)
{
ListWidgetItem *hoveredItem;
ListWidgetItemMetric metrics, *metrics_ptr;
WidgetStyle *style;
ListWidgetItemPart hoveredPart = ListWidgetItemPart_None;
RECT rect, hoveredPartRect;
POINT pt, origin;
if (NULL == cursor)
return FALSE;
metrics_ptr = NULL;
pt = *cursor;
if (NULL != self->pressedCategory ||
NULL != self->activeMenu ||
0 != (0x8000 & GetAsyncKeyState(VK_LBUTTON)) ||
0 != (0x8000 & GetAsyncKeyState(VK_RBUTTON)))
{
return FALSE;
}
if (FALSE == ListWidget_GetViewOrigin(hwnd, &origin))
{
origin.x = 0;
origin.y = 0;
}
if (FALSE != GetClientRect(hwnd, &rect) &&
FALSE != PtInRect(&rect, pt))
{
pt.x -= origin.x;
pt.y -= origin.y;
hoveredItem = ListWidget_GetItemFromPoint(self, pt);
if (NULL != hoveredItem)
{
if (NULL == metrics_ptr)
{
style = WIDGET_GET_STYLE(hwnd);
if (NULL != style &&
FALSE != ListWidget_GetItemMetrics(style, &metrics))
{
metrics_ptr = &metrics;
}
}
hoveredPart = ListWidgetItemPart_Frame |
ListWidgetItemPart_Command |
ListWidgetItemPart_Spacebar |
ListWidgetItemPart_Title;
hoveredPart = ListWidget_GetItemPartFromPoint(self, hoveredItem, metrics_ptr, pt, hoveredPart, &hoveredPartRect);
}
}
else
hoveredItem = NULL;
if (NULL == hoveredItem)
hoveredPart= ListWidgetItemPart_None;
ListWidget_TooltipUpdate(self->tooltip, hoveredItem, hoveredPart, &hoveredPartRect);
if (ListWidgetItemPart_None == ((ListWidgetItemPart_Frame | ListWidgetItemPart_Command | ListWidgetItemPart_Activity) & hoveredPart))
hoveredItem = NULL;
if (self->hoveredItem == hoveredItem)
return FALSE;
if (NULL == metrics_ptr)
{
style = WIDGET_GET_STYLE(hwnd);
if (NULL != style &&
FALSE != ListWidget_GetItemMetrics(style, &metrics))
{
metrics_ptr = &metrics;
}
}
if (NULL != self->hoveredItem)
{
ListWidgetItem_UnsetHovered(self->hoveredItem);
ListWidgetItem_UnsetInteractive(self->hoveredItem);
if (NULL == metrics_ptr ||
FALSE == ListWidget_GetItemFrameRect(self, self->hoveredItem, metrics_ptr, &rect))
{
CopyRect(&rect, &self->hoveredItem->rect);
}
OffsetRect(&rect, origin.x, origin.y);
InvalidateRect(hwnd, &rect, FALSE);
}
if (NULL != hoveredItem)
{
ListWidgetItem_SetHovered(hoveredItem);
if (NULL == metrics_ptr ||
FALSE == ListWidget_GetItemFrameRect(self, hoveredItem, metrics_ptr, &rect))
{
CopyRect(&rect, &hoveredItem->rect);
}
OffsetRect(&rect, origin.x, origin.y);
InvalidateRect(hwnd, &rect, FALSE);
SetTimer(hwnd, LISTWIDGETTIMER_SHOW_COMMANDS_ID,
LISTWIDGETTIMER_SHOW_COMMANDS_DELAY,
ListWidget_ShowCommandTimerCb);
}
else
KillTimer(hwnd, LISTWIDGETTIMER_SHOW_COMMANDS_ID);
self->hoveredItem = hoveredItem;
return TRUE;
}
BOOL
ListWidget_UpdateHover(ListWidget *self, HWND hwnd)
{
POINT pt;
if (FALSE == GetCursorPos(&pt))
return FALSE;
MapWindowPoints(HWND_DESKTOP, hwnd, &pt, 1);
return ListWidget_UpdateHoverEx(self, hwnd, &pt);
}
BOOL
ListWidget_RemoveHover(ListWidget *self, HWND hwnd, BOOL invalidate)
{
if (NULL == self)
return FALSE;
if (NULL == self->hoveredItem)
return FALSE;
ListWidgetItem_UnsetHovered(self->hoveredItem);
ListWidgetItem_UnsetInteractive(self->hoveredItem);
KillTimer(hwnd, LISTWIDGETTIMER_SHOW_COMMANDS_ID);
if (FALSE != invalidate)
{
RECT rect;
POINT origin;
ListWidgetItemMetric metrics;
WidgetStyle *style;
style = WIDGET_GET_STYLE(hwnd);
if (NULL == style ||
FALSE == ListWidget_GetItemMetrics(style, &metrics) ||
FALSE == ListWidget_GetItemFrameRect(self, self->hoveredItem, &metrics, &rect))
{
CopyRect(&rect, &self->hoveredItem->rect);
}
if (FALSE != ListWidget_GetViewOrigin(hwnd, &origin))
OffsetRect(&rect, origin.x, origin.y);
InvalidateRect(hwnd, &rect, FALSE);
}
self->hoveredItem = NULL;
return TRUE;
}
void
ListWidget_UpdateSelectionStatus(ListWidget *self, HWND hwnd, BOOL ensureVisible)
{
HWND statusWindow;
if (NULL == self)
return;
statusWindow = GetParent(hwnd);
if (NULL == statusWindow)
return;
statusWindow = MANAGERVIEW_GET_STATUS_BAR(statusWindow);
if (NULL == statusWindow)
return;
if (NULL != self->selectedItem)
{
wchar_t buffer[2048] = {0};
const wchar_t *statusString;
if (FALSE == ListWidget_FormatItemStatus(self, self->selectedItem, buffer, ARRAYSIZE(buffer)) ||
L'\0' == *buffer)
{
statusString = NULL;
}
else
statusString = buffer;
if (STATUS_ERROR == self->selectionStatus)
{
self->selectionStatus = STATUSBAR_ADD_STATUS(statusWindow, statusString);
if (STATUS_ERROR != self->selectionStatus)
{
if (FALSE == ListWidget_FormatItemSpaceStatus(self, self->selectedItem, buffer, ARRAYSIZE(buffer)) ||
L'\0' == *buffer)
{
statusString = NULL;
}
else
statusString = buffer;
STATUSBAR_SET_STATUS_RTEXT(statusWindow, self->selectionStatus, statusString);
}
}
else
{
STATUSBAR_SET_STATUS_TEXT(statusWindow, self->selectionStatus, statusString);
if (FALSE == ListWidget_FormatItemSpaceStatus(self, self->selectedItem, buffer, ARRAYSIZE(buffer)) ||
L'\0' == *buffer)
{
statusString = NULL;
}
else
statusString = buffer;
STATUSBAR_SET_STATUS_RTEXT(statusWindow, self->selectionStatus, statusString);
if (FALSE != ensureVisible)
{
STATUSBAR_MOVE_STATUS(statusWindow, self->selectionStatus, STATUS_MOVE_TOP);
}
}
}
else
{
if (STATUS_ERROR != self->selectionStatus)
{
STATUSBAR_REMOVE_STATUS(statusWindow, self->selectionStatus);
self->selectionStatus = STATUS_ERROR;
}
}
}
void
ListWidget_UpdateSelectionSpaceStatus(ListWidget *self, HWND hwnd, BOOL ensureVisible)
{
HWND statusWindow;
if (NULL == self)
return;
statusWindow = GetParent(hwnd);
if (NULL == statusWindow)
return;
statusWindow = MANAGERVIEW_GET_STATUS_BAR(statusWindow);
if (NULL == statusWindow)
return;
if (NULL != self->selectedItem &&
STATUS_ERROR != self->selectionStatus)
{
wchar_t buffer[2048] = {0};
const wchar_t *statusString;
if (FALSE == ListWidget_FormatItemSpaceStatus(self, self->selectedItem, buffer, ARRAYSIZE(buffer)) ||
L'\0' == *buffer)
{
statusString = NULL;
}
else
statusString = buffer;
STATUSBAR_SET_STATUS_RTEXT(statusWindow, self->selectionStatus, statusString);
if (FALSE != ensureVisible)
STATUSBAR_MOVE_STATUS(statusWindow, self->selectionStatus, STATUS_MOVE_TOP);
}
}
BOOL
ListWidget_SelectItem(ListWidget *self, HWND hwnd, ListWidgetItem *item, BOOL ensureVisible)
{
BOOL invalidated;
if (NULL == self)
return FALSE;
invalidated = FALSE;
if (self->selectedItem != item)
{
RECT rect;
POINT origin;
ListWidgetItemMetric metrics, *metrics_ptr;
WidgetStyle *style;
if (FALSE == ListWidget_GetViewOrigin(hwnd, &origin))
{
origin.x = 0;
origin.y = 0;
}
style = WIDGET_GET_STYLE(hwnd);
if (NULL != style &&
FALSE != ListWidget_GetItemMetrics(style, &metrics))
{
metrics_ptr = &metrics;
}
else
metrics_ptr = NULL;
if (NULL != self->selectedItem)
{
ListWidgetItem_UnsetSelected(self->selectedItem);
if (NULL == metrics_ptr ||
FALSE == ListWidget_GetItemFrameRect(self, self->selectedItem, metrics_ptr, &rect))
{
CopyRect(&rect, &self->selectedItem->rect);
}
OffsetRect(&rect, origin.x, origin.y);
if (FALSE != InvalidateRect(hwnd, &rect, FALSE))
invalidated = TRUE;
}
if (NULL != item)
{
ListWidgetItem_SetSelected(item);
if (NULL == metrics_ptr ||
FALSE == ListWidget_GetItemFrameRect(self, item, metrics_ptr, &rect))
{
CopyRect(&rect, &item->rect);
}
OffsetRect(&rect, origin.x, origin.y);
if (FALSE != InvalidateRect(hwnd, &rect, FALSE))
invalidated = TRUE;
}
self->selectedItem = item;
}
if (FALSE != ensureVisible)
{
if (FALSE != ListWidget_EnsureItemVisisble(self, hwnd, item, VISIBLE_NORMAL))
invalidated = TRUE;
}
if (FALSE != invalidated)
UpdateWindow(hwnd);
ListWidget_UpdateSelectionStatus(self, hwnd, TRUE);
return TRUE;
}
static void
ListWidget_EnsureFocused(ListWidget *self, HWND hwnd, BOOL forceSelect)
{
HWND hDialog, hParent;
if (NULL == self || NULL == hwnd)
return;
if (GetFocus() == hwnd)
return;
hDialog = NULL;
hParent = hwnd;
while(NULL != (hParent = GetAncestor(hParent, GA_PARENT)))
{
if (32770 != GetClassLongPtr(hParent, GCW_ATOM) ||
0 == (WS_EX_CONTROLPARENT & GetWindowStyleEx(hParent)))
{
break;
}
hDialog = hParent;
}
self->flags |= ListWidgetFlag_NoFocusSelect;
if (NULL != hDialog)
SendMessage(hDialog, WM_NEXTDLGCTL, (WPARAM)hwnd, TRUE);
else
SetFocus(hwnd);
self->flags &= ~ListWidgetFlag_NoFocusSelect;
}
static BOOL
ListWidget_EnsureTopVisible(ListWidget *self, HWND hwnd)
{
POINT pt;
if (NULL == self || NULL == hwnd)
return FALSE;
if (FALSE == ListWidget_GetViewOrigin(hwnd, &pt) ||
(0 == pt.x && 0 == pt.y))
{
return FALSE;
}
if (FALSE == WIDGET_SCROLL(hwnd, pt.x, pt.y, TRUE))
return FALSE;
ListWidget_UpdateHover(self, hwnd);
return TRUE;
}
static BOOL
ListWidget_EnsureBottomVisible(ListWidget *self, HWND hwnd)
{
SCROLLINFO scrollInfo;
POINT pt;
if (NULL == self || NULL == hwnd)
return FALSE;
scrollInfo.cbSize = sizeof(scrollInfo);
scrollInfo.fMask = SIF_POS | SIF_RANGE | SIF_PAGE;
if (FALSE != GetScrollInfo(hwnd, SB_HORZ, &scrollInfo))
pt.x = -scrollInfo.nPos;
else
pt.x = 0;
if (FALSE != GetScrollInfo(hwnd, SB_VERT, &scrollInfo) && 0 != scrollInfo.nPage)
pt.y = (scrollInfo.nMax + 1 - scrollInfo.nPage) - scrollInfo.nPos;
else
pt.y = 0;
if (0 == pt.x && 0 == pt.y)
return FALSE;
if (FALSE == WIDGET_SCROLL(hwnd, pt.x, pt.y, TRUE))
return FALSE;
ListWidget_UpdateHover(self, hwnd);
return TRUE;
}
BOOL
ListWidget_UpdateLayout(HWND hwnd, ListWidgetLayoutFlags layoutFlags)
{
BOOL result;
unsigned int flags;
ListWidget *self;
POINT anchorPoint;
ListWidgetItem *anchorItem;
SCROLLINFO scrollInfo;
HWND managerWindow, focusWindow;
POINT pt, menuAnchor, hoverAnchor;
self = WIDGET_GET_SELF(hwnd, ListWidget);
if (NULL == self)
return FALSE;
if (NULL == self->activeMenu ||
NULL == self->selectedItem ||
FALSE == ListWidget_GetViewItemPos(hwnd, self->selectedItem, &menuAnchor))
{
menuAnchor.x = 0x7FFFFFFF;
menuAnchor.y = 0x7FFFFFFF;
}
if (NULL != self->hoveredItem ||
FALSE == ListWidget_GetViewItemPos(hwnd, self->hoveredItem, &hoverAnchor))
{
hoverAnchor.x = 0x7FFFFFFF;
hoverAnchor.y = 0x7FFFFFFF;
}
scrollInfo.cbSize = sizeof(scrollInfo);
scrollInfo.fMask = SIF_POS;
anchorItem = NULL;
managerWindow = GetAncestor(hwnd, GA_PARENT);
if (NULL == managerWindow)
managerWindow = hwnd;
focusWindow = GetFocus();
if (0 != (ListWidgetLayout_KeepStable & layoutFlags) &&
(managerWindow == focusWindow || IsChild(managerWindow, focusWindow)))
{
if (NULL != self->selectedItem)
{
RECT clientRect;
GetClientRect(hwnd, &clientRect);
anchorPoint.x = (FALSE != GetScrollInfo(hwnd, SB_HORZ, &scrollInfo)) ?
-scrollInfo.nPos : 0;
anchorPoint.y = (FALSE != GetScrollInfo(hwnd, SB_VERT, &scrollInfo)) ?
-scrollInfo.nPos : 0;
OffsetRect(&clientRect, -anchorPoint.x, -anchorPoint.y);
if (clientRect.left <= self->selectedItem->rect.left &&
clientRect.top <= self->selectedItem->rect.top &&
clientRect.right >= self->selectedItem->rect.right &&
clientRect.bottom >= self->selectedItem->rect.bottom)
{
anchorItem = self->selectedItem;
anchorPoint.x += self->selectedItem->rect.left;
anchorPoint.y += self->selectedItem->rect.top;
}
}
}
flags = SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOMOVE | SWP_NOSIZE |
SWP_FRAMECHANGED | SWP_NOREDRAW;
result = SetWindowPos(hwnd, NULL, 0, 0, 0, 0, flags);
if (NULL != anchorItem)
{
long positionY;
positionY = anchorItem->rect.top;
if (FALSE != GetScrollInfo(hwnd, SB_VERT, &scrollInfo))
positionY -= scrollInfo.nPos;
if (positionY != anchorPoint.y)
WIDGET_SET_SCROLL_POS(hwnd, 0, positionY - anchorPoint.y, FALSE);
}
if (0x7FFFFFFF != menuAnchor.x &&
NULL != self->selectedItem &&
FALSE != ListWidget_GetViewItemPos(hwnd, self->selectedItem, &pt) &&
menuAnchor.x != pt.x && menuAnchor.y != pt.y)
{
if (NULL != self->activeMenu)
EndMenu();
}
if (0x7FFFFFFF != hoverAnchor.x &&
NULL != self->hoveredItem &&
FALSE != ListWidget_GetViewItemPos(hwnd, self->hoveredItem, &pt) &&
hoverAnchor.x != pt.x && hoverAnchor.y != pt.y)
{
ListWidget_UpdateHover(self, hwnd);
}
if (0 == (ListWidgetLayout_NoRedraw & layoutFlags))
{
flags = RDW_INVALIDATE | RDW_ALLCHILDREN | RDW_FRAME | RDW_ERASE;
if (0 != (ListWidgetLayout_UpdateNow & layoutFlags))
flags |= (RDW_ERASENOW | RDW_UPDATENOW);
RedrawWindow(hwnd, NULL, NULL, flags);
}
return result;
}
double
ListWidget_GetZoomRatio(ListWidget *self)
{
if (NULL == self)
return 1.0;
if (self->imageSize.cy > LISTWIDGET_IMAGE_DEFAULT_HEIGHT)
{
return (1.0 + (double)(self->imageSize.cy - LISTWIDGET_IMAGE_DEFAULT_HEIGHT)/
(LISTWIDGET_IMAGE_MAX_HEIGHT - LISTWIDGET_IMAGE_DEFAULT_HEIGHT));
}
return (double)(self->imageSize.cy - LISTWIDGET_IMAGE_MIN_HEIGHT)/
(LISTWIDGET_IMAGE_DEFAULT_HEIGHT - LISTWIDGET_IMAGE_MIN_HEIGHT);
}
long
ListWidget_GetZoomedValue(double zoomRatio, long normal, long min, long max)
{
if (zoomRatio < 1.0)
return min + (long)floor((double)(normal - min) * zoomRatio);
else if (zoomRatio > 1.0)
return normal + (long)ceil((double)(max - normal) * (zoomRatio - 1.0));
return normal;
}
static BOOL
ListWidget_UpdateActivityLayout(ListWidget *self, HWND hwnd, double zoomRatio)
{
LOGFONTW lf;
HDC windowDC;
long elementHeight, titleMinWidth, workHeight;
ListWidgetItem *item;
ListWidgetActivityMetric *activityMetrics;
// always reset items activity size cache
size_t index = (self ? self->activeItems.size() : NULL);
while(index--)
{
item = self->activeItems[index];
if (NULL != item)
SetSizeEmpty(&item->activity->titleSize);
}
if (NULL == self)
return FALSE;
activityMetrics = &self->activityMetrics;
activityMetrics->offsetLeft = self->activityMetrics.height/16;
if (activityMetrics->offsetLeft < 1)
activityMetrics->offsetLeft = 1;
activityMetrics->offsetRight = activityMetrics->offsetLeft;
activityMetrics->offsetTop = self->activityMetrics.height/9;
if (activityMetrics->offsetTop < 3)
activityMetrics->offsetTop = 3;
activityMetrics->offsetBottom = activityMetrics->offsetTop;
activityMetrics->spacing = 4 + self->activityMetrics.height/16;
workHeight = activityMetrics->height - (activityMetrics->offsetTop + activityMetrics->offsetBottom);
activityMetrics->fontHeight = workHeight/2;
if (activityMetrics->fontHeight < 8)
activityMetrics->fontHeight = 8;
if (NULL == self->activityFont ||
sizeof(lf) != GetObject(self->activityFont, sizeof(lf), &lf) ||
lf.lfHeight != activityMetrics->fontHeight)
{
if (NULL != self->activityFont)
DeleteObject(self->activityFont);
lf.lfHeight = activityMetrics->fontHeight;
lf.lfWidth = 0;
lf.lfEscapement = 0;
lf.lfOrientation = 0;
lf.lfWeight = FW_NORMAL;
lf.lfItalic = FALSE;
lf.lfUnderline = FALSE;
lf.lfStrikeOut = FALSE;
lf.lfCharSet = DEFAULT_CHARSET;
lf.lfOutPrecision = OUT_TT_PRECIS;
lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;
lf.lfQuality = Graphics_GetSysFontQuality();
lf.lfPitchAndFamily = DEFAULT_PITCH | FF_DONTCARE;
StringCchCopy(lf.lfFaceName, ARRAYSIZE(lf.lfFaceName), L"Arial"/*L"Times New Roman"*/);
self->activityFont = CreateFontIndirect(&lf);
}
activityMetrics->titleHeight = workHeight;
if (activityMetrics->titleHeight < 0)
activityMetrics->titleHeight = 0;
activityMetrics->titleWidth = 0;
activityMetrics->percentWidth = 0;
activityMetrics->percentHeight = 0;
titleMinWidth = 0;
windowDC = GetWindowDC(hwnd);
if (NULL != windowDC)
{
SIZE textSize;
HFONT prevFont;
prevFont = SelectFont(windowDC, self->activityFont);
if (FALSE == GetTextExtentPoint32(windowDC, L"00%", 3, &textSize))
SetSizeEmpty(&textSize);
if (textSize.cy <= workHeight)
{
activityMetrics->fontHeight = textSize.cy;
activityMetrics->percentHeight = textSize.cy;
activityMetrics->percentWidth = textSize.cx;
}
titleMinWidth = Graphics_GetAveStrWidth(windowDC, 6);
activityMetrics->spacing = Graphics_GetAveStrWidth(windowDC, 1) - 2;
}
if (NULL != self->activityBadgeBitmap)
{
DeleteObject(self->activityBadgeBitmap);
self->activityBadgeBitmap = NULL;
}
elementHeight = (long)(18.0 * (double)workHeight/28.0);
if (activityMetrics->progressWidth != elementHeight ||
activityMetrics->progressHeight != elementHeight)
{
activityMetrics->progressWidth = elementHeight;
activityMetrics->progressHeight = elementHeight;
if (NULL != self->activityProgressImage)
{
DeviceImage_Release(self->activityProgressImage);
self->activityProgressImage = NULL;
}
}
for(;;)
{
activityMetrics->titleWidth = activityMetrics->width -
(activityMetrics->offsetLeft + activityMetrics->offsetRight);
if(0 != activityMetrics->progressWidth)
activityMetrics->titleWidth -= (activityMetrics->progressWidth + activityMetrics->spacing);
if(0 != activityMetrics->percentWidth)
activityMetrics->titleWidth -= (activityMetrics->percentWidth + activityMetrics->spacing);
if (activityMetrics->titleWidth < titleMinWidth)
{
if (0 != activityMetrics->percentWidth)
{
activityMetrics->percentWidth = 0;
activityMetrics->percentHeight = 0;
continue;
}
if (0 != activityMetrics->progressWidth)
{
activityMetrics->progressWidth = 0;
activityMetrics->progressHeight = 0;
continue;
}
activityMetrics->titleWidth = 0;
activityMetrics->titleHeight = 0;
}
break;
}
return TRUE;
}
BOOL
ListWidget_SetImageSize(ListWidget *self, HWND hwnd, int imageWidth, int imageHeight, BOOL redraw)
{
size_t iCategory, iGroup, iItem;
ListWidgetCategory *category;
ListWidgetGroup *group;
ListWidgetItem *item;
long elementWidth, elementHeight;
double zoomRatio;
if (NULL == self)
return FALSE;
SetSize(&self->imageSize, imageWidth, imageHeight);
zoomRatio = ListWidget_GetZoomRatio(self);
for (iCategory = 0; iCategory < self->categories.size(); iCategory++)
{
category = self->categories[iCategory];
for(iGroup = 0; iGroup < category->groups.size(); iGroup++)
{
group = category->groups[iGroup];
for(iItem = 0; iItem < group->items.size(); iItem++)
{
item = group->items[iItem];
if (NULL != item->image)
{
DeviceImage_Release(item->image);
item->image = NULL;
}
SetSize(&item->titleSize, -1, -1);
}
}
}
// connetion size
elementHeight = ListWidget_GetZoomedValue(zoomRatio, LISTWIDGET_CONNECTION_DEFAULT_HEIGHT,
LISTWIDGET_CONNECTION_MIN_HEIGHT, LISTWIDGET_CONNECTION_MAX_HEIGHT);
elementWidth = elementHeight;
if (self->connectionSize.cx != elementWidth ||
self->connectionSize.cy != elementHeight)
{
SetSize(&self->connectionSize, elementWidth, elementHeight);
int index = (int)self->connections.size();
while (index--)
{
ListWidget_UpdateConnectionImageSize(self->connections[index],
self->connectionSize.cx, self->connectionSize.cy);
}
}
// primary command
elementHeight = ListWidget_GetZoomedValue(zoomRatio, LISTWIDGET_PRIMARYCOMMAND_DEFAULT_HEIGHT,
LISTWIDGET_PRIMARYCOMMAND_MIN_HEIGHT, LISTWIDGET_PRIMARYCOMMAND_MAX_HEIGHT);
elementWidth = self->imageSize.cx;
if (self->primaryCommandSize.cx != elementWidth ||
self->primaryCommandSize.cy != elementHeight)
{
SetSize(&self->primaryCommandSize, elementWidth, elementHeight);
}
// secondary command
elementHeight = ListWidget_GetZoomedValue(zoomRatio, LISTWIDGET_SECONDARYCOMMAND_DEFAULT_HEIGHT,
LISTWIDGET_SECONDARYCOMMAND_MIN_HEIGHT, LISTWIDGET_SECONDARYCOMMAND_MAX_HEIGHT);
elementWidth = elementHeight;
if (self->secondaryCommandSize.cx != elementWidth ||
self->secondaryCommandSize.cy != elementHeight)
{
SetSize(&self->secondaryCommandSize, elementWidth, elementHeight);
}
// activity
elementHeight = ListWidget_GetZoomedValue(zoomRatio, LISTWIDGET_ACTIVITY_DEFAULT_HEIGHT,
LISTWIDGET_ACTIVITY_MIN_HEIGHT, LISTWIDGET_ACTIVITY_MAX_HEIGHT);
elementWidth = self->imageSize.cx;
if (self->activityMetrics.width != elementWidth ||
self->activityMetrics.height != elementHeight)
{
self->activityMetrics.width = elementWidth;
self->activityMetrics.height = elementHeight;
}
ListWidget_UpdateLayout(hwnd, ListWidgetLayout_NoRedraw);
if (NULL != self->hoveredItem &&
FALSE != ListWidgetItem_IsInteractive(self->hoveredItem))
{
ListWidget_UpdateActiveCommands(self, hwnd);
}
ListWidget_UpdateActivityLayout(self, hwnd, zoomRatio);
if (FALSE != redraw)
{
RedrawWindow(hwnd, NULL, NULL,
RDW_INVALIDATE | RDW_ERASE | RDW_ERASENOW | RDW_UPDATENOW | RDW_ALLCHILDREN);
}
return TRUE;
}
BOOL
ListWidget_DisplayContextMenu(ListWidget *self, HWND hostWindow, POINT pt)
{
return FALSE;
}
BOOL
ListWidget_RegisterActiveItem(ListWidget *self, HWND hwnd, ListWidgetItem *item)
{
size_t index;
if (NULL == self || NULL == item)
return FALSE;
index = self->activeItems.size();
while(index--)
{
if (item == self->activeItems[index])
return FALSE;
}
self->activeItems.push_back(item);
if (1 == self->activeItems.size())
{
if (0 != SetTimer(hwnd, LISTWIDGETTIMER_PROGRESS_TICK_ID,
LISTWIDGETTIMER_PROGRESS_TICK_DELAY, ListWidget_ProgressTickCb))
{
self->activityTimerEnabled = TRUE;
}
}
return TRUE;
}
BOOL
ListWidget_UnregisterActiveItem(ListWidget *self, HWND hwnd, ListWidgetItem *item)
{
size_t index;
if (NULL == self || NULL == item)
return FALSE;
index = self->activeItems.size();
while(index--)
{
if (item == self->activeItems[index])
{
self->activeItems.erase(self->activeItems.begin() + index);
if (0 == self->activeItems.size())
{
KillTimer(hwnd, LISTWIDGETTIMER_PROGRESS_TICK_ID);
self->activityTimerEnabled = FALSE;
}
return TRUE;
}
}
return FALSE;
}
static void
ListWidget_CallItemAction(ListWidget *self, HWND hwnd, ListWidgetCategory *category, ListWidgetItem *item)
{
ifc_device *device;
if (NULL == self || NULL == item)
return;
if (NULL == category)
{
if (FALSE == ListWidget_GetItemOwner(self, item, &category) ||
NULL == category)
{
return;
}
}
if (NULL == WASABI_API_DEVICES ||
S_OK != WASABI_API_DEVICES->DeviceFind(item->name, &device))
{
return;
}
if (CSTR_EQUAL == CompareStringA(CSTR_INVARIANT, 0, category->name, -1, "discovered", -1))
{
if (FALSE == device->GetAttached())
device->Attach(NULL);
}
if (CSTR_EQUAL == CompareStringA(CSTR_INVARIANT, 0, category->name, -1, "attached", -1))
{
Navigation_SelectDevice(device->GetName());
}
device->Release();
}
static BOOL
ListWidget_AddDevicesToCategory(ListWidget *self, ListWidgetCategory *category, DeviceList *list)
{
ListWidgetGroup *group;
ListWidgetItem *item;
ifc_device *device;
size_t index, groupCount, categoryCount;
if (NULL == list || NULL == category)
return FALSE;
categoryCount = category->groups.size();
index = list->size();
if (0 == index)
return FALSE;
do
{
index--;
device = list->at(index);
const char *groupName = device->GetType();
group = ListWidget_FindGroupEx(category, groupName, categoryCount);
if (NULL == group)
{
group = ListWidget_CreateGroup(groupName);
if (NULL != group)
ListWidget_AddGroup(category, group);
}
if (NULL != group)
{
groupCount = group->items.size();
item = ListWidget_FindGroupItemEx(group, device->GetName(), groupCount);
if (NULL == item)
{
item = ListWidget_CreateItemFromDevice(self, device);
if (NULL != item)
{
ListWidget_AddItem(group, item);
if (NULL != item->activity)
self->activeItems.push_back(item);
}
}
}
else
groupCount = 0;
list->erase(list->begin() + index);
device->Release();
while(index--)
{
device = list->at(index);
if (CSTR_EQUAL == CompareStringA(CSTR_INVARIANT, 0, groupName, -1, device->GetType(), -1))
{
if (NULL != group)
{
item = ListWidget_FindGroupItemEx(group, device->GetName(), groupCount);
if (NULL == item)
{
item = ListWidget_CreateItemFromDevice(self, device);
if (NULL != item)
{
ListWidget_AddItem(group, item);
if (NULL != item->activity)
{
self->activeItems.push_back(item);
}
}
}
}
list->erase(list->begin() + index);
device->Release();
}
}
if (NULL != group)
ListWidget_SortGroup(group);
index = list->size();
} while(0 != index);
ListWidget_SortCategory(category);
return TRUE;
}
static void
ListWidget_AddExistingDevices(ListWidget *self, HWND hwnd)
{
DeviceList discoveredList, attachedList;
ifc_device *device;
ListWidgetCategory *category;
size_t index, activeItemsCount;
BOOL devicesAdded;
if (NULL == self)
return;
activeItemsCount = self->activeItems.size();
if (NULL != WASABI_API_DEVICES)
{
ifc_deviceobjectenum *enumerator;
if (SUCCEEDED(WASABI_API_DEVICES->DeviceEnumerate(&enumerator)))
{
size_t reserveSize;
ifc_deviceobject *object;
if (SUCCEEDED(enumerator->GetCount(&reserveSize)))
{
discoveredList.reserve(reserveSize);
attachedList.reserve(reserveSize);
}
while(S_OK == enumerator->Next(&object, 1, NULL))
{
if (SUCCEEDED(object->QueryInterface(IFC_Device, (void**)&device)))
{
if (FALSE == device->GetHidden() &&
// excludes 'cloud' devices from appearing
lstrcmpiA(device->GetConnection(), "cloud"))
{
if (FALSE == device->GetAttached())
discoveredList.push_back(device);
else
attachedList.push_back(device);
}
else
device->Release();
}
object->Release();
}
enumerator->Release();
}
}
devicesAdded = FALSE;
if (0 != attachedList.size())
{
category = ListWidget_FindCategory(self, "attached");
if (NULL != category)
{
if (FALSE != ListWidget_AddDevicesToCategory(self, category, &attachedList))
{
ListWidget_ResetCategoryCounter(category);
devicesAdded = TRUE;
}
}
index = attachedList.size();
while(index--)
attachedList[index]->Release();
}
if (0 != discoveredList.size())
{
category = ListWidget_FindCategory(self, "discovered");
if (NULL != category)
{
if (FALSE != ListWidget_AddDevicesToCategory(self, category, &discoveredList))
{
ListWidget_ResetCategoryCounter(category);
devicesAdded = TRUE;
}
}
index = discoveredList.size();
while(index--)
discoveredList[index]->Release();
}
if (self->activeItems.size() > 0)
{
if (0 == activeItemsCount)
{
if (0 != SetTimer(hwnd, LISTWIDGETTIMER_PROGRESS_TICK_ID,
LISTWIDGETTIMER_PROGRESS_TICK_DELAY, ListWidget_ProgressTickCb))
{
self->activityTimerEnabled = TRUE;
}
}
}
else
{
if (0 != activeItemsCount)
{
KillTimer(hwnd, LISTWIDGETTIMER_PROGRESS_TICK_ID);
self->activityTimerEnabled = FALSE;
}
}
if (FALSE != devicesAdded)
{
ListWidget_UpdateLayout(hwnd, ListWidgetLayout_Normal);
}
}
void
ListWidget_UpdateTitleEditorColors(HWND editor, WidgetStyle *style)
{
if (NULL == editor || NULL == style)
return;
EMBEDDEDEDITOR_SET_TEXT_COLOR(editor, WIDGETSTYLE_TEXT_COLOR(style));
EMBEDDEDEDITOR_SET_BACK_COLOR(editor, WIDGETSTYLE_BACK_COLOR(style));
EMBEDDEDEDITOR_SET_BORDER_COLOR(editor, WIDGETSTYLE_TEXT_EDITOR_BORDER_COLOR(style));
InvalidateRect(editor, NULL, TRUE);
}
static BOOL
ListWidget_DeviceAdd(HWND hwnd, ifc_device *device, DeviceImage *deviceImage)
{
ListWidget *self;
ListWidgetCategory *category;
ListWidgetGroup *group;
ListWidgetItem *item;
self = WIDGET_GET_SELF(hwnd, ListWidget);
if (NULL == self)
return FALSE;
if (NULL == self ||
NULL == device ||
FALSE != device->GetHidden() &&
// excludes 'cloud' devices from appearing
lstrcmpiA(device->GetConnection(), "cloud"))
{
return FALSE;
}
category = ListWidget_FindCategory(self, (FALSE != device->GetAttached()) ? "attached" : "discovered");
if (NULL == category)
return FALSE;
group = ListWidget_FindGroup(category, device->GetType());
if (NULL == group)
{
group = ListWidget_CreateGroup(device->GetType());
if (NULL == group)
return FALSE;
ListWidget_AddGroup(category, group);
ListWidget_SortCategory(category);
}
item = ListWidget_FindGroupItem(group, device->GetName());
if (NULL != item)
return FALSE;
item = ListWidget_CreateItemFromDevice(self, device);
if (NULL == item)
return NULL;
if (NULL == item->image && NULL != deviceImage)
{
item->image = deviceImage;
DeviceImage_AddRef(item->image);
}
ListWidget_AddItem(group, item);
ListWidget_SortGroup(group);
if (NULL != item->activity)
ListWidget_RegisterActiveItem(self, hwnd, item);
ListWidget_ResetCategoryCounter(category);
if (FALSE == category->collapsed)
{
ListWidget_UpdateLayout(hwnd,
ListWidgetLayout_UpdateNow | ListWidgetLayout_KeepStable);
}
else
{
RECT rect;
POINT origin;
CopyRect(&rect, &category->rect);
if (FALSE != ListWidget_GetViewOrigin(hwnd, &origin))
OffsetRect(&rect, origin.x, origin.y);
InvalidateRect(hwnd, &rect, FALSE);
}
return TRUE;
}
static BOOL
ListWidget_DeviceRemove(HWND hwnd, ifc_device *device)
{
ListWidget *self;
self = WIDGET_GET_SELF(hwnd, ListWidget);
if (NULL == self || NULL == device)
return FALSE;
ListWidget_RemoveItem(self, hwnd, device->GetName());
ListWidget_UpdateHover(self, hwnd);
return TRUE;
}
static BOOL
ListWidget_DeviceAttach(HWND hwnd, ifc_device *device)
{
ListWidget *self;
ListWidgetCategory *category;
ListWidgetItem *item;
DeviceImage *image;
BOOL result;
self = WIDGET_GET_SELF(hwnd, ListWidget);
if (NULL == self || NULL == device)
return FALSE;
image = NULL;
category = ListWidget_FindCategory(self, "discovered");
if (NULL != category)
{
ListWidgetGroup *group = ListWidget_FindGroup(category, device->GetType());
if (NULL != group)
{
item = ListWidget_FindGroupItem(group, device->GetName());
if (NULL != item)
{
image = item->image;
if (NULL != image)
DeviceImage_AddRef(image);
ListWidget_RemoveItem(self, hwnd, device->GetName());
}
}
}
result = ListWidget_DeviceAdd(hwnd, device, image);
if (NULL != image)
DeviceImage_Release(image);
return result;
}
static BOOL
ListWidget_DeviceDetach(HWND hwnd, ifc_device *device)
{
ListWidget *self;
ListWidgetCategory *category;
ListWidgetItem *item;
DeviceImage *image;
BOOL result;
self = WIDGET_GET_SELF(hwnd, ListWidget);
if (NULL == self || NULL == device)
return FALSE;
image = NULL;
category = ListWidget_FindCategory(self, "attached");
if (NULL != category)
{
ListWidgetGroup *group = ListWidget_FindGroup(category, device->GetType());
if (NULL != group)
{
item = ListWidget_FindGroupItem(group, device->GetName());
if (NULL != item)
{
image = item->image;
if (NULL != image)
DeviceImage_AddRef(image);
ListWidget_RemoveItem(self, hwnd, device->GetName());
}
}
}
result = ListWidget_DeviceAdd(hwnd, device, image);
if (NULL != image)
DeviceImage_Release(image);
return result;
}
static BOOL
ListWidget_DeviceTitleChanged(HWND hwnd, ifc_device *device)
{
ListWidget *self;
ListWidgetItem *item;
ListWidgetCategory *category;
wchar_t buffer[1024] = {0};
self = WIDGET_GET_SELF(hwnd, ListWidget);
if (NULL == self || NULL == device)
return FALSE;
item = ListWidget_FindItem(self, device->GetName(), &category, NULL);
if (NULL == item)
return FALSE;
if (FAILED(device->GetDisplayName(buffer, ARRAYSIZE(buffer))))
return FALSE;
ListWidget_SetItemTitle(item, buffer);
if (NULL == category ||
FALSE == category->collapsed)
{
ListWidget_UpdateLayout(hwnd, ListWidgetLayout_UpdateNow | ListWidgetLayout_KeepStable);
ListWidget_TooltipUpdateText(self, self->tooltip, item, Tooltip_DeviceTitleChanged);
if (STATUS_ERROR != self->selectionStatus &&
item == self->selectedItem)
{
ListWidget_UpdateSelectionStatus(self, hwnd, FALSE);
}
}
return TRUE;
}
static BOOL
ListWidget_DeviceSpaceChanged(HWND hwnd, ifc_device *device)
{
ListWidget *self;
ListWidgetItem *item;
ListWidgetCategory *category;
self = WIDGET_GET_SELF(hwnd, ListWidget);
if (NULL == self || NULL == device)
return FALSE;
item = ListWidget_FindItem(self, device->GetName(), &category, NULL);
if (NULL == item)
return FALSE;
if (FAILED(device->GetTotalSpace(&item->spaceTotal)))
return FALSE;
if (FAILED(device->GetUsedSpace(&item->spaceUsed)))
return FALSE;
if (NULL == category ||
FALSE == category->collapsed)
{
RECT rect;
POINT origin;
ListWidgetItemMetric metrics;
WidgetStyle *style;
CopyRect(&rect, &item->rect);
if (FALSE != ListWidget_GetViewOrigin(hwnd, &origin))
OffsetRect(&rect, origin.x, origin.y);
style = WIDGET_GET_STYLE(hwnd);
if (NULL != style && FALSE != ListWidget_GetItemMetrics(style, &metrics))
{
rect.top += metrics.offsetTop +
metrics.imageOffsetTop +
self->imageSize.cy +
metrics.imageOffsetBottom +
metrics.spacebarOffsetTop;
rect.left += metrics.offsetLeft;
rect.right -= metrics.offsetRight;
rect.bottom = rect.top + metrics.spacebarHeight;
}
InvalidateRect(hwnd, &rect, FALSE);
UpdateWindow(hwnd);
ListWidget_TooltipUpdateText(self, self->tooltip, item, Tooltip_DeviceSpaceChanged);
if (STATUS_ERROR != self->selectionStatus &&
item == self->selectedItem)
{
ListWidget_UpdateSelectionSpaceStatus(self, hwnd, FALSE);
}
}
return TRUE;
}
static BOOL
ListWidget_DeviceIconChanged(HWND hwnd, ifc_device *device)
{
ListWidget *self;
ListWidgetItem *item;
ListWidgetCategory *category;
DeviceImage *previousImage;
self = WIDGET_GET_SELF(hwnd, ListWidget);
if (NULL == self || NULL == device)
return FALSE;
item = ListWidget_FindItem(self, device->GetName(), &category, NULL);
if (NULL == item)
return FALSE;
previousImage = item->image;
item->image = NULL;
if (NULL == category ||
FALSE == category->collapsed)
{
RECT rect;
POINT origin;
ListWidgetItemMetric metrics;
WidgetStyle *style;
style = WIDGET_GET_STYLE(hwnd);
if (NULL == style ||
FALSE == ListWidget_GetItemMetrics(style, &metrics) ||
FALSE == ListWidget_GetItemImageRect(self, item, &metrics, &rect))
{
CopyRect(&rect, &item->rect);
}
if (FALSE != ListWidget_GetViewOrigin(hwnd, &origin))
OffsetRect(&rect, origin.x, origin.y);
InvalidateRect(hwnd, &rect, FALSE);
UpdateWindow(hwnd);
}
if (NULL != previousImage)
DeviceImage_Release(previousImage);
return TRUE;
}
static BOOL
ListWidget_DeviceCommandChanged(HWND hwnd, ifc_device *device)
{
ListWidget *self;
ListWidgetItem *item;
self = WIDGET_GET_SELF(hwnd, ListWidget);
if (NULL == self || NULL == device)
return FALSE;
item = ListWidget_FindItem(self, device->GetName(), NULL, NULL);
if (NULL == item)
return FALSE;
if (item == self->hoveredItem &&
NULL == self->activeMenu)
{
ListWidget_UpdateActiveCommands(self, hwnd);
}
return TRUE;
}
static BOOL
ListWidget_DeviceActivityStarted(HWND hwnd, ifc_device *device)
{
ListWidget *self;
ListWidgetItem *item;
ListWidgetCategory *category;
size_t index;
self = WIDGET_GET_SELF(hwnd, ListWidget);
if (NULL == self || NULL == device)
return FALSE;
item = ListWidget_FindItem(self, device->GetName(), &category, NULL);
if (NULL == item)
return FALSE;
index = self->activeItems.size();
while(index--)
{
if (item == self->activeItems[index])
return FALSE;
}
if (FALSE != ListWidget_CreateItemActivity(item))
{
ifc_deviceactivity *activity;
ListWidget_RegisterActiveItem(self, hwnd, item);
if(S_OK == device->GetActivity(&activity) &&
NULL != activity)
{
ListWidget_UpdateItemActivity(item, activity);
activity->Release();
}
}
if (NULL == category ||
FALSE == category->collapsed)
{
ListWidget_InvalidateItemImage(self, hwnd, item);
if (STATUS_ERROR != self->selectionStatus &&
item == self->selectedItem)
{
ListWidget_UpdateSelectionStatus(self, hwnd, FALSE);
}
}
if (item == self->hoveredItem &&
NULL == self->activeMenu)
{
ListWidget_UpdateActiveCommands(self, hwnd);
}
return TRUE;
}
static BOOL
ListWidget_DeviceActivityFinished(HWND hwnd, ifc_device *device)
{
ListWidget *self;
ListWidgetItem *item;
ListWidgetCategory *category;
BOOL activityChanged;
self = WIDGET_GET_SELF(hwnd, ListWidget);
if (NULL == self || NULL == device)
return FALSE;
item = ListWidget_FindItem(self, device->GetName(), &category, NULL);
if (NULL == item)
return FALSE;
activityChanged = FALSE;
if (FALSE != ListWidget_UnregisterActiveItem(self, hwnd, item))
activityChanged = TRUE;
if (FALSE != ListWidget_DeleteItemActivity(item))
activityChanged = TRUE;
if (FALSE != activityChanged)
{
if (NULL == category ||
FALSE == category->collapsed)
{
ListWidget_InvalidateItemImage(self, hwnd, item);
}
if (item == self->hoveredItem &&
NULL == self->activeMenu)
{
ListWidget_UpdateActiveCommands(self, hwnd);
}
if (STATUS_ERROR != self->selectionStatus &&
item == self->selectedItem)
{
ListWidget_UpdateSelectionStatus(self, hwnd, FALSE);
}
}
return TRUE;
}
static BOOL
ListWidget_DeviceActivityChanged(HWND hwnd, ifc_device *device)
{
ListWidget *self;
ListWidgetItem *item;
ListWidgetCategory *category;
ifc_deviceactivity *activity;
ListWidgetActivityChange changes;
self = WIDGET_GET_SELF(hwnd, ListWidget);
if (NULL == self || NULL == device)
return FALSE;
item = ListWidget_FindItem(self, device->GetName(), &category, NULL);
if (NULL == item)
return FALSE;
if (S_OK == device->GetActivity(&activity) &&
NULL != activity)
{
changes = ListWidget_UpdateItemActivity(item, activity);
activity->Release();
}
else
changes = ListWidgetActivityChanged_Nothing;
//if (FALSE != self->activityTimerEnabled)
// changes &= ~ListWidgetActivityChanged_Percent;
if (ListWidgetActivityChanged_Nothing != changes &&
(NULL == category || FALSE == category->collapsed))
{
ListWidget_InvalidateItemActivity(self, hwnd, item, changes);
ListWidget_TooltipUpdateText(self, self->tooltip, item, Tooltip_DeviceActivityChanged);
if (0 != (ListWidgetActivityChanged_Title & changes) &&
STATUS_ERROR != self->selectionStatus &&
item == self->selectedItem)
{
ListWidget_UpdateSelectionStatus(self, hwnd, FALSE);
}
}
return TRUE;
}
static BOOL
ListWidget_DeviceModelChanged(HWND hwnd, ifc_device *device)
{
ListWidget *self;
ListWidgetItem *item;
ListWidgetCategory *category;
self = WIDGET_GET_SELF(hwnd, ListWidget);
if (NULL == self || NULL == device)
return FALSE;
item = ListWidget_FindItem(self, device->GetName(), &category, NULL);
if (NULL == item)
return FALSE;
if (NULL == category ||
FALSE == category->collapsed)
{
ListWidget_TooltipUpdateText(self, self->tooltip, item, Tooltip_DeviceModelChanged);
if (STATUS_ERROR != self->selectionStatus &&
item == self->selectedItem)
{
ListWidget_UpdateSelectionStatus(self, hwnd, FALSE);
}
}
return TRUE;
}
static BOOL
ListWidget_DeviceStatusChanged(HWND hwnd, ifc_device *device)
{
ListWidget *self;
ListWidgetItem *item;
ListWidgetCategory *category;
self = WIDGET_GET_SELF(hwnd, ListWidget);
if (NULL == self || NULL == device)
return FALSE;
item = ListWidget_FindItem(self, device->GetName(), &category, NULL);
if (NULL == item)
return FALSE;
if (NULL == category ||
FALSE == category->collapsed)
{
ListWidget_TooltipUpdateText(self, self->tooltip, item, Tooltip_DeviceStatusChanged);
if (STATUS_ERROR != self->selectionStatus &&
item == self->selectedItem)
{
ListWidget_UpdateSelectionStatus(self, hwnd, FALSE);
}
}
return TRUE;
}
static void
ListWidget_DeviceCb(ifc_device *device, DeviceEvent eventId, void *user)
{
HWND hwnd;
hwnd = (HWND)user;
switch(eventId)
{
case Event_DeviceAdded:
ListWidget_DeviceAdd(hwnd, device, NULL);
break;
case Event_DeviceRemoved:
ListWidget_DeviceRemove(hwnd, device);
break;
case Event_DeviceHidden:
ListWidget_DeviceRemove(hwnd, device);
break;
case Event_DeviceShown:
ListWidget_DeviceAdd(hwnd, device, NULL);
break;
case Event_DeviceAttached:
ListWidget_DeviceAttach(hwnd, device);
break;
case Event_DeviceDetached:
ListWidget_DeviceDetach(hwnd, device);
break;
case Event_DeviceDisplayNameChanged:
ListWidget_DeviceTitleChanged(hwnd, device);
break;
case Event_DeviceTotalSpaceChanged:
ListWidget_DeviceSpaceChanged(hwnd, device);
break;
case Event_DeviceUsedSpaceChanged:
ListWidget_DeviceSpaceChanged(hwnd, device);
break;
case Event_DeviceIconChanged:
ListWidget_DeviceIconChanged(hwnd, device);
break;
case Event_DeviceActivityStarted:
ListWidget_DeviceActivityStarted(hwnd, device);
break;
case Event_DeviceActivityFinished:
ListWidget_DeviceActivityFinished(hwnd, device);
break;
case Event_DeviceActivityChanged:
ListWidget_DeviceActivityChanged(hwnd, device);
break;
case Event_DeviceCommandChanged:
ListWidget_DeviceCommandChanged(hwnd, device);
break;
case Event_DeviceModelChanged:
ListWidget_DeviceModelChanged(hwnd, device);
break;
case Event_DeviceStatusChanged:
ListWidget_DeviceStatusChanged(hwnd, device);
break;
}
}
static BOOL
ListWidget_RegisterDeviceHandler(ListWidget *self, HWND hwnd)
{
HWND eventRelay;
DeviceEventCallbacks callbacks;
if (NULL == self)
return FALSE;
if (0 != self->deviceHandler)
return FALSE;
eventRelay = Plugin_GetEventRelayWindow();
if (NULL == eventRelay)
return FALSE;
ZeroMemory(&callbacks, sizeof(callbacks));
callbacks.deviceCb = ListWidget_DeviceCb;
self->deviceHandler = EVENTRELAY_REGISTER_HANDLER(eventRelay, &callbacks, hwnd);
return (0 != self->deviceHandler);
}
static BOOL
ListWidget_InitCb(HWND hwnd, void **object, void *param)
{
ListWidget *self;
HWND sliderWindow;
int imageHeight, imageWidth;
self = new ListWidget();
if (NULL == self)
return FALSE;
self->flags = (ListWidgetFlags)0;
self->hoveredItem = NULL;
self->selectedItem = NULL;
self->titleEditItem = NULL;
self->pressedCategory = NULL;
self->itemWidth = 0;
self->spacebarBitmap = NULL;
self->hoverBitmap = NULL;
self->selectBitmap = NULL;
self->inactiveSelectBitmap = NULL;
self->largeBadgeBitmap = NULL;
self->smallBadgeBitmap = NULL;
self->arrowsBitmap = NULL;
self->itemsPerLine = 0;
self->deviceHandler = 0;
self->activeMenu = NULL;
self->previousMouse.x = -1;
self->previousMouse.y = -1;
self->commands = NULL;
self->commandsCount = 0;
self->commandsMax = 0;
self->unknownCommandLargeImage = NULL;
self->unknownCommandSmallImage = NULL;
ZeroMemory(&self->activityMetrics, sizeof(ListWidgetActivityMetric));
self->activityFont = NULL;
self->activityProgressImage = NULL;
self->activityBadgeBitmap = NULL;
self->activityTimerEnabled = FALSE;
SetSizeEmpty(&self->connectionSize);
SetSizeEmpty(&self->primaryCommandSize);
SetSizeEmpty(&self->secondaryCommandSize);
self->selectionStatus = STATUS_ERROR;
self->titleEditor = NULL;
BackBuffer_Initialize(&self->backBuffer, hwnd);
imageHeight = Config_ReadInt("View", "imageHeight", LISTWIDGET_IMAGE_DEFAULT_HEIGHT);
if (imageHeight < LISTWIDGET_IMAGE_MIN_HEIGHT)
imageHeight = LISTWIDGET_IMAGE_MIN_HEIGHT;
else if (imageHeight > LISTWIDGET_IMAGE_MAX_HEIGHT)
imageHeight = LISTWIDGET_IMAGE_MAX_HEIGHT;
imageWidth = (imageHeight * LISTWIDGET_IMAGE_DEFAULT_WIDTH)/LISTWIDGET_IMAGE_DEFAULT_HEIGHT;
ListWidget_SetImageSize(self, hwnd, imageWidth, imageHeight, FALSE);
ListWidget_CreateDefaultCategories(self);
*object = self;
sliderWindow = MANAGERVIEW_GET_ZOOM_SLIDER(GetParent(hwnd));
if (NULL != sliderWindow)
{
int pos;
SendMessage(sliderWindow, TBM_SETPAGESIZE, 0, 10);
SendMessage(sliderWindow, TBM_SETLINESIZE, 0, 10);
SendMessage(sliderWindow, TBM_SETRANGE, TRUE, MAKELPARAM(-100, 100));
SendMessage(sliderWindow, TBM_SETTIC, 0, 0);
if (imageHeight == LISTWIDGET_IMAGE_DEFAULT_HEIGHT)
pos = 0;
else if (imageHeight > LISTWIDGET_IMAGE_DEFAULT_HEIGHT)
pos = (100 * (imageHeight- LISTWIDGET_IMAGE_DEFAULT_HEIGHT))/(LISTWIDGET_IMAGE_MAX_HEIGHT - LISTWIDGET_IMAGE_DEFAULT_HEIGHT);
else
pos = (100 * (imageHeight - LISTWIDGET_IMAGE_MIN_HEIGHT))/(LISTWIDGET_IMAGE_DEFAULT_HEIGHT - LISTWIDGET_IMAGE_MIN_HEIGHT) - 100;
SendMessage(sliderWindow, TBM_SETPOS, TRUE, pos);
}
self->tooltip = ListWidget_TooltipCreate(hwnd);
ListWidget_AddExistingDevices(self, hwnd);
ListWidget_RegisterDeviceHandler(self, hwnd);
return TRUE;
}
static void
ListWidget_DestroyCb(ListWidget *self, HWND hwnd)
{
HWND sliderWindow;
size_t index;
if (NULL == self)
return;
Config_WriteInt("View", "imageHeight", self->imageSize.cy);
if (0 != self->deviceHandler)
{
HWND eventRelay;
eventRelay = Plugin_GetEventRelayWindow();
if (NULL != eventRelay)
{
EVENTRELAY_UNREGISTER_HANDLER(eventRelay, self->deviceHandler);
}
}
index = self->activeItems.size();
if (0 != index)
{
KillTimer(hwnd, LISTWIDGETTIMER_PROGRESS_TICK_ID);
self->activityTimerEnabled = FALSE;
while(index--)
ListWidget_DeleteItemActivity(self->activeItems[index]);
}
index = self->categories.size();
if (0 != index)
{
while(index--)
{
ListWidgetCategory *category = self->categories[index];
Config_WriteBool("CollapsedCategories", category->name, category->collapsed);
ListWidget_DestroyCategory(category);
}
self->categories.clear();
}
ListWidget_RemoveAllConnections(self);
BackBuffer_Uninitialize(&self->backBuffer);
if (NULL != self->spacebarBitmap)
DeleteObject(self->spacebarBitmap);
if (NULL != self->hoverBitmap)
DeleteObject(self->hoverBitmap);
if (NULL != self->selectBitmap)
DeleteObject(self->selectBitmap);
if (NULL != self->inactiveSelectBitmap)
DeleteObject(self->inactiveSelectBitmap);
if (NULL != self->largeBadgeBitmap)
DeleteObject(self->largeBadgeBitmap);
if (NULL != self->smallBadgeBitmap)
DeleteObject(self->smallBadgeBitmap);
if (NULL != self->unknownCommandLargeImage)
DeviceImage_Release(self->unknownCommandLargeImage);
if (NULL != self->unknownCommandSmallImage)
DeviceImage_Release(self->unknownCommandSmallImage);
if (NULL != self->arrowsBitmap)
DeleteObject(self->arrowsBitmap);
if (NULL != self->activityProgressImage)
DeviceImage_Release(self->activityProgressImage);
if (NULL != self->activityBadgeBitmap)
DeleteObject(self->activityBadgeBitmap);
if (NULL != self->activityFont)
DeleteObject(self->activityFont);
ListWidget_TooltipDestroy(self->tooltip);
if (NULL != self->commands)
{
ListWidget_DestroyAllCommands(self->commands, self->commandsCount);
free(self->commands);
}
free(self);
sliderWindow = MANAGERVIEW_GET_ZOOM_SLIDER(GetParent(hwnd));
if (NULL != sliderWindow)
{
ShowWindow(sliderWindow, SW_HIDE);
}
}
static void
ListWidget_LayoutCb(ListWidget *self, HWND hwnd, WidgetStyle *style,
const RECT *clientRect, SIZE *viewSize, BOOL redraw)
{
size_t iCategory, iGroup, iItem;
ListWidgetCategory *category;
ListWidgetGroup *group;
ListWidgetItem *item;
ListWidgetCategoryMetric categoryMetrics;
size_t itemsInLine;
long viewWidth, itemHeight, lineHeight;
long itemTextWidth, itemTextHeightMax, textHeight, fontHeight;
long categoryHeight, categorySpacing, categorySpacingCollapsed;
SIZE itemSpacing, widgetSize, itemSize;
POINT widgetOffset, categoryOffset, itemOffset;
RECT elementRect;
HDC targetDC;
HFONT targetPrevFont;
TEXTMETRIC textMetrics;
if (NULL == style)
return;
viewWidth = RECTWIDTH(*clientRect);
if (FALSE == ListWidget_CalculateItemBaseSize(self, style, &itemSize, &itemTextWidth))
SetSizeEmpty(&itemSize);
self->itemWidth = itemSize.cx;
WIDGETSTYLE_DLU_TO_HORZ_PX_MIN(widgetOffset.x, style, LISTWIDGET_OFFSET_LEFT_DLU, 1);
WIDGETSTYLE_DLU_TO_VERT_PX_MIN(widgetOffset.y, style, LISTWIDGET_OFFSET_TOP_DLU, 1);
WIDGETSTYLE_DLU_TO_HORZ_PX_MIN(categoryOffset.x, style, LISTWIDGET_CATEGORY_OFFSET_LEFT_DLU, 1);
WIDGETSTYLE_DLU_TO_VERT_PX_MIN(categoryOffset.y, style, LISTWIDGET_CATEGORY_OFFSET_TOP_DLU, 1);
WIDGETSTYLE_DLU_TO_VERT_PX_MIN(categorySpacing, style, LISTWIDGET_CATEGORY_SPACING_DLU, 1);
WIDGETSTYLE_DLU_TO_VERT_PX_MIN(categorySpacingCollapsed, style, LISTWIDGET_CATEGORY_SPACING_COLLAPSED_DLU, 1);
WIDGETSTYLE_DLU_TO_HORZ_PX_MIN(itemOffset.x, style, LISTWIDGET_ITEM_OFFSET_LEFT_DLU, 1);
WIDGETSTYLE_DLU_TO_VERT_PX_MIN(itemOffset.y, style, LISTWIDGET_ITEM_OFFSET_TOP_DLU, 1);
WIDGETSTYLE_DLU_TO_HORZ_PX_MIN(itemSpacing.cx, style, LISTWIDGET_ITEM_SPACING_HORZ_DLU, 1);
WIDGETSTYLE_DLU_TO_VERT_PX_MIN(itemSpacing.cy, style, LISTWIDGET_ITEM_SPACING_VERT_DLU, 1);
self->itemsPerLine = ((viewWidth - (widgetOffset.x + itemOffset.x))/* + itemSpacing.cx*/) / (itemSize.cx + itemSpacing.cx);
self->itemsPerLine = MAX(self->itemsPerLine, 1);
itemsInLine = 0;
for (iCategory = 0; iCategory < self->categories.size(); iCategory++)
{
category = self->categories[iCategory];
if (FALSE == category->collapsed)
{
for(iGroup = 0; iGroup < category->groups.size(); iGroup++)
{
group = category->groups[iGroup];
if (itemsInLine < group->items.size())
itemsInLine = group->items.size();
}
}
}
if (self->itemsPerLine < itemsInLine && self->itemsPerLine > 1)
itemSpacing.cx = (LONG)(((viewWidth - (widgetOffset.x + itemOffset.x)) - (itemSize.cx * self->itemsPerLine))/self->itemsPerLine);
if (itemsInLine < self->itemsPerLine)
self->itemsPerLine = itemsInLine;
widgetSize.cx = widgetOffset.x + itemOffset.x + itemSize.cx;
widgetSize.cy = widgetOffset.y;
targetDC = GetDCEx(hwnd, NULL, DCX_CACHE | DCX_NORESETATTRS);
if (NULL != targetDC)
{
targetPrevFont = SelectFont(targetDC, WIDGETSTYLE_CATEGORY_FONT(style));
categoryHeight = Graphics_GetFontHeight(targetDC);
SelectFont(targetDC, WIDGETSTYLE_TEXT_FONT(style));
fontHeight = Graphics_GetFontHeight(targetDC);
itemTextHeightMax = LISTWIDGET_ITEM_TITLE_MAX_LINES * fontHeight;
}
else
{
targetPrevFont = NULL;
itemTextHeightMax = 0;
categoryHeight = 0;
fontHeight = 0;
}
if (NULL == targetDC ||
FALSE == GetTextMetrics(targetDC, &textMetrics))
{
ZeroMemory(&textMetrics, sizeof(textMetrics));
}
if (FALSE != ListWidget_GetCategoryMetrics(style, &categoryMetrics))
{
if (categoryHeight < categoryMetrics.minHeight)
categoryHeight = categoryMetrics.minHeight;
categoryHeight += categoryMetrics.offsetTop + categoryMetrics.offsetBottom +
categoryMetrics.lineHeight + categoryMetrics.lineOffsetTop;
}
for (iCategory = 0; iCategory < self->categories.size(); iCategory++)
{
category = self->categories[iCategory];
SetRect(&category->rect, 0, 0, viewWidth, categoryHeight);
long offsetX = clientRect->left + categoryOffset.x;
long offsetY = clientRect->top + widgetSize.cy;
if (0 == iCategory)
offsetY += categoryOffset.y;
else
{
if (FALSE == self->categories[iCategory - 1]->collapsed)
offsetY += categorySpacing;
else
offsetY += categorySpacingCollapsed;
}
OffsetRect(&category->rect, offsetX, offsetY);
widgetSize.cy = category->rect.bottom - clientRect->top;
size_t itemsInCategory = 0;
if (FALSE == category->collapsed)
{
for(iGroup = 0; iGroup < category->groups.size(); iGroup++)
{
group = category->groups[iGroup];
itemsInLine = 1;
lineHeight = 0;
if (0 != group->items.size())
{
if (0 == iGroup)
widgetSize.cy += itemOffset.y;
else
widgetSize.cy += itemSpacing.cy;
for(iItem = 0; iItem < group->items.size(); iItem++, itemsInLine++)
{
item = group->items[iItem];
if (itemsInLine > self->itemsPerLine)
{
widgetSize.cy += lineHeight + itemSpacing.cy;
lineHeight = 0;
itemsInLine = 1;
}
itemHeight = itemSize.cy;
itemsInCategory++;
if (-1 == item->titleSize.cy)
{
if (FALSE == IS_STRING_EMPTY(item->title))
{
SetRect(&elementRect, 0, 0, itemTextWidth - textMetrics.tmAveCharWidth/2, 0);
if (FALSE != DrawText(targetDC, item->title, -1, &elementRect,
DT_NOPREFIX | DT_CALCRECT | DT_EDITCONTROL | DT_WORDBREAK))
{
SetSize(&item->titleSize, RECTWIDTH(elementRect), RECTHEIGHT(elementRect));
item->titleSize.cx += textMetrics.tmAveCharWidth/2;
if (item->titleSize.cx > itemTextWidth)
item->titleSize.cx = itemTextWidth;
}
else
SetSizeEmpty(&item->titleSize);
}
else
{
SetSize(&item->titleSize, 0, textMetrics.tmHeight);
}
}
textHeight = item->titleSize.cy;
if (textHeight > itemTextHeightMax)
{
textHeight = itemTextHeightMax;
ListWidgetItem_SetTextTruncated(item);
}
itemHeight += textHeight;
SetRect(&item->rect, 0, 0, itemSize.cx, itemHeight);
offsetX = long(clientRect->left + itemOffset.x +
(itemsInLine - 1)*(itemSize.cx + itemSpacing.cx));
offsetY = clientRect->top + widgetSize.cy;
OffsetRect(&item->rect, offsetX, offsetY);
if (lineHeight < itemHeight)
lineHeight = itemHeight;
}
if (0 != lineHeight)
widgetSize.cy += lineHeight;
}
}
if (0 == itemsInCategory &&
FALSE == IS_STRING_EMPTY(category->emptyText))
{
SetRect(&category->emptyTextRect, 0, 0, viewWidth - textMetrics.tmAveCharWidth/2, 0);
if (FALSE != DrawText(targetDC, category->emptyText, -1, &category->emptyTextRect,
DT_NOPREFIX | DT_CALCRECT | DT_EDITCONTROL | DT_WORDBREAK))
{
category->emptyTextRect.right += textMetrics.tmAveCharWidth/2;
if (category->emptyTextRect.right > viewWidth)
category->emptyTextRect.right = viewWidth;
offsetX = clientRect->left + categoryOffset.x +
(viewWidth - category->emptyTextRect.right)/2;
offsetY = clientRect->top + widgetSize.cy + itemOffset.y + fontHeight/2;
OffsetRect(&category->emptyTextRect, offsetX, offsetY);
widgetSize.cy += RECTHEIGHT(category->emptyTextRect) + itemOffset.y + fontHeight;
}
else
SetRectEmpty(&category->emptyTextRect);
}
}
else
{
for(iGroup = 0; iGroup < category->groups.size(); iGroup++)
{
group = category->groups[iGroup];
for(iItem = 0; iItem < group->items.size(); iItem++, itemsInLine++)
{
item = group->items[iItem];
SetRectEmpty(&item->rect);
itemsInCategory++;
}
}
}
}
widgetSize.cy += WIDGETSTYLE_DLU_TO_VERT_PX(style, LISTWIDGET_OFFSET_BOTTOM_DLU);
viewSize->cx = widgetSize.cx;
viewSize->cy = widgetSize.cy;
size_t commandsMax = 1;
if (self->commandsMax != commandsMax)
{
if (NULL != self->commands)
{
ListWidget_DestroyAllCommands(self->commands, self->commandsCount);
free(self->commands);
}
self->commandsCount = 0;
self->commands = (ListWidgetCommand**)malloc(sizeof(ListWidgetCommand*) * commandsMax);
if (NULL != self->commands)
self->commandsMax = commandsMax;
else
self->commandsMax = 0;
}
if (NULL != targetDC)
{
SelectFont(targetDC, targetPrevFont);
ReleaseDC(hwnd, targetDC);
}
}
static BOOL
ListWidget_PaintCb(ListWidget *self, HWND hwnd, WidgetStyle *style, HDC hdc, const RECT *paintRect, BOOL erase)
{
size_t iCategory, iGroup, iItem;
ListWidgetCategory *category;
ListWidgetGroup *group;
ListWidgetItem *item;
HFONT prevFont;
FillRegion fillRegion;
ListWidgetPaint paint;
size_t itemsInCategory;
if (FALSE == ListWidgetPaint_Initialize(&paint, self, style, hwnd, hdc, paintRect, erase))
return FALSE;
SetTextColor(hdc, style->textColor);
SetBkColor(hdc, style->backColor);
SetBkMode(hdc, TRANSPARENT);
prevFont = SelectFont(hdc, style->textFont);
FillRegion_Init(&fillRegion, paintRect);
if (FALSE != erase)
{
for (iCategory = 0; iCategory < self->categories.size(); iCategory++)
{
category = self->categories[iCategory];
FillRegion_ExcludeRect(&fillRegion, &category->rect);
if (FALSE == category->collapsed)
{
itemsInCategory = 0;
for(iGroup = 0; iGroup < category->groups.size(); iGroup++)
{
group = category->groups[iGroup];
for(iItem = 0; iItem < group->items.size(); iItem++)
{
item = group->items[iItem];
itemsInCategory++;
FillRegion_ExcludeRect(&fillRegion, &item->rect);
}
}
if (0 == itemsInCategory &&
FALSE == IS_STRING_EMPTY(category->emptyText))
{
FillRegion_ExcludeRect(&fillRegion, &category->emptyTextRect);
}
}
}
FillRegion_BrushFill(&fillRegion, hdc, style->backBrush);
FillRegion_SetEmpty(&fillRegion);
}
for (iCategory = 0; iCategory < self->categories.size(); iCategory++)
{
category = self->categories[iCategory];
if (FALSE == ListWidgetPaint_DrawCategory(&paint, category))
FillRegion_AppendRect(&fillRegion, &category->rect);
if (FALSE == category->collapsed)
{
itemsInCategory = 0;
for(iGroup = 0; iGroup < category->groups.size(); iGroup++)
{
group = category->groups[iGroup];
for(iItem = 0; iItem < group->items.size(); iItem++)
{
item = group->items[iItem];
itemsInCategory++;
if (FALSE == ListWidgetPaint_DrawItem(&paint, item))
FillRegion_AppendRect(&fillRegion, &item->rect);
}
}
if (0 == itemsInCategory &&
FALSE == IS_STRING_EMPTY(category->emptyText))
{
if (FALSE == ListWidgetPaint_DrawEmptyCategoryText(&paint, category))
FillRegion_AppendRect(&fillRegion, &category->emptyTextRect);
}
}
}
FillRegion_BrushFill(&fillRegion, hdc, style->backBrush);
FillRegion_Uninit(&fillRegion);
SelectFont(hdc, prevFont);
ListWidgetPaint_Uninitialize(&paint);
return TRUE;
}
static void
ListWidget_StyleColorChangedCb(ListWidget *self, HWND hwnd, WidgetStyle *style)
{
if (NULL == self)
return;
if (NULL != self->spacebarBitmap)
{
DeleteObject(self->spacebarBitmap);
self->spacebarBitmap = NULL;
}
if (NULL != self->hoverBitmap)
{
DeleteObject(self->hoverBitmap);
self->hoverBitmap = NULL;
}
if (NULL != self->selectBitmap)
{
DeleteObject(self->selectBitmap);
self->selectBitmap = NULL;
}
if (NULL != self->inactiveSelectBitmap)
{
DeleteObject(self->inactiveSelectBitmap);
self->inactiveSelectBitmap = NULL;
}
if (NULL != self->arrowsBitmap)
{
DeleteObject(self->arrowsBitmap);
self->arrowsBitmap = NULL;
}
ListWidget_ResetConnnectionsColors(self, style);
if (NULL != self->titleEditor)
ListWidget_UpdateTitleEditorColors(self->titleEditor, style);
}
static void
ListWidget_StyleFontChangedCb(ListWidget *self, HWND hwnd, WidgetStyle *style)
{
size_t iCategory, iGroup, iItem;
ListWidgetCategory *category;
ListWidgetGroup *group;
ListWidgetItem *item;
if (NULL == self)
return;
for (iCategory = 0; iCategory < self->categories.size(); iCategory++)
{
category = self->categories[iCategory];
category->countWidth = -1;
category->titleWidth = -1;
SetRect(&category->emptyTextRect, -1, -1, -1, -1);
for(iGroup = 0; iGroup < category->groups.size(); iGroup++)
{
group = category->groups[iGroup];
for(iItem = 0; iItem < group->items.size(); iItem++)
{
item = group->items[iItem];
SetSize(&item->titleSize, -1, -1);
}
}
}
ListWidget_TooltipFontChanged(self->tooltip);
if (NULL != self->titleEditor)
SendMessage(self->titleEditor, WM_SETFONT, (WPARAM)WIDGETSTYLE_TEXT_FONT(style), TRUE);
}
static BOOL
ListWidget_MouseMoveCb(ListWidget *self, HWND hwnd, unsigned int vKeys, const POINT *cursor)
{
if (self->previousMouse.x == cursor->x &&
self->previousMouse.y == cursor->y)
{
return TRUE;
}
self->previousMouse = *cursor;
if (FALSE != ListWidget_UpdateHoverEx(self, hwnd, cursor))
UpdateWindow(hwnd);
ListWidget_TooltipRelayMouseMessage(self->tooltip, WM_MOUSEMOVE, vKeys, cursor);
return TRUE;
}
static BOOL
ListWidget_LeftButtonDownCb(ListWidget *self, HWND hwnd, unsigned int vKeys, const POINT *cursor)
{
ListWidgetItem *selectedItem;
ListWidgetCategory *pressedCategory;
ListWidgetItemPart pressedPart;
ListWidgetCommand *command, *pressedCommand;
WidgetStyle *style;
RECT rect, pressedPartRect;
POINT pt, origin;
size_t index;
style = WIDGET_GET_STYLE(hwnd);
if (NULL == style)
return FALSE;
pt = *cursor;
if (FALSE == ListWidget_GetViewOrigin(hwnd, &origin))
{
origin.x = 0;
origin.y = 0;
}
selectedItem = NULL;
pressedCategory = NULL;
pressedPart = ListWidgetItemPart_None;
pressedCommand = NULL;
if (FALSE != GetClientRect(hwnd, &rect) &&
FALSE != PtInRect(&rect, pt))
{
pt.x -= origin.x;
pt.y -= origin.y;
pressedCategory = ListWidget_GetCategoryFromPoint(self, pt);
if (NULL == pressedCategory)
{
selectedItem = ListWidget_GetItemFromPoint(self, pt);
if (NULL != selectedItem)
{
ListWidgetItemMetric metrics;
if (FALSE != ListWidget_GetItemMetrics(style, &metrics))
{
pressedPart = ListWidgetItemPart_Command;
if (selectedItem == self->selectedItem)
pressedPart |= ListWidgetItemPart_Title;
pressedPart = ListWidget_GetItemPartFromPoint(self, selectedItem, &metrics, pt,
pressedPart, &pressedPartRect);
if (ListWidgetItemPart_Title == pressedPart &&
self->titleEditItem != selectedItem &&
hwnd == GetFocus() &&
FALSE == ListWidgetItem_IsTextEdited(selectedItem))
{
self->titleEditItem = selectedItem;
SetTimer(hwnd, LISTWIDGETTIMER_EDIT_TITLE_ID,
GetDoubleClickTime() + 1,
ListWidget_BeginTitleEditTimerCb);
}
}
}
}
}
if (NULL != pressedCategory)
{
ListWidgetCategoryMetric metrics;
if (FALSE == ListWidget_GetCategoryMetrics(style, &metrics))
SetRectEmpty(&rect);
else
{
CopyRect(&rect, &pressedCategory->rect);
rect.left += metrics.offsetLeft;
rect.top += metrics.offsetTop;
rect.right = rect.left + metrics.iconWidth;
rect.bottom -= (metrics.offsetBottom + metrics.lineHeight + metrics.lineOffsetTop);
}
if (FALSE == PtInRect(&rect, pt))
pressedCategory = NULL;
}
self->pressedCategory = pressedCategory;
ListWidget_SelectItem(self, hwnd, selectedItem, FALSE);
ListWidget_EnsureFocused(self, hwnd, FALSE);
if (ListWidgetItemPart_Command == pressedPart &&
NULL != selectedItem)
{
OffsetRect(&pressedPartRect, -selectedItem->rect.left, -selectedItem->rect.top);
}
index = self->commandsCount;
while(index--)
{
command = self->commands[index];
if (NULL == pressedCommand &&
ListWidgetItemPart_Command == pressedPart &&
ListWidget_GetCommandRectEqual(command, &pressedPartRect))
{
pressedCommand = command;
}
if (FALSE != ListWidget_GetCommandPressed(command) ||
pressedCommand == command)
{
if (FALSE != ListWidget_SetCommandPressed(pressedCommand, (pressedCommand == command)) &&
FALSE != ListWidget_GetCommandRect(command, &rect) &&
NULL != selectedItem)
{
OffsetRect(&rect, selectedItem->rect.left + origin.x, selectedItem->rect.top + origin.y);
InvalidateRect(hwnd, &rect, FALSE);
}
}
}
if (NULL != pressedCommand)
self->flags |= ListWidgetFlag_LButtonDownOnCommand;
else
self->flags &= ~ListWidgetFlag_LButtonDownOnCommand;
if (GetCapture() != hwnd)
SetCapture(hwnd);
UpdateWindow(hwnd);
ListWidget_TooltipHide(self->tooltip);
return TRUE;
}
static BOOL
ListWidget_LeftButtonUpCb(ListWidget *self, HWND hwnd, unsigned int vKeys, const POINT *cursor)
{
WidgetStyle *style;
RECT rect;
POINT pt, origin;
ListWidgetCategory *pressedCategory;
ListWidgetCommand *pressedCommand;
size_t index;
BOOL updateWindow;
style = WIDGET_GET_STYLE(hwnd);
pt = *cursor;
if (FALSE == ListWidget_GetViewOrigin(hwnd, &origin))
{
origin.x = 0;
origin.y = 0;
}
pressedCategory = NULL;
pressedCommand = NULL;
updateWindow = FALSE;
if (FALSE != GetClientRect(hwnd, &rect) &&
FALSE != PtInRect(&rect, pt))
{
pt.x -= origin.x;
pt.y -= origin.y;
pressedCategory = ListWidget_GetCategoryFromPoint(self, pt);
if (NULL == pressedCategory)
{
if (NULL != self->selectedItem &&
FALSE != ListWidgetItem_IsInteractive(self->selectedItem))
{
index = self->commandsCount;
while(index--)
{
if (FALSE != ListWidget_GetCommandRect(self->commands[index], &rect))
{
OffsetRect(&rect, self->selectedItem->rect.left, self->selectedItem->rect.top);
if (PtInRect(&rect, pt))
{
pressedCommand = self->commands[index];
if (FALSE != ListWidget_GetCommandDisabled(pressedCommand) ||
FALSE == ListWidget_GetCommandPressed(pressedCommand))
{
pressedCommand = NULL;
}
break;
}
}
}
}
}
}
if (NULL != self->pressedCategory)
{
if (NULL != pressedCategory)
{
ListWidgetCategoryMetric metrics;
if (FALSE == ListWidget_GetCategoryMetrics(style, &metrics))
SetRectEmpty(&rect);
else
{
CopyRect(&rect, &pressedCategory->rect);
rect.left += metrics.offsetLeft;
rect.top += metrics.offsetTop;
rect.right = rect.left + metrics.iconWidth;
rect.bottom -= (metrics.offsetBottom + metrics.lineHeight + metrics.lineOffsetTop);
}
if (FALSE == PtInRect(&rect, pt))
pressedCategory = NULL;
}
if(self->pressedCategory == pressedCategory)
{
ListWidget_ToggleCategory(pressedCategory, hwnd);
}
self->pressedCategory = NULL;
}
if (NULL != self->selectedItem)
{
if (NULL != pressedCommand && NULL != self->selectedItem)
{
ListWidget_SendItemCommand(self->selectedItem->name,
ListWidget_GetCommandName(pressedCommand),
hwnd, 0, TRUE);
}
index = self->commandsCount;
while(index--)
{
if (FALSE != ListWidget_GetCommandPressed(self->commands[index]))
{
if (FALSE != ListWidget_SetCommandPressed(self->commands[index], FALSE) &&
FALSE != ListWidget_GetCommandRect(self->commands[index], &rect))
{
OffsetRect(&rect, self->selectedItem->rect.left + origin.x, self->selectedItem->rect.top + origin.y);
InvalidateRect(hwnd, &rect, FALSE);
updateWindow = TRUE;
}
break;
}
}
if (FALSE != ListWidget_EnsureItemVisisble(self, hwnd, self->selectedItem, VISIBLE_NORMAL))
updateWindow = TRUE;
}
if (FALSE != ListWidget_UpdateHoverEx(self, hwnd, cursor))
updateWindow = TRUE;
if (GetCapture() == hwnd)
ReleaseCapture();
if (FALSE != updateWindow)
UpdateWindow(hwnd);
ListWidget_TooltipRelayMouseMessage(self->tooltip, WM_LBUTTONUP, vKeys, cursor);
return TRUE;
}
static BOOL
ListWidget_LeftButtonDblClkCb(ListWidget *self, HWND hwnd, unsigned int vKeys, const POINT *cursor)
{
RECT rect;
POINT pt = *cursor, origin;
ListWidgetCategory *category;
if (NULL != self->titleEditItem)
{
KillTimer(hwnd, LISTWIDGETTIMER_EDIT_TITLE_ID);
self->titleEditItem = NULL;
}
if (0 != (ListWidgetFlag_LButtonDownOnCommand & self->flags))
return FALSE;
if (FALSE == ListWidget_GetViewOrigin(hwnd, &origin))
{
origin.x = 0;
origin.y = 0;
}
if (FALSE != GetClientRect(hwnd, &rect) &&
FALSE != PtInRect(&rect, pt))
{
pt.x -= origin.x;
pt.y -= origin.y;
category = ListWidget_GetCategoryFromPoint(self, pt);
if (NULL != category)
{
ListWidget_ToggleCategory(category, hwnd);
self->pressedCategory = NULL;
return TRUE;
}
ListWidgetItem *item = ListWidget_GetItemFromPointEx(self, pt, &category, NULL);
if (NULL != item)
{
if (NULL != item &&
FALSE != ListWidgetItem_IsInteractive(item))
{
size_t index;
index = self->commandsCount;
while(index--)
{
if (FALSE != ListWidget_GetCommandRect(self->commands[index], &rect))
{
OffsetRect(&rect, item->rect.left, item->rect.top);
if (PtInRect(&rect, pt))
{
item = NULL;
break;
}
}
}
}
if (NULL != item)
{
ListWidget_CallItemAction(self, hwnd, category, item);
return TRUE;
}
}
}
return FALSE;
}
static BOOL
ListWidget_RightButtonDownCb(ListWidget *self, HWND hwnd, unsigned int vKeys, const POINT *cursor)
{
ListWidgetItem *selectedItem;
RECT rect;
POINT pt, origin;
pt = *cursor;
if (NULL != self->titleEditItem)
{
KillTimer(hwnd, LISTWIDGETTIMER_EDIT_TITLE_ID);
self->titleEditItem = NULL;
}
if (FALSE == ListWidget_GetViewOrigin(hwnd, &origin))
{
origin.x = 0;
origin.y = 0;
}
selectedItem = NULL;
if (FALSE != GetClientRect(hwnd, &rect) &&
FALSE != PtInRect(&rect, pt))
{
pt.x -= origin.x;
pt.y -= origin.y;
selectedItem = ListWidget_GetItemFromPoint(self, pt);
}
ListWidget_SelectItem(self, hwnd, selectedItem, TRUE);
ListWidget_EnsureFocused(self, hwnd, FALSE);
if (GetCapture() != hwnd)
SetCapture(hwnd);
UpdateWindow(hwnd);
ListWidget_TooltipRelayMouseMessage(self->tooltip, WM_RBUTTONDOWN, vKeys, cursor);
return FALSE; // allow defwindowproc to get this message
}
static BOOL
ListWidget_RightButtonUpCb(ListWidget *self, HWND hwnd, unsigned int vKeys, const POINT *cursor)
{
RECT rect;
if (FALSE != ListWidget_UpdateHoverEx(self, hwnd, cursor))
UpdateWindow(hwnd);
if (GetCapture() == hwnd)
ReleaseCapture();
ListWidget_TooltipRelayMouseMessage(self->tooltip, WM_RBUTTONUP, vKeys, cursor);
if (FALSE != GetClientRect(hwnd, &rect) &&
FALSE != PtInRect(&rect, *cursor))
{
ListWidgetItem *item;
ListWidgetItemMetric metrics;
POINT pt;
if (FALSE == ListWidget_GetViewOrigin(hwnd, &pt))
{
pt.x = 0;
pt.y = 0;
}
pt.x = cursor->x - pt.x;
pt.y = cursor->y - pt.y;
item = ListWidget_GetItemFromPoint(self, pt);
if (NULL != item)
{
WidgetStyle *style = WIDGET_GET_STYLE(hwnd);
if (NULL != style &&
FALSE != ListWidget_GetItemMetrics(style, &metrics))
{
ListWidgetItemPart part;
part = ListWidgetItemPart_Command | ListWidgetItemPart_Activity;
part = ListWidget_GetItemPartFromPoint(self, item, &metrics, pt, part, NULL);
if (ListWidgetItemPart_None != part)
return TRUE;
}
}
}
return FALSE; // allow defwindowproc to get this message
}
static BOOL
ListWidget_KeyDownCb(ListWidget *self, HWND hwnd, unsigned int vKey, unsigned int flags)
{
ListWidgetItem *selectedItem;
ListWidgetVisibleFlags visibleFlags;
selectedItem = NULL;
visibleFlags = VISIBLE_NORMAL/*VISIBLE_PARTIAL_OK*/;
switch(vKey)
{
case VK_HOME:
ListWidget_EnsureTopVisible(self, hwnd);
visibleFlags |= VISIBLE_ALIGN_TOP | VISIBLE_ALIGN_ALWAYS;
selectedItem = ListWidget_GetFirstItem(self);
break;
case VK_END:
ListWidget_EnsureBottomVisible(self, hwnd);
visibleFlags |= VISIBLE_ALIGN_BOTTOM | VISIBLE_ALIGN_ALWAYS;
selectedItem = ListWidget_GetLastItem(self);
break;
case VK_LEFT:
selectedItem = (NULL != self->selectedItem) ?
ListWidget_GetPreviousItem(self, self->selectedItem) :
ListWidget_GetLastItem(self);
if (NULL == selectedItem)
ListWidget_EnsureTopVisible(self, hwnd);
break;
case VK_RIGHT:
selectedItem = (NULL != self->selectedItem) ?
ListWidget_GetNextItem(self, self->selectedItem) :
ListWidget_GetFirstItem(self);
if (NULL == selectedItem)
ListWidget_EnsureBottomVisible(self, hwnd);
break;
case VK_UP:
selectedItem = (NULL != self->selectedItem) ?
ListWidget_GetPreviousLineItem(self, self->selectedItem) :
ListWidget_GetLastItem(self);
if (NULL == selectedItem)
ListWidget_EnsureTopVisible(self, hwnd);
break;
case VK_DOWN:
selectedItem = (NULL != self->selectedItem) ?
ListWidget_GetNextLineItem(self, self->selectedItem) :
ListWidget_GetFirstItem(self);
if (NULL == selectedItem)
ListWidget_EnsureBottomVisible(self, hwnd);
break;
case VK_PRIOR:
visibleFlags |= VISIBLE_ALIGN_BOTTOM;
selectedItem = (NULL != self->selectedItem) ?
ListWidget_GetPreviousPageItem(self, hwnd, self->selectedItem) :
ListWidget_GetLastItem(self);
if (NULL == selectedItem)
ListWidget_EnsureTopVisible(self, hwnd);
break;
case VK_NEXT:
visibleFlags |= VISIBLE_ALIGN_TOP;
selectedItem = (NULL != self->selectedItem) ?
ListWidget_GetNextPageItem(self, hwnd, self->selectedItem) :
ListWidget_GetFirstItem(self);
if (NULL == selectedItem)
ListWidget_EnsureBottomVisible(self, hwnd);
break;
case VK_RETURN:
if (NULL != self->selectedItem)
{
ListWidget_CallItemAction(self, hwnd, NULL, self->selectedItem);
ListWidget_EnsureItemVisisble(self, hwnd, self->selectedItem, visibleFlags);
}
break;
case VK_F2:
if (NULL != self->selectedItem)
{
if (NULL != self->titleEditor)
DestroyWindow(self->titleEditor);
self->titleEditor = ListWidget_BeginItemTitleEdit(self, hwnd, self->selectedItem);
}
break;
default:
return FALSE;
}
if (NULL != selectedItem)
{
ListWidget_SelectItem(self, hwnd, selectedItem, FALSE);
ListWidget_EnsureItemVisisble(self, hwnd, self->selectedItem, visibleFlags);
}
return TRUE;
}
static BOOL
ListWidget_KeyUpCb(ListWidget *self, HWND hwnd, unsigned int vKey, unsigned int flags)
{
return FALSE;
}
static BOOL
ListWidget_CharacterCb(ListWidget *self, HWND hwnd, unsigned int vKey, unsigned int flags)
{
return FALSE;
}
static INT
ListWidget_InputRequestCb(ListWidget *self, HWND hwnd, unsigned int vKey, MSG *message)
{
INT result;
if (NULL == message)
return DLGC_WANTALLKEYS;
ListWidget_TooltipHide(self->tooltip);
result = DLGC_WANTCHARS;
switch(vKey)
{
case VK_LEFT:
case VK_RIGHT:
case VK_UP:
case VK_DOWN:
case VK_PRIOR:
case VK_NEXT:
case VK_END:
case VK_HOME:
case VK_RETURN:
result |= DLGC_WANTALLKEYS;
break;
}
return result;
}
static void
ListWidget_FocusChangedCb(ListWidget *self, HWND hwnd, HWND focusWindow, BOOL focusReceived)
{
if (NULL == self)
return;
if (NULL == self->selectedItem)
{
if (FALSE != focusReceived && 0 == (ListWidgetFlag_NoFocusSelect & self->flags))
{
BOOL disableSelect;
disableSelect = FALSE;
if (NULL != focusWindow)
{
HWND ancestorWindow;
ancestorWindow = hwnd;
while(NULL != ancestorWindow)
{
ancestorWindow = GetAncestor(ancestorWindow, GA_PARENT);
if (focusWindow == ancestorWindow)
{
wchar_t buffer[64] = {0};
if (0 != GetClassName(focusWindow, buffer, ARRAYSIZE(buffer)) &&
CSTR_EQUAL == CompareString(CSTR_INVARIANT, NORM_IGNORECASE, buffer, -1, L"Winamp Gen", -1))
{
disableSelect = TRUE;
}
break;
}
}
}
if (FALSE == disableSelect)
{
ListWidgetItem *item;
item = ListWidget_GetFirstItem(self);
if (NULL != item)
ListWidget_SelectItem(self, hwnd, item, FALSE);
}
}
}
else
{
POINT origin;
RECT rect;
CopyRect(&rect, &self->selectedItem->rect);
if (FALSE != ListWidget_GetViewOrigin(hwnd, &origin))
OffsetRect(&rect, origin.x, origin.y);
InvalidateRect(hwnd, &rect, FALSE);
UpdateWindow(hwnd);
}
}
static BOOL
ListWidget_ContextMenuCb(ListWidget *self, HWND hwnd, HWND targetWindow, const POINT *cursor)
{
POINT pt;
ListWidgetItem *item;
if (NULL == self)
return FALSE;
if (NULL == cursor ||
(-1 == cursor->x && -1 == cursor->y))
{
if (hwnd != targetWindow)
return FALSE;
item = self->selectedItem;
if (NULL != item)
{
POINT origin;
pt.x = RECTWIDTH(item->rect);
pt.x = item->rect.left + pt.x/2 + pt.x%2;
pt.y = RECTHEIGHT(item->rect);
pt.y = item->rect.top + pt.y/2 + pt.y%2;
if (FALSE != ListWidget_GetViewOrigin(hwnd, &origin))
{
pt.x += origin.x;
pt.y += origin.y;
}
}
else
{
RECT rect;
GetClientRect(hwnd, &rect);
pt.x = rect.left + 2;
pt.y = rect.top + 2;
}
MapWindowPoints(hwnd, HWND_DESKTOP, &pt, 1);
}
else
{
POINT test;
pt = *cursor;
if (FALSE == ListWidget_GetViewOrigin(hwnd, &test))
{
test = pt;
}
else
{
test.x = pt.x - test.x;
test.y = pt.y - test.y;
}
MapWindowPoints(HWND_DESKTOP, hwnd, &test, 1);
item = ListWidget_GetItemFromPoint(self, test);
}
if (NULL == item)
ListWidget_DisplayContextMenu(self, hwnd, pt);
else
ListWidget_DisplayItemContextMenu(self, hwnd, item, pt);
return TRUE;
};
static void
ListWidget_ZoomChangingCb(ListWidget *self, HWND hwnd, NMTRBTHUMBPOSCHANGING *zoomInfo)
{
double pos, height, width;
int cx, cy;
if (NULL == self)
return;
pos = (double)(int)zoomInfo->dwPos;
if (0 == pos)
{
height = LISTWIDGET_IMAGE_DEFAULT_HEIGHT;
}
else if (pos < 0)
{
height = ((LISTWIDGET_IMAGE_DEFAULT_HEIGHT - LISTWIDGET_IMAGE_MIN_HEIGHT) * (100.0 + pos))/100.0;
height += LISTWIDGET_IMAGE_MIN_HEIGHT;
height = floor(height);
}
else
{
height = ((LISTWIDGET_IMAGE_MAX_HEIGHT - LISTWIDGET_IMAGE_DEFAULT_HEIGHT) * pos)/100.0;
height += LISTWIDGET_IMAGE_DEFAULT_HEIGHT;
height = ceil(height);
}
width = (height * LISTWIDGET_IMAGE_DEFAULT_WIDTH)/ LISTWIDGET_IMAGE_DEFAULT_HEIGHT;
cx = (int)(width + 0.5);
cy = (int)(height + 0.5);
if (self->imageSize.cx == cx &&
self->imageSize.cy == cy)
{
return;
}
ListWidget_SetImageSize(self, hwnd, cx, cy, TRUE);
// aTRACE_FMT("zoom changing: pos = %d, width = %d, height = %d\r\n", zoomInfo->dwPos, cx, cy);
}
static void
ListWidget_ScrollCb(ListWidget *self, HWND hwnd, int *dx, int *dy)
{
if (NULL != self->titleEditor)
{
DestroyWindow(self->titleEditor);
self->titleEditor = NULL;
}
if (FALSE != ListWidget_UpdateHover(self, hwnd))
UpdateWindow(hwnd);
ListWidget_TooltipHide(self->tooltip);
}
static BOOL
ListWidget_NotifyCb(ListWidget *self, HWND hwnd, NMHDR *pnmh, LRESULT *result)
{
if (FALSE != ListWidget_TooltipProcessNotification(self, self->tooltip, pnmh, result))
return TRUE;
return FALSE;
}
HWND
ListWidget_CreateWindow(HWND parentWindow, int x, int y, int width, int height, BOOL border, unsigned int controlId)
{
const static WidgetInterface widgetInterface =
{
(WidgetInitCallback)ListWidget_InitCb,
(WidgetDestroyCallback)ListWidget_DestroyCb,
(WidgetLayoutCallback)ListWidget_LayoutCb,
(WidgetPaintCallback)ListWidget_PaintCb,
(WidgetStyleCallback)ListWidget_StyleColorChangedCb,
(WidgetStyleCallback)ListWidget_StyleFontChangedCb,
(WidgetMouseCallback)ListWidget_MouseMoveCb,
(WidgetMouseCallback)ListWidget_LeftButtonDownCb,
(WidgetMouseCallback)ListWidget_LeftButtonUpCb,
(WidgetMouseCallback)ListWidget_LeftButtonDblClkCb,
(WidgetMouseCallback)ListWidget_RightButtonDownCb,
(WidgetMouseCallback)ListWidget_RightButtonUpCb,
(WidgetKeyCallback)ListWidget_KeyDownCb,
(WidgetKeyCallback)ListWidget_KeyUpCb,
(WidgetKeyCallback)ListWidget_CharacterCb,
(WidgetInputCallback)ListWidget_InputRequestCb,
(WidgetFocusCallback)ListWidget_FocusChangedCb,
(WidgetMenuCallback)ListWidget_ContextMenuCb,
(WidgetZoomCallback)ListWidget_ZoomChangingCb,
(WidgetScrollCallback)NULL, /*scrollBefore*/
(WidgetScrollCallback)ListWidget_ScrollCb,
(WidgetNotifyCallback)ListWidget_NotifyCb,
};
return Widget_CreateWindow(WIDGET_TYPE_LIST,
&widgetInterface,
NULL,
(FALSE != border) ? WS_EX_CLIENTEDGE : 0,
WS_TABSTOP,
x, y, width, height,
parentWindow,
controlId, 0L);
}
Reference in New Issue View Git Blame Copy Permalink