/* a simple button control */
static int MybuttonWindowProc (HWND hWnd, int message, WPARAM wParam, LPARAM lParam)
{
HDC hdc;
static int status = 0;
switch (message) {
case MSG_LBUTTONDOWN:
status = 1;
SetCapture (hWnd);
InvalidateRect (hWnd, NULL, TRUE);
break;
case MSG_LBUTTONUP:
if (GetCapture() != hWnd)
break;
status = 0;
ReleaseCapture ();
InvalidateRect (hWnd, NULL, TRUE);
break;
case MSG_PAINT:
hdc = BeginPaint (hWnd);
if (status) {
SetBkMode(hdc, BM_TRANSPARENT);
TextOut(hdc,10, 0, CP_ST_PRESSED);
}
EndPaint(hWnd, hdc);
return 0;
case MSG_DESTROY:
return 0;
}
return DefaultControlProc (hWnd, message, wParam, lParam);
}
static int CoolBarCtrlProc (HWND hWnd, int message, WPARAM wParam, LPARAM lParam)
{
HDC hdc;
PCOOLBARCTRL TbarData;
PCOOLBARITEMDATA pTbid;
switch (message) {
case MSG_CREATE:
{
DWORD data;
DWORD dwStyle;
const char* caption;
if ((TbarData = (COOLBARCTRL*) calloc (1, sizeof (COOLBARCTRL))) == NULL)
return 1;
TbarData->nCount = 0;
TbarData->head = TbarData->tail = NULL;
TbarData->BackBmp = NULL;
TbarData->iSel = -1;
TbarData->iMvOver = -1;
TbarData->ShowHint = TRUE;
TbarData->hToolTip = 0;
ExcludeWindowStyle (hWnd, WS_BORDER);
dwStyle = GetWindowStyle (hWnd);
if (dwStyle & CBS_BMP_32X32) {
TbarData->ItemWidth = 32;
TbarData->ItemHeight = 32;
}
else if (dwStyle & CBS_BMP_CUSTOM) {
data = GetWindowAdditionalData (hWnd);
TbarData->ItemWidth = LOWORD (data);
TbarData->ItemHeight = HIWORD (data);
}
else {
TbarData->ItemWidth = 16;
TbarData->ItemHeight = 16;
}
caption = GetWindowCaption (hWnd);
if ((dwStyle & CBS_USEBKBMP) && caption [0]) {
TbarData->BackBmp = (BITMAP*)calloc (1, sizeof (BITMAP));
if (LoadBitmap (HDC_SCREEN, TbarData->BackBmp, caption) < 0) {
free (TbarData->BackBmp);
TbarData->BackBmp = NULL;
break;
}
}
SetWindowAdditionalData2 (hWnd, (DWORD)TbarData);
}
break;
case MSG_DESTROY:
{
COOLBARITEMDATA* unloaddata, *tmp;
TbarData = (PCOOLBARCTRL) GetWindowAdditionalData2(hWnd);
if (TbarData->hToolTip != 0) {
DestroyToolTipWin (TbarData->hToolTip);
TbarData->hToolTip = 0;
}
if (TbarData->BackBmp) {
UnloadBitmap (TbarData->BackBmp);
free (TbarData->BackBmp);
}
unloaddata = TbarData->head;
while (unloaddata) {
tmp = unloaddata->next;
free (unloaddata);
unloaddata = tmp;
}
free (TbarData);
}
break;
case MSG_SIZECHANGING:
{
const RECT* rcExpect = (const RECT*)wParam;
RECT* rcResult = (RECT*)lParam;
TbarData = (PCOOLBARCTRL) GetWindowAdditionalData2(hWnd);
rcResult->left = rcExpect->left;
rcResult->top = rcExpect->top;
rcResult->right = rcExpect->right;
rcResult->bottom = rcExpect->top + TbarData->ItemHeight + 8;
return 0;
}
case MSG_SIZECHANGED:
{
RECT* rcWin = (RECT*)wParam;
RECT* rcClient = (RECT*)lParam;
*rcClient = *rcWin;
return 1;
}
case MSG_NCPAINT:
return 0;
case MSG_PAINT:
{
TbarData = (PCOOLBARCTRL) GetWindowAdditionalData2(hWnd);
hdc = BeginPaint (hWnd);
DrawCoolBox (hWnd, hdc, TbarData);
EndPaint (hWnd, hdc);
return 0;
}
case CBM_ADDITEM:
{
COOLBARITEMINFO* TbarInfo = NULL;
COOLBARITEMDATA* ptemp;
RECT rc;
TbarData = (PCOOLBARCTRL) GetWindowAdditionalData2 (hWnd);
TbarInfo = (COOLBARITEMINFO*) lParam;
if (!(ptemp = (COOLBARITEMDATA*)calloc (1, sizeof (COOLBARITEMDATA)))) {
return -1;
}
GetClientRect (hWnd, &rc);
ptemp->id = TbarInfo->id;
ptemp->Disable = 0;
ptemp->ItemType = TbarInfo->ItemType;
if (TbarInfo->ItemHint) {
strncpy (ptemp->Hint, TbarInfo->ItemHint, LEN_HINT);
ptemp->Hint [LEN_HINT] = '\0';
}
else
ptemp->Hint [0] = '\0';
if (TbarInfo->Caption) {
strncpy (ptemp->Caption, TbarInfo->Caption, LEN_TITLE);
ptemp->Caption [LEN_TITLE] = '\0';
}
else
ptemp->Caption [0] = '\0';
ptemp->Bmp = TbarInfo->Bmp;
set_item_rect (hWnd, TbarData, ptemp);
ptemp->next = NULL;
if (TbarData->nCount == 0) {
TbarData->head = TbarData->tail = ptemp;
}
else if (TbarData->nCount > 0) {
TbarData->tail->next = ptemp;
TbarData->tail = ptemp;
}
ptemp->insPos = TbarData->nCount;
TbarData->nCount++;
InvalidateRect (hWnd, NULL, TRUE);
return 0;
}
case CBM_ENABLE:
TbarData = (PCOOLBARCTRL)GetWindowAdditionalData2 (hWnd);
if (enable_item (TbarData, wParam, lParam))
return -1;
InvalidateRect (hWnd, NULL, TRUE);
return 0;
case MSG_LBUTTONDOWN:
{
int posx, posy;
TbarData=(PCOOLBARCTRL) GetWindowAdditionalData2(hWnd);
posx = LOSWORD (lParam);
posy = HISWORD (lParam);
if (GetCapture () == hWnd)
break;
SetCapture (hWnd);
if ((pTbid = GetCurTag (posx, posy, TbarData)) == NULL)
break;
TbarData->iSel = pTbid->insPos;
break;
}
case MSG_LBUTTONUP:
{
int x, y;
TbarData = (PCOOLBARCTRL)GetWindowAdditionalData2(hWnd);
x = LOSWORD(lParam);
y = HISWORD(lParam);
if (GetCapture() != hWnd)
break;
ReleaseCapture ();
ScreenToClient (hWnd, &x, &y);
if ((pTbid = GetCurTag(x, y, TbarData)) == NULL) {
break;
}
if (TbarData->iSel == pTbid->insPos && !pTbid->Disable)
NotifyParent (hWnd, GetDlgCtrlID(hWnd), pTbid->id);
TbarData->iSel = -1;
break;
}
case MSG_MOUSEMOVE:
{
int x, y;
TbarData = (PCOOLBARCTRL) GetWindowAdditionalData2(hWnd);
x = LOSWORD(lParam);
y = HISWORD(lParam);
if (GetCapture() == hWnd)
ScreenToClient (hWnd, &x, &y);
if ((pTbid = GetCurTag (x, y, TbarData)) == NULL) {
unhilight (hWnd);
break;
}
if (TbarData->iMvOver == pTbid->insPos)
break;
unhilight (hWnd);
TbarData->iMvOver = pTbid->insPos;
hilight (hWnd, TbarData, pTbid);
break;
}
case MSG_MOUSEMOVEIN:
if (!wParam)
unhilight (hWnd);
break;
case MSG_NCLBUTTONDOWN:
case MSG_KILLFOCUS:
unhilight (hWnd);
break;
}
return DefaultControlProc (hWnd, message, wParam, lParam);
}
/* a simple edit window */
static int MyeditWindowProc(HWND hWnd, int message, WPARAM wParam, LPARAM lParam)
{
int w = 0;
SIZE Size;
static char *pBuffer = NULL;
static int pos = 0, len = 0;
HDC hdc;
switch (message) {
case MSG_CREATE:
SetWindowFont(hWnd, GetSystemFont(SYSLOGFONT_DEFAULT));
if (!CreateCaret (hWnd, NULL, 1, GetSysCharHeight())) {
return -1;
}
pBuffer = (char *) calloc(1, 11);
*pBuffer = 0;
break;
case MSG_SETFOCUS:
hdc = GetClientDC(hWnd);
w = GetTextExtent (hdc, pBuffer, pos, &Size);
SetCaretPos(hWnd, w, 0);
//SetCaretPos(hWnd, pos*GetSysCharWidth(), 0);
ShowCaret(hWnd);
ReleaseDC(hdc);
break;
case MSG_KILLFOCUS:
HideCaret(hWnd);
break;
case MSG_CHAR:
switch (wParam) {
case '\t':
case '\b':
case '\n':
SetCaretBlinkTime(hWnd, GetCaretBlinkTime(hWnd)-100);
break;
default:
{
char ch, buf[11];
char *tmp;
ch = wParam;
if (!isalpha(ch) && !isdigit(ch))
break;
if (len == 10)
break;
tmp = pBuffer+pos;
if (*tmp != 0) {
strcpy(buf, tmp);
strcpy(tmp+1, buf);
}
*tmp = ch;
pos++;
len++;
hdc = GetClientDC(hWnd);
InvalidateRect(hWnd, NULL, TRUE);
w = GetTextExtent (hdc, pBuffer, pos, &Size);
SetCaretPos(hWnd, w, 0);
//SetCaretPos(hWnd, pos*GetSysCharWidth(), 0);
ShowCaret(hWnd);
ReleaseDC(hdc);
}
break;
}
break;
case MSG_KEYDOWN:
switch (wParam) {
case SCANCODE_CURSORBLOCKLEFT:
pos = MAX(pos-1, 0);
break;
case SCANCODE_CURSORBLOCKRIGHT:
pos = MIN(pos+1, len);
break;
case SCANCODE_BACKSPACE:
{
char buf[11];
char *tmp;
if (len == 0 || pos == 0)
break;
tmp = pBuffer+pos;
strcpy(buf, tmp);
strcpy(tmp-1, buf);
pos--;
len--;
break;
}
}
if (wParam == SCANCODE_CURSORBLOCKLEFT || wParam == SCANCODE_CURSORBLOCKRIGHT ||
wParam == SCANCODE_BACKSPACE) {
hdc = GetClientDC(hWnd);
InvalidateRect(hWnd, NULL, TRUE);
w = GetTextExtent (hdc, pBuffer, pos, &Size);
//SetCaretPos(hWnd, pos*GetSysCharWidth(), 0);
SetCaretPos(hWnd, w, 0);
ReleaseDC(hdc);
}
break;
case MSG_PAINT:
hdc = BeginPaint(hWnd);
TextOut(hdc, 0, 0, pBuffer);
EndPaint(hWnd, hdc);
return 0;
case MSG_DESTROY:
DestroyCaret (hWnd);
if (pBuffer)
free(pBuffer);
return 0;
}
return DefaultControlProc(hWnd, message, wParam, lParam);
}
/* window procedure of the property sheet. */
static int
PropSheetCtrlProc (HWND hwnd, int message, WPARAM wParam, LPARAM lParam)
{
PCONTROL ctrl;
PPROPSHEETDATA propsheet;
ctrl = gui_Control (hwnd);
propsheet = (PROPSHEETDATA *) ctrl->dwAddData2;
switch (message) {
case MSG_CREATE: {
#ifdef __TARGET_MSTUDIO__
SetWindowBkColor(hwnd,
GetWindowElementPixel (hwnd, WE_MAINC_THREED_BODY));
#endif
if (!(propsheet = calloc (1, sizeof (PROPSHEETDATA)))) {
return -1;
}
ctrl->dwAddData2 = (DWORD)propsheet;
break;
}
/* make the client size same as window size */
case MSG_SIZECHANGED: {
const RECT* rcWin = (RECT *)wParam;
RECT* rcClient = (RECT *)lParam;
/* cale the width of content page */
*rcClient = *rcWin;
propsheet->head_rc.right = RECTWP (rcClient);
if ((ctrl->dwStyle & 0xf0L) == PSS_BOTTOM) {
propsheet->head_rc.top = RECTHP (rcClient) - get_metrics (MWM_ICONY)
- 2 - _ICON_OFFSET * 2;
propsheet->head_rc.bottom = RECTHP (rcClient);
} else {
propsheet->head_rc.bottom = get_metrics (MWM_ICONY) + 2
+ _ICON_OFFSET * 2;
}
if ((ctrl->dwStyle & 0x0fL)!= PSS_SCROLLABLE) {
recalc_tab_widths (hwnd, propsheet, ctrl->dwStyle);
} else {
HDC hdc;
propsheet->head_width = propsheet->head_rc.right;
if (propsheet->head) {
PPROPPAGE page;
hdc = GetClientDC(hwnd);
page = propsheet->head;
while(page) {
page->width = tab_required_width (hdc, propsheet, page);
page = page->next;
}
ReleaseDC (hdc);
update_propsheet (propsheet);
}
}
resize_children (propsheet, rcClient, ctrl->dwStyle);
InvalidateRect (hwnd, &propsheet->head_rc, TRUE);
return 1;
}
case MSG_DESTROY: {
PPROPPAGE page, temp;
page = propsheet->head;
while (page) {
temp = page->next;
destroy_page (page);
free (page);
page = temp;
}
free (propsheet);
break;
}
case MSG_GETDLGCODE: {
return DLGC_WANTTAB | DLGC_WANTARROWS;
}
case PSM_SHEETCMD: {
int index = 0;
PPROPPAGE page = propsheet->head;
while (page) {
if (SendMessage (page->hwnd, MSG_SHEETCMD, wParam, lParam))
/* when encounter an error, return page index plus 1. */
return index + 1;
index++;
page = page->next;
}
return 0; /* success */
}
case PSM_SETACTIVEINDEX: {
PPROPPAGE page;
if ((page = get_page (propsheet, wParam)) && page != propsheet->active) {
show_hide_page (propsheet->active, SW_HIDE);
propsheet->active = page;
update_propsheet (propsheet);
NotifyParent (hwnd, ctrl->id, PSN_ACTIVE_CHANGED);
show_hide_page (page, SW_SHOW);
InvalidateRect (hwnd, &propsheet->head_rc, TRUE);
return PS_OKAY;
}
return PS_ERR;
}
case PSM_GETACTIVEINDEX: {
int index = 0;
PPROPPAGE page = propsheet->head;
while (page) {
if (page == propsheet->active) {
return index;
}
index ++;
page = page->next;
}
return PS_ERR;
}
case PSM_GETACTIVEPAGE: {
return (propsheet->active) ?
propsheet->active->hwnd : HWND_INVALID;
}
case PSM_GETPAGE: {
int index = 0;
PPROPPAGE page = propsheet->head;
while (page) {
if (index == wParam) {
return page->hwnd;
}
index ++;
page = page->next;
}
return HWND_INVALID;
}
case PSM_GETPAGEINDEX: {
int index = 0;
PPROPPAGE page = propsheet->head;
while (page) {
if (page->hwnd == wParam) {
return index;
}
index ++;
page = page->next;
}
return PS_ERR;
}
case PSM_GETPAGECOUNT: {
return propsheet->page_count;
}
case PSM_GETTITLELENGTH: {
int len = PS_ERR;
PPROPPAGE page;
if ((page = get_page (propsheet, wParam))) {
len = strlen (page->title);
}
return len;
}
case PSM_GETTITLE: {
char* buffer = (char*)lParam;
PPROPPAGE page;
if ((page = get_page (propsheet, wParam))) {
strcpy (buffer, page->title);
return PS_OKAY;
}
return PS_ERR;
}
case PSM_SETTITLE: {
BOOL rc = PS_ERR;
char* buffer = (char*)lParam;
PPROPPAGE page;
HDC hdc;
if ((ctrl->dwStyle & 0x0fL) != PSS_SCROLLABLE) {
if ((page = get_page (propsheet, wParam))) {
rc = set_page_title (page, buffer);
recalc_tab_widths (hwnd, propsheet, ctrl->dwStyle);
InvalidateRect (hwnd, &propsheet->head_rc, TRUE);
}
} else {
if ((page = get_page (propsheet, wParam))) {
hdc = GetClientDC (hwnd);
rc = set_page_title_normal_style (hdc, propsheet, page, buffer);
ReleaseDC (hdc);
InvalidateRect (hwnd, &propsheet->head_rc, TRUE);
}
}
return rc;
}
case PSM_ADDPAGE: {
if ((ctrl->dwStyle & 0x0fL) != PSS_SCROLLABLE) {
int index;
PPROPPAGE page;
if ((propsheet->head_rc.right / (propsheet->page_count + 1)) <
_MIN_TAB_WIDTH) {
return PS_ERR;
}
if (!(page = calloc (1, sizeof (PROPPAGE)))) {
return PS_ERR;
}
if (!create_page (hwnd, ctrl->dwStyle, propsheet, page,
(DLGTEMPLATE *)wParam, (WNDPROC)lParam)) {
free (page);
return PS_ERR;
}
index = append_page (propsheet, page);
if (propsheet->active) {
show_hide_page (propsheet->active, SW_HIDE);
}
propsheet->active = page;
NotifyParent (hwnd, ctrl->id, PSN_ACTIVE_CHANGED);
show_hide_page (page, SW_SHOW);
recalc_tab_widths (hwnd, propsheet, ctrl->dwStyle);
InvalidateRect (hwnd, &propsheet->head_rc, TRUE);
return index;
} else {
return add_new_page_normal_style (hwnd, ctrl,
propsheet, (DLGTEMPLATE *)wParam,
(WNDPROC)lParam);
}
}
case PSM_REMOVEPAGE: {
if ((ctrl->dwStyle & 0x0fL) != PSS_SCROLLABLE) {
PPROPPAGE page;
if ((page = get_page (propsheet, wParam))) {
remove_page (propsheet, page);
destroy_page (page);
free (page);
recalc_tab_widths (hwnd, propsheet, ctrl->dwStyle);
} else {
return PS_ERR;
}
if (propsheet->active == page) {
propsheet->active = propsheet->head;
NotifyParent (hwnd, ctrl->id, PSN_ACTIVE_CHANGED);
if (propsheet->active) {
show_hide_page (propsheet->active, SW_SHOW);
}
}
InvalidateRect (hwnd, &propsheet->head_rc, TRUE);
return PS_OKAY;
} else {
return delete_page (hwnd, ctrl, propsheet, wParam);
}
}
case MSG_LBUTTONDOWN: {
click_tab_bar (hwnd, ctrl, propsheet, lParam);
/* dump_propsheetdata (propsheet); */
break;
}
case MSG_KEYDOWN: {
PPROPPAGE page, new_active = NULL;
if (!(lParam & KS_CTRL) || (propsheet->head == NULL)) {
break;
}
/* Key borad message for PSS_COMPACTTAB and PSS_SIMPLE */
switch (LOWORD (wParam)) {
case SCANCODE_CURSORBLOCKDOWN:
case SCANCODE_CURSORBLOCKRIGHT:
if ((ctrl->dwStyle & 0x0fL)!= PSS_SCROLLABLE) {
new_active = propsheet->active->next;
if (new_active == NULL)
new_active = propsheet->head;
break;
} else {
scroll_tab_right (hwnd, ctrl, propsheet);
InvalidateRect (hwnd, &propsheet->head_rc, TRUE);
return 0;
}
case SCANCODE_CURSORBLOCKUP:
case SCANCODE_CURSORBLOCKLEFT:
if ((ctrl->dwStyle & 0x0fL)!= PSS_SCROLLABLE) {
page = propsheet->head;
if (propsheet->head == propsheet->active) {
while (page && page->next) {
page = page->next;
}
} else {
while (page) {
if (page->next == propsheet->active)
break;
page = page->next;
}
}
new_active = page;
break;
} else {
scroll_tab_left (hwnd, ctrl, propsheet);
InvalidateRect (hwnd, &propsheet->head_rc, TRUE);
return 0;
}
} /* switch */
if (new_active == NULL) {
break;
}
show_hide_page (propsheet->active, SW_HIDE);
propsheet->active = new_active;
NotifyParent (hwnd, ctrl->id, PSN_ACTIVE_CHANGED);
show_hide_page (new_active, SW_SHOW);
InvalidateRect (hwnd, &propsheet->head_rc, TRUE);
return 0;
}
case MSG_NCPAINT:
case MSG_PAINT: {
HDC hdc = BeginPaint (hwnd);
PPROPPAGE page = ((ctrl->dwStyle & 0x0fL) == PSS_SCROLLABLE) ?
propsheet->first_display_page : propsheet->head;
draw_propsheet (hwnd, hdc, ctrl, propsheet, page);
EndPaint (hwnd, hdc);
return 0;
}
default:
break;
}
return DefaultControlProc (hwnd, message, wParam, lParam);
}
static int SpinCtrlProc (HWND hWnd, int message, WPARAM wParam, LPARAM lParam)
{
PSPINDATA pData = (PSPINDATA) GetWindowAdditionalData2 (hWnd);
switch (message) {
case MSG_CREATE:
pData = (PSPINDATA) calloc (1, sizeof (SPINDATA));
if (!pData) {
return -1;
}
pData->canup = 1;
pData->candown = 1;
pData->hTarget = GetParent ( hWnd );
SetWindowAdditionalData2 (hWnd, (DWORD)pData);
break;
case MSG_DESTROY:
free (pData);
break;
case MSG_SIZECHANGING:
{
const RECT* rcExpect = (const RECT*)wParam;
RECT* rcResult = (RECT*)lParam;
int w, h;
rcResult->left = rcExpect->left;
rcResult->top = rcExpect->top;
GetSpinBoxSize (GetWindowStyle (hWnd), &w, &h);
rcResult->right = rcExpect->left + w;
rcResult->bottom = rcExpect->top + h;
return 0;
}
case MSG_SIZECHANGED:
{
RECT* rcWin = (RECT*)wParam;
RECT* rcClient = (RECT*)lParam;
*rcClient = *rcWin;
return 1;
}
case SPM_SETINFO:
{
PSPININFO spinfo = (PSPININFO) lParam;
if ( !spinfo )
return -1;
if (!(GetWindowStyle (hWnd) & SPS_AUTOSCROLL)) {
memcpy ( &(pData->spinfo), spinfo, sizeof (SPININFO) );
} else {
if ( (spinfo->max >= spinfo->min &&
spinfo->max >= spinfo->cur &&
spinfo->cur >= spinfo->min )) {
memcpy ( &(pData->spinfo), spinfo, sizeof (SPININFO) );
} else {
return -1;
}
}
InvalidateRect ( hWnd, NULL, FALSE );
return 0;
}
case SPM_GETINFO:
{
PSPININFO spinfo = (PSPININFO) lParam;
if ( !spinfo )
return -1;
memcpy ( spinfo, &(pData->spinfo), sizeof (SPININFO) );
return 0;
}
case SPM_SETCUR:
{
if (!(GetWindowStyle (hWnd) & SPS_AUTOSCROLL)) {
pData->spinfo.cur = wParam;
}
else{
if ( wParam > pData->spinfo.max || wParam < pData->spinfo.min)
return -1;
pData->spinfo.cur = wParam;
}
InvalidateRect (hWnd, NULL, FALSE );
return 0;
}
case SPM_GETCUR:
return pData->spinfo.cur;
case SPM_ENABLEUP:
pData->canup = 1;
InvalidateRect ( hWnd, NULL, FALSE );
return 0;
case SPM_ENABLEDOWN:
pData->candown = 1;
InvalidateRect ( hWnd, NULL, FALSE );
return 0;
case SPM_DISABLEUP:
pData->canup = 0;
InvalidateRect ( hWnd, NULL, FALSE );
return 0;
case SPM_DISABLEDOWN:
pData->candown = 0;
InvalidateRect ( hWnd, NULL, FALSE );
return 0;
case SPM_SETTARGET:
pData->hTarget = (HWND) lParam;
return 0;
case SPM_GETTARGET:
return pData->hTarget;
case MSG_NCPAINT:
return 0;
case MSG_PAINT:
{
DWORD dwStyle = GetWindowStyle (hWnd);
HDC hdc = BeginPaint (hWnd);
if (dwStyle & SPS_HORIZONTAL)
DrawSpinBoxHorz (hdc, &pData->spinfo, pData, dwStyle);
else
DrawSpinBoxVert (hdc, &pData->spinfo, pData, dwStyle);
EndPaint (hWnd, hdc);
return 0;
}
case MSG_LBUTTONDOWN:
{
int posx = LOWORD (lParam);
int posy = HIWORD (lParam);
int id = GetDlgCtrlID (hWnd);
DWORD dwStyle = GetWindowStyle (hWnd);
if ((dwStyle & SPS_TYPE_MASK) == SPS_TYPE_UPARROW) {
OnUpArrow (hWnd, pData, id, dwStyle, wParam);
}
else if ((dwStyle & SPS_TYPE_MASK) == SPS_TYPE_DOWNARROW) {
OnDownArrow (hWnd, pData, id, dwStyle, wParam);
}
else if ( ((dwStyle & SPS_HORIZONTAL) && (posx <= SPINBOX_HORZ_WIDTH))
|| (!(dwStyle & SPS_HORIZONTAL) && (posy <= SPINBOX_VERT_HEIGHT)) ) {
OnUpArrow (hWnd, pData, id, dwStyle, wParam);
}
else if ( ((dwStyle & SPS_HORIZONTAL) && (posx >= SPINBOX_HORZ_WIDTH + 2))
|| (!(dwStyle & SPS_HORIZONTAL) && (posy >= SPINBOX_VERT_HEIGHT + 2)) ) {
OnDownArrow (hWnd, pData, id, dwStyle, wParam);
}
InvalidateRect ( hWnd, NULL, FALSE );
if (GetCapture () == hWnd)
break;
SetCapture (hWnd);
SetAutoRepeatMessage (hWnd, message, wParam, lParam);
break;
}
case MSG_LBUTTONUP:
SetAutoRepeatMessage (0, 0, 0, 0);
ReleaseCapture ();
break;
default:
break;
}
return DefaultControlProc (hWnd, message, wParam, lParam);
}
static int ProgressBarCtrlProc (HWND hwnd, int message, WPARAM wParam, LPARAM lParam)
{
HDC hdc;
PCONTROL pCtrl;
PROGRESSDATA* pData;
pCtrl = Control (hwnd);
switch (message)
{
case MSG_CREATE:
if (!(pData = malloc (sizeof (PROGRESSDATA)))) {
fprintf(stderr, "Create progress bar control failure!\n");
return -1;
}
pData->nMax = 100;
pData->nMin = 0;
pData->nPos = 0;
pData->nStepInc = 10;
pCtrl->dwAddData2 = (DWORD)pData;
break;
case MSG_DESTROY:
free ((void *)(pCtrl->dwAddData2));
break;
case MSG_NCPAINT:
return 0;
case MSG_GETDLGCODE:
return DLGC_STATIC;
case MSG_GETTEXTLENGTH:
case MSG_GETTEXT:
case MSG_SETTEXT:
return -1;
case MSG_PAINT:
{
RECT rcClient;
GetClientRect (hwnd, &rcClient);
hdc = BeginPaint (hwnd);
#ifdef _FLAT_WINDOW_STYLE
SetPenColor (hdc, GetWindowElementColorEx (hwnd, BKC_CONTROL_DEF));
Rectangle (hdc, rcClient.left, rcClient.top,
rcClient.right - 1, rcClient.bottom - 1);
SetPenColor (hdc, GetWindowElementColorEx (hwnd, FGC_CONTROL_NORMAL));
Rectangle (hdc, rcClient.left + 1, rcClient.top + 1,
rcClient.right - 2, rcClient.bottom - 2);
#else
Draw3DThickFrameEx (hdc, hwnd, rcClient.left, rcClient.top,
rcClient.right - 1, rcClient.bottom - 1,
DF_3DBOX_PRESSED | DF_3DBOX_NOTFILL, 0);
#endif
pbarOnDraw (hwnd, hdc, (PROGRESSDATA *)pCtrl->dwAddData2,
pCtrl->dwStyle & PBS_VERTICAL);
EndPaint (hwnd, hdc);
return 0;
}
case PBM_SETRANGE:
pData = (PROGRESSDATA *)pCtrl->dwAddData2;
if (wParam == lParam)
return PB_ERR;
pData->nMin = MIN (wParam, lParam);
pData->nMax = MAX (wParam, lParam);
if (pData->nPos > pData->nMax)
pData->nPos = pData->nMax;
if (pData->nPos < pData->nMin)
pData->nPos = pData->nMin;
if (pData->nStepInc > (pData->nMax - pData->nMin))
pData->nStepInc = pData->nMax - pData->nMin;
InvalidateRect (hwnd, NULL, TRUE);
return PB_OKAY;
case PBM_SETSTEP:
pData = (PROGRESSDATA *)pCtrl->dwAddData2;
if ((int)wParam > (int)(pData->nMax - pData->nMin))
return PB_ERR;
pData->nStepInc = wParam;
return PB_OKAY;
case PBM_SETPOS:
pData = (PROGRESSDATA *)pCtrl->dwAddData2;
if (pData->nPos == wParam)
return PB_OKAY;
pbarOnNewPos (pCtrl, pData, wParam);
return PB_OKAY;
case PBM_DELTAPOS:
pData = (PROGRESSDATA *)pCtrl->dwAddData2;
if (wParam == 0)
return PB_OKAY;
pbarOnNewPos (pCtrl, pData, pData->nPos + wParam);
return PB_OKAY;
case PBM_STEPIT:
pData = (PROGRESSDATA *)pCtrl->dwAddData2;
if (pData->nStepInc == 0)
return PB_OKAY;
pbarOnNewPos (pCtrl, pData, pData->nPos + pData->nStepInc);
return PB_OKAY;
case MSG_FONTCHANGED:
InvalidateRect (hwnd, NULL, TRUE);
break;
}
return DefaultControlProc (hwnd, message, wParam, lParam);
}
static int AnimationCtrlProc (HWND hwnd, int message, WPARAM wParam, LPARAM lParam)
{
ANIMATIONINFO* anim_info = (ANIMATIONINFO*)GetWindowAdditionalData2 (hwnd);
switch (message) {
case MSG_CREATE:
if (!HaveFreeTimer ()) {
fprintf (stderr,
"Animation error : no free timer is available!\n");
return -1;
}
anim_info = (ANIMATIONINFO*) calloc (1, sizeof (ANIMATIONINFO));
if (anim_info == NULL)
return -1;
SetWindowAdditionalData2 (hwnd, (DWORD)anim_info);
if(lParam)
SendMessage (hwnd, ANM_SETANIMATION, 0, lParam);
break;
case MSG_DESTROY:
if (anim_info->mem_dc)
DeleteCompatibleDC (anim_info->mem_dc);
free (anim_info);
/* timer will be freed automatically */
//KillTimer (hwnd, ID_TIMER);
break;
case MSG_TIMER:
if(anim_info->anim == NULL)
return 0;
if (anim_info->status == ANIM_STATUS_PLAY) {
int delay_time = -1;
if(anim_info->current) {
delay_time = anim_info->current->delay_time;
}
anim_info->elapsed_10ms++;
if (delay_time > 0 && anim_info->elapsed_10ms >= delay_time) {
next_frame (hwnd, anim_info);
anim_info->elapsed_10ms = 0;
}
}
return 0;
case MSG_PAINT: {
HDC hdc;
HDC src_dc;
RECT rc_anim;
if (!anim_info->mem_dc)
break;
hdc = BeginPaint (hwnd);
src_dc = anim_info->mem_dc;
if (GetWindowStyle (hwnd) & ANS_SCALED) {
GetClientRect (hwnd, &rc_anim);
} else {
SetRect (&rc_anim, 0, 0, anim_info->anim->width,
anim_info->anim->height);
}
if (RECTW (rc_anim) == anim_info->anim->width
&& RECTH (rc_anim) == anim_info->anim->height) {
BitBlt (anim_info->mem_dc, 0, 0, 0, 0, hdc, 0, 0, 0);
} else {
StretchBlt (anim_info->mem_dc, 0, 0,
anim_info->anim->width, anim_info->anim->height,
hdc,
0, 0,
RECTW (rc_anim), RECTH (rc_anim), 0);
}
EndPaint (hwnd, hdc);
return 0;
}
case ANM_SETANIMATION: {
ANIMATION* old = anim_info->anim;
anim_info->anim = (ANIMATION*)lParam;
anim_info->current = NULL;
if (anim_info->anim) {
KillTimer (hwnd, ID_TIMER);
if (GetWindowStyle (hwnd) & ANS_FITTOANI) {
RECT rc;
GetWindowRect(hwnd, &rc);
MoveWindow(hwnd, rc.left, rc.top,
anim_info->anim->width,
anim_info->anim->height, FALSE);
}
anim_info->current = NULL;
setup_anim_mem_dc(hwnd, anim_info);
next_frame(hwnd, anim_info);
anim_info->elapsed_10ms = 0;
//SetTimer (hwnd, ID_TIMER, anim_info->anim->time_unit);
SetTimer (hwnd, ID_TIMER, 10);
}
return (int)old;
}
case ANM_GETANIMATION:
return (int)anim_info->anim;
case ANM_STARTPLAY: {
if (anim_info->anim) {
anim_info->current = NULL;
anim_info->status = ANIM_STATUS_PLAY;
next_frame(hwnd, anim_info);
anim_info->elapsed_10ms = 0;
}
return 0;
}
case ANM_PAUSE_RESUME:
if(anim_info->anim)
{
if (anim_info->status == ANIM_STATUS_PLAY)
anim_info->status = ANIM_STATUS_STOP;
else
anim_info->status = ANIM_STATUS_PLAY;
}
return 0;
case ANM_STOPPLAY:
if(anim_info->anim)
{
anim_info->current = NULL;
anim_info->status = ANIM_STATUS_STOP;
next_frame (hwnd, anim_info); //back to the first frame
anim_info->elapsed_10ms = 0;
InvalidateRect (hwnd, NULL, FALSE);
}
return 0;
case MSG_LBUTTONDBLCLK:
NotifyParent (hwnd, GetDlgCtrlID (hwnd), ANNC_DBLCLK);
break;
case MSG_LBUTTONDOWN:
NotifyParent (hwnd, GetDlgCtrlID (hwnd), ANNC_CLICKED);
break;
default:
break;
}
return DefaultControlProc (hwnd, message, wParam, lParam);
}