winamp/Src/Plugins/Library/ml_devices/statusBar.cpp

1001 lines
22 KiB
C++
Raw Normal View History

2024-09-24 12:54:57 +00:00
#include "main.h"
#include "./statusBar.h"
#include <vector>
#include <strsafe.h>
typedef struct StatusTextBlock
{
wchar_t *text;
size_t length;
long width;
} StatusTextBlock;
typedef struct StaturRecord
{
unsigned int id;
StatusTextBlock mainBlock;
StatusTextBlock rightBlock;
} StatusRecord;
typedef std::vector<StatusRecord*> StatusRecordList;
typedef struct StatusBar
{
HFONT font;
HBRUSH backBrush;
COLORREF textColor;
COLORREF backColor;
StatusRecordList list;
int idealHeight;
long spacing;
long leftBlockMinWidth;
BackBuffer backBuffer;
} StatusBar;
#define STATUSBAR(_hwnd) ((StatusBar*)(LONGX86)GetWindowLongPtrW((_hwnd), 0))
#define STATUSBAR_RET_VOID(_self, _hwnd) {(_self) = STATUSBAR((_hwnd)); if (NULL == (_self)) return;}
#define STATUSBAR_RET_VAL(_self, _hwnd, _error) {(_self) = STATUSBAR((_hwnd)); if (NULL == (_self)) return (_error);}
static LRESULT CALLBACK
StatusBar_WindowProc(HWND hwnd, unsigned int uMsg, WPARAM wParam, LPARAM lParam);
static ATOM
StatusBar_GetClassAtom(HINSTANCE instance)
{
WNDCLASSEXW klass;
ATOM klassAtom;
klassAtom = (ATOM)GetClassInfoExW(instance, STATUSBAR_WINDOW_CLASS, &klass);
if (0 != klassAtom)
return klassAtom;
memset(&klass, 0, sizeof(klass));
klass.cbSize = sizeof(klass);
klass.style = 0;
klass.lpfnWndProc = StatusBar_WindowProc;
klass.cbClsExtra = 0;
klass.cbWndExtra = sizeof(StatusBar*);
klass.hInstance = instance;
klass.hIcon = NULL;
klass.hCursor = LoadCursorW(NULL, (LPCWSTR)IDC_ARROW);
klass.hbrBackground = NULL;
klass.lpszMenuName = NULL;
klass.lpszClassName = STATUSBAR_WINDOW_CLASS;
klass.hIconSm = NULL;
klassAtom = RegisterClassExW(&klass);
return klassAtom;
}
HWND
StatusBar_CreateWindow(unsigned long windowExStyle, const wchar_t *text, unsigned long windowStyle,
int x, int y, int width, int height,
HWND parentWindow, unsigned int controlId)
{
HINSTANCE instance = GetModuleHandleW(NULL);
ATOM klassAtom = StatusBar_GetClassAtom(instance);
if (0 == klassAtom)
return NULL;
return CreateWindowExW(WS_EX_NOPARENTNOTIFY | windowExStyle, (LPCWSTR)MAKEINTATOM(klassAtom), text,
WS_CHILD | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | windowStyle,
x, y, width, height, parentWindow, (HMENU)controlId, instance, NULL);
}
static void
StatusBar_InitTextBlock(StatusTextBlock *block)
{
if (NULL != block)
{
block->text = NULL;
block->length = ((size_t)-1);
block->width = -1;
}
}
static void
StatusBar_FreeTextBlock(StatusTextBlock *block)
{
if (NULL != block)
{
ResourceString_Free(block->text);
StatusBar_InitTextBlock(block);
}
}
static const wchar_t *
StatusBar_RetriveText(StatusTextBlock *block)
{
const wchar_t *source;
if (NULL == block)
return NULL;
source = block->text;
if (FALSE != IS_INTRESOURCE(source) &&
NULL != source)
{
wchar_t buffer[256] = {0};
if (NULL == WASABI_API_LNG)
return NULL;
WASABI_API_LNGSTRINGW_BUF((INT)(INT_PTR)source, buffer, ARRAYSIZE(buffer));
block->text = String_Duplicate(buffer);
}
return block->text;
}
static size_t
StatusBar_GetTextBlockLength(StatusTextBlock *block)
{
const wchar_t *text;
if (NULL == block)
return NULL;
if (((size_t)-1) != block->length)
{
text = StatusBar_RetriveText(block);
block->length = (NULL != text) ? lstrlenW(text) : 0;
}
return block->length;
}
static const wchar_t *
StatusBar_GetTextBlockInfo(StatusTextBlock *block, HDC hdc)
{
const wchar_t *text;
text = StatusBar_RetriveText(block);
if (((size_t)-1) == block->length)
{
if (FALSE == IS_STRING_EMPTY(text))
block->length = lstrlenW(text);
else
block->length = 0;
}
if (-1 == block->width)
{
block->width = 0;
if (0 != block->length)
{
RECT rect;
DRAWTEXTPARAMS textParams;
textParams.cbSize = sizeof(textParams);
textParams.iTabLength = 4;
textParams.iLeftMargin = 0;
textParams.iRightMargin = 0;
SetRect(&rect, 0, 0, 0x7FFFFFFF, 0);
if (FALSE != DrawTextEx(hdc, (wchar_t*)text, -1, &rect,
DT_LEFT | DT_TOP | DT_TABSTOP | DT_SINGLELINE |
DT_NOPREFIX | DT_EXPANDTABS | DT_NOCLIP | DT_CALCRECT | DT_EDITCONTROL,
&textParams))
{
block->width = RECTWIDTH(rect);
}
}
TEXTMETRIC metrics;
if (FALSE != GetTextMetrics(hdc, &metrics))
{
block->width += metrics.tmAveCharWidth/2;
}
}
return text;
}
static unsigned int
StatusBar_GetNextFreeId(StatusBar *self)
{
unsigned int id;
size_t index, count;
StatusRecord *record;
BOOL checkId;
count = self->list.size();
id = (unsigned int)count;
do
{
if (0xFFFFFFFF == id)
return STATUS_ERROR;
checkId = FALSE;
index = count;
while(index--)
{
record = self->list[index];
if (record->id == id)
{
id++;
checkId = TRUE;
break;
}
}
} while(FALSE != checkId);
return id;
}
static StatusRecord *
StatusBar_AddRecord(StatusBar *self, const wchar_t *text)
{
StatusRecord *record;
unsigned int id;
id = StatusBar_GetNextFreeId(self);
if (STATUS_ERROR == id)
return NULL;
record = (StatusRecord*)malloc(sizeof(StatusRecord));
if(NULL == record)
return NULL;
record->id = 0;
StatusBar_InitTextBlock(&record->mainBlock);
StatusBar_InitTextBlock(&record->rightBlock);
record->mainBlock.text = ResourceString_Duplicate(text);
self->list.push_back(record);
return record;
}
static StatusRecord *
StatusBar_FindRecord(StatusBar *self, unsigned int id, size_t *indexOut)
{
StatusRecord *record;
size_t index;
index = self->list.size();
while(index--)
{
record = self->list[index];
if (record->id == id)
{
if (NULL != indexOut)
*indexOut = index;
return record;
}
}
return NULL;
}
static StatusRecord *
StatusBar_FindVisibleRecord(StatusBar *self, size_t *indexOut)
{
StatusRecord *record;
size_t index;
const wchar_t *text;
index = self->list.size();
while(index--)
{
record = self->list[index];
text = StatusBar_RetriveText(&record->mainBlock);
if (FALSE != IS_STRING_EMPTY(text))
text = StatusBar_RetriveText(&record->rightBlock);
if (FALSE == IS_STRING_EMPTY(text))
{
if (NULL != indexOut)
*indexOut = index;
return record;
}
}
return NULL;
}
static void
StatusBar_Paint(HWND hwnd, HDC hdc, const RECT *paintRect, BOOL erase)
{
StatusBar *self;
StatusRecord *record;
const wchar_t *text;
STATUSBAR_RET_VOID(self, hwnd);
if (FALSE != erase)
{
FillRect(hdc, paintRect, self->backBrush);
}
record = StatusBar_FindVisibleRecord(self, NULL);
if (NULL != record)
{
COLORREF prevBackColor, prevTextColor;
HFONT prevFont;
RECT clientRect, textRect;
DRAWTEXTPARAMS textParams;
long limit;
prevBackColor = SetBkColor(hdc, self->backColor);
prevTextColor = SetTextColor(hdc, self->textColor);
prevFont = SelectFont(hdc, self->font);
textParams.cbSize = sizeof(textParams);
textParams.iTabLength = 4;
textParams.iLeftMargin = 0;
textParams.iRightMargin = 0;
GetClientRect(hwnd, &clientRect);
if (-1 == self->spacing)
self->spacing = Graphics_GetAveStrWidth(hdc, 2);
if (-1 == self->leftBlockMinWidth)
self->leftBlockMinWidth = Graphics_GetAveStrWidth(hdc, 16);
text = StatusBar_GetTextBlockInfo(&record->rightBlock, hdc);
if (FALSE == IS_STRING_EMPTY(text))
{
CopyRect(&textRect, &clientRect);
textRect.left = textRect.right - record->rightBlock.width;
limit = clientRect.left + self->spacing + self->leftBlockMinWidth;
if (textRect.left < limit)
textRect.left = limit;
if (textRect.left < textRect.right)
{
DrawTextEx(hdc, (wchar_t*)text, -1, &textRect,
DT_LEFT | DT_BOTTOM | DT_TABSTOP | DT_SINGLELINE |
DT_NOPREFIX | DT_EXPANDTABS, &textParams);
}
}
text = StatusBar_GetTextBlockInfo(&record->mainBlock, hdc);
if (FALSE == IS_STRING_EMPTY(text))
{
CopyRect(&textRect, &clientRect);
textRect.right = textRect.left + record->mainBlock.width;
limit = clientRect.right - record->rightBlock.width - 8;
if (limit < self->leftBlockMinWidth)
limit = self->leftBlockMinWidth;
if (textRect.right > limit)
textRect.right = limit;
if (textRect.left < textRect.right)
{
DrawTextEx(hdc, (wchar_t*)text, -1, &textRect,
DT_LEFT | DT_BOTTOM | DT_TABSTOP | DT_SINGLELINE |
DT_NOPREFIX | DT_EXPANDTABS | DT_END_ELLIPSIS, &textParams);
}
}
SetBkColor(hdc, prevBackColor);
SetTextColor(hdc, prevTextColor);
SelectFont(hdc, prevFont);
}
return;
}
static void
StatusBar_PaintBuffered(HWND hwnd, HDC hdc, const RECT *paintRect, BOOL erase)
{
StatusBar *self;
HDC bufferDC, targetDC;
RECT clientRect;
STATUSBAR_RET_VOID(self, hwnd);
GetClientRect(hwnd, &clientRect);
if (FALSE != BackBuffer_EnsureSizeEx(&self->backBuffer,
RECTWIDTH(*paintRect), RECTHEIGHT(*paintRect),
RECTWIDTH(clientRect), RECTHEIGHT(clientRect)))
{
bufferDC = BackBuffer_GetDC(&self->backBuffer);
if (NULL != bufferDC)
{
SetViewportOrgEx(bufferDC, -paintRect->left, -paintRect->top, NULL);
targetDC = hdc;
hdc = bufferDC;
}
}
else
{
bufferDC = NULL;
targetDC = NULL;
}
StatusBar_Paint(hwnd, hdc, paintRect, erase);
if (NULL != bufferDC)
{
hdc = targetDC;
SetViewportOrgEx(bufferDC, 0, 0, NULL);
BackBuffer_Copy(&self->backBuffer, hdc,
paintRect->left, paintRect->top, RECTWIDTH(*paintRect), RECTHEIGHT(*paintRect));
}
return;
}
static BOOL
StatusBar_InvalidateByIndex(StatusBar *self, HWND hwnd, size_t recordIndex)
{
unsigned int windowStyle;
size_t visibleIndex;
windowStyle = GetWindowStyle(hwnd);
if (0 == (WS_VISIBLE & windowStyle))
return FALSE;
if(NULL != StatusBar_FindVisibleRecord(self, &visibleIndex))
{
if (recordIndex == visibleIndex)
return InvalidateRect(hwnd, NULL, FALSE);
}
return FALSE;
}
static BOOL
StatusBar_InvalidateByRecord(StatusBar *self, HWND hwnd, StatusRecord *record)
{
unsigned int windowStyle;
StatusRecord *visibleRecord;
windowStyle = GetWindowStyle(hwnd);
if (0 == (WS_VISIBLE & windowStyle))
return FALSE;
visibleRecord = StatusBar_FindVisibleRecord(self, NULL);
if (record == visibleRecord &&
NULL != visibleRecord)
{
return InvalidateRect(hwnd, NULL, FALSE);
}
return FALSE;
}
static LRESULT
StatusBar_OnCreate(HWND hwnd, CREATESTRUCT *createStruct)
{
StatusBar *self;
self = new StatusBar();
if (NULL == self)
return -1;
SetLastError(ERROR_SUCCESS);
if (!SetWindowLongPtr(hwnd, 0, (LONGX86)self) && ERROR_SUCCESS != GetLastError())
{
delete self;
return -1;
}
if (NULL != createStruct->lpszName)
StatusBar_AddRecord(self, createStruct->lpszName);
self->backBrush = GetSysColorBrush(COLOR_WINDOW);
self->backColor = GetSysColor(COLOR_WINDOW);
self->textColor = GetSysColor(COLOR_WINDOWTEXT);
self->idealHeight = -1;
self->spacing = -1;
self->leftBlockMinWidth = -1;
BackBuffer_Initialize(&self->backBuffer, hwnd);
return 0;
}
static void
StatusBar_OnDestroy(HWND hwnd)
{
StatusBar *self;
size_t index;
StatusRecord *record;
self = STATUSBAR(hwnd);
SetWindowLongPtr(hwnd, 0, 0);
if (NULL == self)
return;
index = self->list.size();
while(index--)
{
record = self->list[index];
StatusBar_FreeTextBlock(&record->mainBlock);
StatusBar_FreeTextBlock(&record->rightBlock);
}
BackBuffer_Uninitialize(&self->backBuffer);
delete self;
}
static void
StatusBar_OnPaint(HWND hwnd)
{
PAINTSTRUCT ps;
if (NULL != BeginPaint(hwnd, &ps))
{
StatusBar_PaintBuffered(hwnd, ps.hdc, &ps.rcPaint, ps.fErase);
EndPaint(hwnd, &ps);
}
}
static void
StatusBar_OnPrintClient(HWND hwnd, HDC hdc, UINT options)
{
RECT clientRect;
if (GetClientRect(hwnd, &clientRect))
{
StatusBar_Paint(hwnd, hdc, &clientRect, TRUE);
}
}
static void
StatusBar_OnWindowPosChanged(HWND hwnd, WINDOWPOS *windowPos)
{
if (SWP_NOSIZE != ((SWP_NOSIZE | SWP_FRAMECHANGED) & windowPos->flags) &&
0 == (SWP_NOREDRAW & windowPos->flags))
{
InvalidateRect(hwnd, NULL, FALSE);
}
}
static LRESULT
StatusBar_OnSetText(HWND hwnd, LPCWSTR text)
{
StatusBar *self;
StatusRecord *record;
size_t count;
STATUSBAR_RET_VAL(self, hwnd, FALSE);
count = self->list.size();
if (0 == count)
{
if (NULL == text)
return TRUE;
record = StatusBar_AddRecord(self, text);
if (NULL == record)
return FALSE;
}
else
{
record = self->list[count - 1];
StatusBar_FreeTextBlock(&record->mainBlock);
StatusBar_FreeTextBlock(&record->rightBlock);
record->mainBlock.text = ResourceString_Duplicate(text);
}
StatusBar_InvalidateByRecord(self, hwnd, record);
return TRUE;
}
static LRESULT
StatusBar_OnGetText(HWND hwnd, LPWSTR buffer, size_t bufferMax)
{
StatusBar *self;
StatusRecord *record;
const wchar_t *lText, *rText;
size_t count, remaining;
wchar_t *cursor;
HRESULT hr;
STATUSBAR_RET_VAL(self, hwnd, 0);
if (NULL == buffer)
return 0;
count = self->list.size();
if (0 == count)
{
lText = NULL;
rText = NULL;
}
else
{
record = self->list[count - 1];
lText = StatusBar_RetriveText(&record->mainBlock);
rText = StatusBar_RetriveText(&record->rightBlock);
}
cursor = buffer;
remaining = bufferMax;
if (NULL != lText)
hr = StringCchCopyEx(cursor, bufferMax, lText, &cursor, &remaining, 0);
else
hr = S_OK;
if (NULL != rText && SUCCEEDED(hr))
{
hr = StringCchCopyEx(cursor, bufferMax, L"\f", &cursor, &remaining, 0);
if (SUCCEEDED(hr))
hr = StringCchCopyEx(cursor, bufferMax, rText, &cursor, &remaining, 0);
}
return (bufferMax - remaining);
}
static LRESULT
StatusBar_OnGetTextLength(HWND hwnd)
{
StatusBar *self;
StatusRecord *record;
size_t length, r;
STATUSBAR_RET_VAL(self, hwnd, 0);
length = self->list.size();
if (0 == length)
return 0;
record = self->list[length - 1];
length = StatusBar_GetTextBlockLength(&record->mainBlock);
r = StatusBar_GetTextBlockLength(&record->rightBlock);
if (0 != r)
{
length += (r + 1);
}
return length;
}
static void
StatusBar_OnSetFont(HWND hwnd, HFONT font, BOOL redraw)
{
StatusBar *self;
StatusRecord *record;
size_t index;
STATUSBAR_RET_VOID(self, hwnd);
self->font = font;
self->idealHeight = -1;
self->spacing = -1;
self->leftBlockMinWidth = -1;
index = self->list.size();
while(index--)
{
record = self->list[index];
record->mainBlock.width = -1;
record->rightBlock.width = -1;
}
if (NULL != redraw)
InvalidateRect(hwnd, NULL, TRUE);
}
static LRESULT
StatusBar_OnGetFont(HWND hwnd)
{
StatusBar *self;
STATUSBAR_RET_VAL(self, hwnd, NULL);
return (LRESULT)self->font;
}
static LRESULT
StatusBar_OnSetBackBrush(HWND hwnd, HBRUSH brush, BOOL redraw)
{
StatusBar *self;
HBRUSH prevBrush;
STATUSBAR_RET_VAL(self, hwnd, (LRESULT)GetSysColorBrush(COLOR_WINDOW));
prevBrush = self->backBrush;
self->backBrush = brush;
if (NULL != redraw)
InvalidateRect(hwnd, NULL, TRUE);
return (LRESULT)prevBrush;
}
static LRESULT
StatusBar_OnGetBackBrush(HWND hwnd)
{
StatusBar *self;
STATUSBAR_RET_VAL(self, hwnd, (LRESULT)GetSysColorBrush(COLOR_WINDOW));
return (LRESULT)self->backBrush;
}
static LRESULT
StatusBar_OnSetBackColor(HWND hwnd, COLORREF color, BOOL redraw)
{
StatusBar *self;
COLORREF prevColor;
STATUSBAR_RET_VAL(self, hwnd, GetSysColor(COLOR_WINDOW));
prevColor = self->backColor;
self->backColor = color;
if (NULL != redraw)
InvalidateRect(hwnd, NULL, FALSE);
return (LRESULT)prevColor;
}
static LRESULT
StatusBar_OnGetBackColor(HWND hwnd)
{
StatusBar *self;
STATUSBAR_RET_VAL(self, hwnd, GetSysColor(COLOR_WINDOW));
return (LRESULT)self->backColor;
}
static LRESULT
StatusBar_OnSetTextColor(HWND hwnd, COLORREF color, BOOL redraw)
{
StatusBar *self;
COLORREF prevColor;
STATUSBAR_RET_VAL(self, hwnd, GetSysColor(COLOR_WINDOWTEXT));
prevColor = self->textColor;
self->textColor = color;
if (NULL != redraw)
InvalidateRect(hwnd, NULL, FALSE);
return (LRESULT)prevColor;
}
static LRESULT
StatusBar_OnGetTextColor(HWND hwnd)
{
StatusBar *self;
STATUSBAR_RET_VAL(self, hwnd, GetSysColor(COLOR_WINDOWTEXT));
return (LRESULT)self->textColor;
}
static LRESULT
StatusBar_OnGetIdealHeight(HWND hwnd)
{
StatusBar *self;
STATUSBAR_RET_VAL(self, hwnd, 0);
if (self->idealHeight < 0)
{
HDC hdc;
self->idealHeight = 0;
hdc = GetDCEx(hwnd, NULL, DCX_CACHE | DCX_NORESETATTRS);
if (NULL != hdc)
{
TEXTMETRIC metrics;
HFONT font, prevFont;
font = (HFONT)SendMessage(hwnd, WM_GETFONT, 0, 0L);
prevFont = SelectFont(hdc, font);
if (FALSE != GetTextMetrics(hdc, &metrics))
self->idealHeight = metrics.tmHeight;
SelectFont(hdc, prevFont);
ReleaseDC(hwnd, hdc);
}
}
return (LRESULT)self->idealHeight;
}
static LRESULT
StatusBar_OnAddStatus(HWND hwnd, const wchar_t *text)
{
StatusBar *self;
StatusRecord *record;
STATUSBAR_RET_VAL(self, hwnd, STATUS_ERROR);
record = StatusBar_AddRecord(self, text);
if (NULL == record)
return STATUS_ERROR;
StatusBar_InvalidateByRecord(self, hwnd, record);
return record->id;
}
static LRESULT
StatusBar_OnRemoveStatus(HWND hwnd, unsigned int statusId)
{
StatusBar *self;
StatusRecord *record;
size_t index;
STATUSBAR_RET_VAL(self, hwnd, FALSE);
record = StatusBar_FindRecord(self, statusId, &index);
if (NULL == record)
return FALSE;
StatusBar_InvalidateByRecord(self, hwnd, record);
self->list.erase(self->list.begin() + index);
StatusBar_FreeTextBlock(&record->mainBlock);
StatusBar_FreeTextBlock(&record->rightBlock);
free(record);
return (LRESULT)TRUE;
}
static LRESULT
StatusBar_OnSetStatusText(HWND hwnd, unsigned int statusId, const wchar_t *text)
{
StatusBar *self;
StatusRecord *record;
size_t index;
STATUSBAR_RET_VAL(self, hwnd, FALSE);
record = StatusBar_FindRecord(self, statusId, &index);
if (NULL == record)
return FALSE;
StatusBar_InvalidateByRecord(self, hwnd, record);
StatusBar_FreeTextBlock(&record->mainBlock);
record->mainBlock.text = ResourceString_Duplicate(text);
StatusBar_InvalidateByRecord(self, hwnd, record);
return (LRESULT)TRUE;
}
static LRESULT
StatusBar_OnSetStatusRightText(HWND hwnd, unsigned int statusId, const wchar_t *text)
{
StatusBar *self;
StatusRecord *record;
size_t index;
STATUSBAR_RET_VAL(self, hwnd, FALSE);
record = StatusBar_FindRecord(self, statusId, &index);
if (NULL == record)
return FALSE;
StatusBar_InvalidateByRecord(self, hwnd, record);
StatusBar_FreeTextBlock(&record->rightBlock);
record->rightBlock.text = ResourceString_Duplicate(text);
StatusBar_InvalidateByRecord(self, hwnd, record);
return (LRESULT)TRUE;
}
static LRESULT
StatusBar_OnMoveStatus(HWND hwnd, unsigned int statusId, unsigned int moveCommand)
{
StatusBar *self;
StatusRecord *record;
size_t index, count, newIndex;
STATUSBAR_RET_VAL(self, hwnd, FALSE);
record = StatusBar_FindRecord(self, statusId, &index);
if (NULL == record)
return FALSE;
count = self->list.size();
switch(moveCommand)
{
case STATUS_MOVE_BOTTOM:
if (0 == index)
return TRUE;
self->list.erase(self->list.begin() + index);
self->list.insert(self->list.begin(), record);
newIndex = 0;
break;
case STATUS_MOVE_TOP:
if (index == (count - 1))
return TRUE;
self->list.erase(self->list.begin() + index);
self->list.push_back(record);
newIndex = count - 1;
break;
case STATUS_MOVE_UP:
if (index == (count - 1))
return TRUE;
self->list.erase(self->list.begin() + index);
newIndex = index + 1;
self->list.insert(self->list.begin() + newIndex, record);
break;
case STATUS_MOVE_DOWN:
if (index == 0)
return TRUE;
self->list.erase(self->list.begin() + index);
newIndex = index - 1;
self->list.insert(self->list.begin() + newIndex, record);
break;
}
if (index != newIndex)
{
StatusBar_InvalidateByIndex(self, hwnd, index);
StatusBar_InvalidateByIndex(self, hwnd, newIndex);
}
return (LRESULT)TRUE;
}
static LRESULT CALLBACK
StatusBar_WindowProc(HWND hwnd, unsigned int uMsg, WPARAM wParam, LPARAM lParam)
{
switch(uMsg)
{
case WM_CREATE: return StatusBar_OnCreate(hwnd, (CREATESTRUCT*)lParam);
case WM_DESTROY: StatusBar_OnDestroy(hwnd); return 0;
case WM_PAINT: StatusBar_OnPaint(hwnd); return 0;
case WM_PRINTCLIENT: StatusBar_OnPrintClient(hwnd, (HDC)wParam, (UINT)lParam); return 0;
case WM_PRINT: return 0;
case WM_ERASEBKGND: return 0;
case WM_WINDOWPOSCHANGED: StatusBar_OnWindowPosChanged(hwnd, (WINDOWPOS*)lParam); return 0;
case WM_SIZE: return 0;
case WM_MOVE: return 0;
case WM_SETTEXT: return StatusBar_OnSetText(hwnd, (LPCWSTR)lParam);
case WM_GETTEXT: return StatusBar_OnGetText(hwnd, (LPWSTR)lParam, (INT)wParam);
case WM_GETTEXTLENGTH: return StatusBar_OnGetTextLength(hwnd);
case WM_SETFONT: StatusBar_OnSetFont(hwnd, (HFONT)wParam, (BOOL)LOWORD(lParam)); return 0;
case WM_GETFONT: return StatusBar_OnGetFont(hwnd);
case STATUSBAR_WM_SET_BACK_BRUSH: return StatusBar_OnSetBackBrush(hwnd, (HBRUSH)lParam, (BOOL)wParam);
case STATUSBAR_WM_GET_BACK_BRUSH: return StatusBar_OnGetBackBrush(hwnd);
case STATUSBAR_WM_SET_BACK_COLOR: return StatusBar_OnSetBackColor(hwnd, (COLORREF)lParam, (BOOL)wParam);
case STATUSBAR_WM_GET_BACK_COLOR: return StatusBar_OnGetBackColor(hwnd);
case STATUSBAR_WM_SET_TEXT_COLOR: return StatusBar_OnSetTextColor(hwnd, (COLORREF)lParam, (BOOL)wParam);
case STATUSBAR_WM_GET_TEXT_COLOR: return StatusBar_OnGetTextColor(hwnd);
case STATUSBAR_WM_GET_IDEAL_HEIGHT: return StatusBar_OnGetIdealHeight(hwnd);
case STATUSBAR_WM_ADD_STATUS: return StatusBar_OnAddStatus(hwnd, (const wchar_t*)lParam);
case STATUSBAR_WM_REMOVE_STATUS: return StatusBar_OnRemoveStatus(hwnd, (unsigned int)(wParam));
case STATUSBAR_WM_SET_STATUS_TEXT: return StatusBar_OnSetStatusText(hwnd, (unsigned int)(wParam), (const wchar_t*)lParam);
case STATUSBAR_WM_SET_STATUS_RTEXT: return StatusBar_OnSetStatusRightText(hwnd, (unsigned int)(wParam), (const wchar_t*)lParam);
case STATUSBAR_WM_MOVE_STATUS: return StatusBar_OnMoveStatus(hwnd, (unsigned int)(wParam), (unsigned int)lParam);
}
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}