mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
628 lines
23 KiB
628 lines
23 KiB
/*-----------------------------------------------------------------------------+
|
|
| FRAMEBOX.C |
|
|
| |
|
|
| Code to handle the frame edit boxes for MPlayer. |
|
|
| |
|
|
| This code handles the edit box that goes between time, track & |
|
|
| frame view. When a FrameBox is created we will create an |
|
|
| Edit box and spin arrows for it. By checking the |
|
|
| <gwCurScale> flag we will display text in either frame, track |
|
|
| or in time mode. The displayed time mode will be HH:MM:SS.ss |
|
|
| Track mode is TT HH:MM:SS or maybe TT MM:SS or something. |
|
|
| GETTEXT will return a frame number in frame mode or a millisec |
|
|
| value in time or track mode. |
|
|
| |
|
|
| (C) Copyright Microsoft Corporation 1991. All rights reserved. |
|
|
| |
|
|
| Revision History |
|
|
| Oct-1992 MikeTri Ported to WIN32 / WIN16 common code |
|
|
| |
|
|
+-----------------------------------------------------------------------------*/
|
|
|
|
#include <windows.h>
|
|
#include <mmsystem.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <ctype.h>
|
|
|
|
#include "mplayer.h"
|
|
#include "framebox.h"
|
|
|
|
extern int gInc; // amount spin arrows inc/dec by
|
|
|
|
#define SPINARROWWIDTH 6 /* In dialog base units */
|
|
|
|
#define IDC_EDITBOX 5000
|
|
#define IDC_SPINARROW 5001
|
|
|
|
// extra fields in window instance data
|
|
#define GWI_EDITBOX (0 * sizeof(INT)) // edit box window handle
|
|
#define GWI_SPINARROWS (1 * sizeof(INT)) // spinarrow window handle
|
|
#define GWL_MAXFRAME (2 * sizeof(INT)) // max frame value
|
|
#define GWI_ALLOCATE (2 * sizeof(INT) + sizeof(LONG)) // number of BYTEs to allocate
|
|
|
|
#define GETEDITBOXWND(hwnd) (HWND)GetWindowLongPtr (hwnd, GWI_EDITBOX)
|
|
#define GETSPINARRWND(hwnd) (HWND)GetWindowLongPtr (hwnd, GWI_SPINARROWS)
|
|
|
|
#define SETEDITBOXWND(hwnd, hwndEdit) \
|
|
SETWINDOWUINT(hwnd, GWI_EDITBOX, hwndEdit)
|
|
#define SETSPINARRWND(hwnd, hwndArr) \
|
|
SETWINDOWUINT(hwnd, GWI_SPINARROWS, hwndArr)
|
|
|
|
#define HILIGHTEDITBOX(hwnd) \
|
|
SendMessage(GETEDITBOXWND(hwnd), EM_SETSEL, (WPARAM)0, (LPARAM)(UINT)-1);
|
|
|
|
#define GETMAXFRAME(hwnd) (DWORD)GetWindowLongPtr(hwnd, GWL_MAXFRAME)
|
|
#define SETMAXFRAME(hwnd, l) SetWindowLongPtr(hwnd, GWL_MAXFRAME, (LONG_PTR)l)
|
|
|
|
// internal functions
|
|
LONG_PTR FAR PASCAL _EXPORT frameboxWndProc(HWND hwnd, unsigned wMsg, WPARAM wParam, LPARAM lParam);
|
|
|
|
LONG_PTR NEAR PASCAL frameboxiSetText(HWND hwnd, LPTSTR lpsz);
|
|
LONG_PTR NEAR PASCAL frameboxiGetText(HWND hwnd, UINT_PTR wStrLen, LPTSTR lpsz);
|
|
LONG_PTR NEAR PASCAL frameboxiArrowEdit(HWND hwnd, WPARAM wParam, LONG_PTR lParam);
|
|
|
|
// strings
|
|
TCHAR szFrameBoxClass[] = TEXT("aviframebox");
|
|
|
|
|
|
/*--------------------------------------------------------------+
|
|
| ******************** EXTERNAL FUNCTIONS ********************* |
|
|
+--------------------------------------------------------------*/
|
|
/*--------------------------------------------------------------+
|
|
| frameboxInit() - initialize by registering our class. |
|
|
| NOTE: Even if we return FALSE, nobody should |
|
|
| care, because we don't register these classes|
|
|
| at AppInit time, but on demand, so only the |
|
|
| first call will succeed. Complain to Todd. |
|
|
| (DM). |
|
|
| |
|
|
+--------------------------------------------------------------*/
|
|
BOOL FAR PASCAL frameboxInit(HANDLE hInst, HANDLE hPrev)
|
|
{
|
|
WNDCLASS cls;
|
|
|
|
if (1) {
|
|
cls.hCursor = LoadCursor(NULL, IDC_ARROW);
|
|
cls.hIcon = NULL;
|
|
cls.lpszMenuName = NULL;
|
|
cls.lpszClassName = szFrameBoxClass;
|
|
cls.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
|
|
cls.hInstance = ghInst;
|
|
cls.style = CS_HREDRAW | CS_VREDRAW;
|
|
cls.lpfnWndProc = frameboxWndProc;
|
|
cls.cbClsExtra = 0;
|
|
cls.cbWndExtra = GWI_ALLOCATE; // room for stuff
|
|
|
|
if (!RegisterClass(&cls))
|
|
return FALSE;
|
|
|
|
if (!ArrowInit(hInst))
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
/*--------------------------------------------------------------+
|
|
| frameboxSetText() - set the text for the window passed in |
|
|
| <hwnd>. |
|
|
| |
|
|
+--------------------------------------------------------------*/
|
|
LONG_PTR FAR PASCAL frameboxSetText(HWND hwnd, LPTSTR lpsz)
|
|
{
|
|
LONG_PTR l;
|
|
TCHAR achTimeString[20];
|
|
BOOL fFrameFormat = (gwCurScale == ID_FRAMES);
|
|
UINT wCurScaleSave = gwCurScale;
|
|
|
|
if (fFrameFormat || *lpsz == TEXT('\0')){
|
|
/* we are in frame format - this is easy and all we need*/
|
|
/* to do is to return what is in the Edit box */
|
|
l = SendMessage(hwnd, WM_SETTEXT, (WPARAM)0, (LPARAM)lpsz);
|
|
} else {
|
|
/* we are in time/track format - need to convert to a time string */
|
|
/* based on the msec value we have been passed in. */
|
|
DWORD_PTR dwmSecs;
|
|
|
|
/* get into local buffer */
|
|
lstrcpy((LPTSTR)achTimeString, (LPTSTR)lpsz);
|
|
dwmSecs = (DWORD_PTR)ATOL(achTimeString);
|
|
|
|
/* It's meaningless to print track style numbers for the length of */
|
|
/* the selection, so use ordinary time mode. */
|
|
if (GetParent(hwnd) ==
|
|
GetDlgItem(GetParent(GetParent(hwnd)), IDC_EDITNUM))
|
|
gwCurScale = ID_TIME;
|
|
|
|
FormatTime(dwmSecs, (LPTSTR)achTimeString, NULL, FALSE);
|
|
gwCurScale = wCurScaleSave;
|
|
|
|
/* send it to the control */
|
|
l = SendMessage(hwnd,
|
|
WM_SETTEXT,
|
|
(WPARAM)0,
|
|
(LPARAM)(LPTSTR)achTimeString);
|
|
}
|
|
return l;
|
|
}
|
|
|
|
|
|
/*--------------------------------------------------------------+
|
|
| *********************** WINDOW PROC ************************* |
|
|
+--------------------------------------------------------------*/
|
|
/*--------------------------------------------------------------+
|
|
| frameboxWndProc - window process to handle the FrameBox |
|
|
| |
|
|
+--------------------------------------------------------------*/
|
|
LONG_PTR FAR PASCAL _EXPORT frameboxWndProc(HWND hwnd, unsigned wMsg,
|
|
WPARAM wParam, LPARAM lParam)
|
|
{
|
|
HWND hwndNew;
|
|
RECT rc;
|
|
UINT wArrowWidth;
|
|
|
|
switch(wMsg){
|
|
case WM_CREATE:
|
|
/* create the Edit box and the spin arrows for this */
|
|
/* FrameBox window. */
|
|
GetClientRect(hwnd, (LPRECT)&rc);
|
|
|
|
/* Calculate arrow width in pixels */
|
|
wArrowWidth = ((SPINARROWWIDTH * LOWORD(GetDialogBaseUnits()))
|
|
/ 4) - 1;
|
|
|
|
/* create the edit box */
|
|
|
|
hwndNew = CreateWindowEx(gfdwFlagsEx,
|
|
TEXT("edit"),
|
|
TEXT(""),
|
|
WS_CHILD|WS_TABSTOP|ES_LEFT|WS_BORDER,
|
|
0,
|
|
0,
|
|
rc.right - wArrowWidth,
|
|
rc.bottom,
|
|
hwnd,
|
|
(HMENU)IDC_EDITBOX,
|
|
GETHWNDINSTANCE(hwnd),
|
|
0L);
|
|
|
|
if (!hwndNew){
|
|
return 0L;
|
|
}
|
|
SETEDITBOXWND(hwnd, hwndNew);
|
|
|
|
/* limit this box to 15 chars of input */
|
|
SendMessage(hwndNew, EM_LIMITTEXT, (WPARAM)15, (LPARAM)0L);
|
|
ShowWindow(hwndNew, SW_SHOW);
|
|
|
|
|
|
/* create the spin arrows */
|
|
|
|
hwndNew = CreateWindowEx(gfdwFlagsEx,
|
|
TEXT("comarrow"),
|
|
TEXT(""),
|
|
WS_CHILD|WS_TABSTOP|WS_BORDER,
|
|
rc.right - wArrowWidth,
|
|
0,
|
|
wArrowWidth,
|
|
rc.bottom,
|
|
hwnd,
|
|
(HMENU)IDC_SPINARROW,
|
|
GETHWNDINSTANCE(hwnd),
|
|
0L);
|
|
|
|
if (!hwndNew){
|
|
return 0L;
|
|
}
|
|
SETSPINARRWND(hwnd, hwndNew);
|
|
ShowWindow(hwndNew, SW_SHOW);
|
|
|
|
/* set the max to be the end of the media by default */
|
|
SETMAXFRAME(hwnd, (DWORD)(gdwMediaStart + gdwMediaLength));
|
|
break;
|
|
|
|
|
|
case WM_DESTROY:
|
|
/* Delete the Edit box and the spin arrows */
|
|
DestroyWindow(GETEDITBOXWND(hwnd));
|
|
DestroyWindow(GETSPINARRWND(hwnd));
|
|
break;
|
|
|
|
case WM_SETFONT:
|
|
return SendMessage(GETEDITBOXWND(hwnd), wMsg, wParam, lParam);
|
|
|
|
case WM_SETFOCUS:
|
|
/* when we get the focus just send it on to the edit control */
|
|
SetFocus(GETEDITBOXWND(hwnd));
|
|
break;
|
|
|
|
case WM_SETTEXT:
|
|
/* set the text which is a frame number or time in */
|
|
/* msec to be a frame or time mode string */
|
|
return frameboxiSetText(hwnd, (LPTSTR)lParam);
|
|
|
|
case WM_GETTEXT:
|
|
/* get the text from the Edit box and translate to a */
|
|
/* frame number or time in msec. */
|
|
return frameboxiGetText(hwnd, wParam, (LPTSTR)lParam);
|
|
|
|
case WM_VSCROLL:
|
|
/* handle the scrolling via spin arrows */
|
|
return frameboxiArrowEdit(hwnd, wParam, lParam);
|
|
|
|
case WM_COMMAND:
|
|
switch (LOWORD(wParam) ){
|
|
case IDC_EDITBOX:
|
|
// route editbox messages back to our parent
|
|
|
|
SendMessage(GetParent(hwnd),
|
|
WM_COMMAND,
|
|
GETWINDOWID(hwnd),
|
|
lParam);
|
|
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case EM_SETSEL:
|
|
/* Perhaps we should only let this through if the caller
|
|
** is trying to select the entire contents of the edit box,
|
|
** because otherwise we'll have to map the range.
|
|
*/
|
|
SendMessage(GETEDITBOXWND(hwnd), wMsg, wParam, lParam);
|
|
break;
|
|
|
|
#pragma message("Should we be supporting other EM_* messages?")
|
|
|
|
/* handle special case messages for the FrameBox control */
|
|
case FBOX_SETMAXFRAME:
|
|
/* set the max frames to allow spin arrows to go */
|
|
SETMAXFRAME(hwnd, lParam);
|
|
break;
|
|
|
|
default:
|
|
return(DefWindowProc(hwnd, wMsg, wParam, lParam));
|
|
break;
|
|
|
|
}
|
|
return (0L);
|
|
}
|
|
|
|
/*--------------------------------------------------------------+
|
|
| ******************** INTERNAL FUNCTIONS ********************* |
|
|
+--------------------------------------------------------------*/
|
|
/*--------------------------------------------------------------+
|
|
| frameboxiSetText() - handle setting the text depending on if |
|
|
| we are in time or frame format. |
|
|
| |
|
|
+--------------------------------------------------------------*/
|
|
LONG_PTR NEAR PASCAL frameboxiSetText(HWND hwnd, LPTSTR lpsz)
|
|
{
|
|
LONG_PTR l;
|
|
|
|
/* We want to set the text even if it's identical because someone might */
|
|
/* have typed 03 06:00 and if track 3 if only 4 minutes long we want it */
|
|
/* to change to 04 02:00. Clever, eh? */
|
|
#if 0
|
|
TCHAR ach[12];
|
|
|
|
/* see if we are setting the same string as what is there */
|
|
/* and just don't do it if so to avoid flicker. */
|
|
l = frameboxiGetText(hwnd, CHAR_COUNT(ach), (LPTSTR)ach);
|
|
if (lstrcmp((LPTSTR)ach, lpsz) == 0)
|
|
goto HighLight;
|
|
#endif
|
|
|
|
/* call generic function to handle this */
|
|
l = frameboxSetText(GETEDITBOXWND(hwnd), lpsz);
|
|
|
|
#if 0
|
|
HighLight:
|
|
#endif
|
|
/* now let's highlight the whole thing */
|
|
HILIGHTEDITBOX(hwnd);
|
|
|
|
return l;
|
|
}
|
|
|
|
|
|
#define IsCharNumeric( ch ) ( IsCharAlphaNumeric( ch ) && !IsCharAlpha( ch ) )
|
|
|
|
/*--------------------------------------------------------------+
|
|
| frameboxiGetText() - handle getting the text depending on if |
|
|
| we are in time or frame format. Either |
|
|
| returns a frame number or msec number |
|
|
| depending on the mode. |
|
|
| |
|
|
+--------------------------------------------------------------*/
|
|
LONG_PTR NEAR PASCAL frameboxiGetText(HWND hwnd, UINT_PTR wStrLen, LPTSTR lpsz)
|
|
{
|
|
UINT wCurScaleSave = gwCurScale;
|
|
|
|
if (gwCurScale == ID_FRAMES) {
|
|
LPTSTR p;
|
|
LPTSTR pStart;
|
|
UINT w;
|
|
|
|
/* we are in frame format - this is easy and all we need*/
|
|
/* to do is to return what is in the Edit box */
|
|
if (GetWindowText(GETEDITBOXWND(hwnd), lpsz, (int)wStrLen) == 0)
|
|
goto LB_Error;
|
|
|
|
/* cut through leading white space */
|
|
for (pStart = lpsz; *pStart == TEXT(' ') || *pStart == TEXT('\t'); pStart++)
|
|
;
|
|
|
|
/* now rip out trailing white space */
|
|
if (*pStart) { // don't backtrack before beginning of string
|
|
for (p=pStart; *p; p++)
|
|
;
|
|
for (--p; *p == TEXT(' ') || *p == TEXT('\t'); --p)
|
|
;
|
|
*++p = TEXT('\0');
|
|
}
|
|
|
|
// make sure digits only were entered
|
|
for (p=pStart, w=0; *p; p++, w++)
|
|
if (!IsCharNumeric(*p))
|
|
goto LB_Error;
|
|
|
|
// copy over only the part you need and return #chars
|
|
lstrcpy(lpsz, pStart);
|
|
return w;
|
|
|
|
} else {
|
|
/* we are in time or track format - we need to convert the time */
|
|
/* to msec. */
|
|
PTSTR pStart; // pointer to achTime buffer
|
|
TCHAR achTime[20]; // buffer for time string (input)
|
|
DWORD dwmSecs; // total mSecs for this thing */
|
|
TCHAR *pDelim; // pointer to next delimeter
|
|
TCHAR *p; // general pointer
|
|
DWORD dwTrack = 0; // track number
|
|
DWORD dwHours = 0; // # of hours
|
|
DWORD dwMins = 0; // # of minutes
|
|
DWORD dwSecs = 0; // # of seconds
|
|
DWORD wmsec = 0; // # hundredths
|
|
DWORD w;
|
|
|
|
/* It's meaningless to use track style numbers for the length of */
|
|
/* the selection, so use ordinary time mode. */
|
|
if (hwnd == GetDlgItem(GetParent(hwnd), IDC_EDITNUM))
|
|
gwCurScale = ID_TIME;
|
|
|
|
/* get the string from the edit box */
|
|
SendMessage(GETEDITBOXWND(hwnd),
|
|
WM_GETTEXT,
|
|
(WPARAM)CHAR_COUNT(achTime),
|
|
(LPARAM)(LPTSTR) achTime);
|
|
|
|
if (achTime[0] == TEXT('\0'))
|
|
goto LB_Error; // bad char so error out
|
|
|
|
/* go past any white space up front */
|
|
for (pStart = achTime; *pStart == TEXT(' ') || *pStart == TEXT('\t'); pStart++)
|
|
;
|
|
|
|
/* now rip out trailing white space */
|
|
if (*pStart) { // don't backtrack before beginning of string
|
|
for (p=pStart; *p; p++)
|
|
;
|
|
for (--p; *p == TEXT(' ') || *p == TEXT('\t'); --p)
|
|
;
|
|
*++p = TEXT('\0');
|
|
}
|
|
|
|
/* We're in track mode so peel the track number off the front */
|
|
if (gwCurScale == ID_TRACKS) {
|
|
|
|
/* First non-digit better be a space */
|
|
for (p = pStart; *p && *p != TEXT(' '); p++){
|
|
if (!IsCharNumeric(*p))
|
|
goto LB_Error; // bad char so error out
|
|
}
|
|
|
|
/* It is, so just grab the first numeric and use the rest of */
|
|
/* the string as the time. */
|
|
dwTrack = ATOI(pStart);
|
|
if ((int)dwTrack < (int)gwFirstTrack || dwTrack >= gwFirstTrack +
|
|
gwNumTracks)
|
|
goto LB_Error;
|
|
|
|
/* Now bypass the spaces between track number and time */
|
|
pStart = p;
|
|
while (*pStart == TEXT(' '))
|
|
pStart++;
|
|
|
|
/* There is nothing after the track number. Use it. */
|
|
if (*pStart == TEXT('\0'))
|
|
goto MAKETOTAL;
|
|
|
|
}
|
|
|
|
/* rip through the whole string and look for illegal chars */
|
|
for (p = pStart; *p ; p++){
|
|
if (!IsCharNumeric(*p) && *p != chDecimal && *p != chTime)
|
|
goto LB_Error; // bad char so error out
|
|
}
|
|
|
|
/*
|
|
* The reason for the slightly odd "if" statements of the form:
|
|
*
|
|
* if (pDelim) {
|
|
* if (*pDelim){
|
|
*
|
|
* is because strchr(...) returns an offset OR NULL. As this is then promptly
|
|
* dereferenced to see what character (if any) is there we have a problem.
|
|
* Win16 is allows this sort of thing, but Win32
|
|
* will generate an address exception post haste...
|
|
*
|
|
* Hence we try to do it properly.
|
|
*
|
|
*/
|
|
|
|
/* go find the milliseconds portion if it exists */
|
|
pDelim = STRCHR(pStart, chDecimal);
|
|
if (pDelim) {
|
|
if (*pDelim){
|
|
p = STRRCHR(pStart, chDecimal);
|
|
if (pDelim != p){
|
|
goto LB_Error; // string has > 1 '.', return error
|
|
}
|
|
p++; // move up past delim
|
|
if (STRLEN(p) > 3)
|
|
*(p+3) = TEXT('\0'); // knock off all but thousandths
|
|
wmsec = ATOI(p); // get the fractional part
|
|
if (STRLEN(p) == 1) // adjust to a millisecond value
|
|
wmsec *= 100;
|
|
if (STRLEN(p) == 2)
|
|
wmsec *= 10;
|
|
*pDelim = TEXT('\0'); // null out this terminator
|
|
}
|
|
}
|
|
|
|
/* try and find seconds */
|
|
pDelim = STRRCHR(pStart, chTime); // get last ':'
|
|
if (pDelim) {
|
|
if (*pDelim)
|
|
p = (pDelim+1);
|
|
else
|
|
p = pStart;
|
|
dwSecs = ATOI(p);
|
|
|
|
if (*pDelim)
|
|
*pDelim = TEXT('\0');
|
|
else
|
|
goto MAKETOTAL;
|
|
} else {
|
|
p = pStart;
|
|
dwSecs = ATOI(p);
|
|
|
|
goto MAKETOTAL;
|
|
}
|
|
|
|
/* go and get the minutes part */
|
|
pDelim = STRRCHR(pStart, chTime);
|
|
if (pDelim) {
|
|
if (*pDelim)
|
|
p = (pDelim + 1);
|
|
else {
|
|
p = pStart;
|
|
dwMins = ATOI(p);
|
|
}
|
|
} else {
|
|
p = pStart;
|
|
dwMins = ATOI(p);
|
|
}
|
|
|
|
if (pDelim)
|
|
if (*pDelim)
|
|
*pDelim = TEXT('\0');
|
|
else
|
|
goto MAKETOTAL;
|
|
else
|
|
goto MAKETOTAL;
|
|
|
|
|
|
/* get the hours */
|
|
p = pStart;
|
|
dwHours = ATOI(p);
|
|
|
|
MAKETOTAL:
|
|
/* now we've got the hours, minutes, seconds and any */
|
|
/* fractional part. Time to build up the total time */
|
|
|
|
dwSecs += (dwHours * 3600); // add in hours worth of seconds
|
|
dwSecs += (dwMins * 60); // add in minutes worth of seconds
|
|
dwmSecs = (dwSecs * 1000L) + wmsec;
|
|
|
|
/* For track mode, this is an offset into a track, so add track start */
|
|
if (gwCurScale == ID_TRACKS) {
|
|
dwmSecs += gadwTrackStart[dwTrack - 1];
|
|
}
|
|
|
|
/* build this into a string */
|
|
wsprintf(achTime, TEXT("%ld"), dwmSecs);
|
|
w = STRLEN(achTime);
|
|
|
|
if (wCurScaleSave)
|
|
gwCurScale = wCurScaleSave;
|
|
|
|
/* copy to user buffer and return */
|
|
lstrcpy(lpsz, achTime);
|
|
return w;
|
|
|
|
LB_Error:
|
|
gwCurScale = wCurScaleSave;
|
|
return LB_ERR;
|
|
}
|
|
}
|
|
|
|
|
|
/*--------------------------------------------------------------+
|
|
| frameboxiArrowEdit() - handle the spin arrows for msec mode. |
|
|
| |
|
|
+--------------------------------------------------------------*/
|
|
LONG_PTR NEAR PASCAL frameboxiArrowEdit(HWND hwnd, WPARAM wParam, LONG_PTR lParam)
|
|
{
|
|
TCHAR achTime[20];
|
|
DWORD dwmSecs, dwStart, dwEnd;
|
|
|
|
if (hwnd == GetDlgItem(GetParent(hwnd), IDC_EDITNUM)) {
|
|
dwStart = 0;
|
|
dwEnd = gdwMediaLength;
|
|
} else {
|
|
dwStart = gdwMediaStart;
|
|
dwEnd = GETMAXFRAME(hwnd);
|
|
}
|
|
|
|
frameboxiGetText(hwnd, CHAR_COUNT(achTime), (LPTSTR)achTime);
|
|
dwmSecs = ATOL(achTime);
|
|
if (LOWORD(wParam) == SB_LINEUP){
|
|
if ((long)dwmSecs >= (long)dwStart - gInc &&
|
|
(long)dwmSecs < (long)dwEnd) {
|
|
dwmSecs += gInc;
|
|
wsprintf(achTime, TEXT("%ld"), dwmSecs);
|
|
/* bring focus here NOW! so update works */
|
|
SendMessage(hwnd,
|
|
WM_NEXTDLGCTL,
|
|
(WPARAM)GETEDITBOXWND(hwnd),
|
|
(LPARAM)1L);
|
|
frameboxSetText(GETEDITBOXWND(hwnd), (LPTSTR)achTime);
|
|
/* now let's highlight the whole thing */
|
|
|
|
HILIGHTEDITBOX(hwnd);
|
|
|
|
} else
|
|
MessageBeep(MB_ICONEXCLAMATION);
|
|
} else if (LOWORD(wParam) == SB_LINEDOWN){
|
|
if ((long)dwmSecs > (long)dwStart &&
|
|
(long)dwmSecs <= (long)dwEnd + gInc) {
|
|
if ((long)dwmSecs - gInc < (long)dwStart)
|
|
dwmSecs = dwStart;
|
|
else
|
|
dwmSecs -= gInc;
|
|
wsprintf(achTime, TEXT("%ld"), dwmSecs);
|
|
/* bring focus here NOW! so update works */
|
|
SendMessage(hwnd,
|
|
WM_NEXTDLGCTL,
|
|
(WPARAM)GETEDITBOXWND(hwnd),
|
|
(LPARAM)1L);
|
|
frameboxSetText(GETEDITBOXWND(hwnd), (LPTSTR)achTime);
|
|
/* now let's highlight the whole thing */
|
|
|
|
HILIGHTEDITBOX(hwnd);
|
|
|
|
} else
|
|
MessageBeep(MB_ICONEXCLAMATION);
|
|
}
|
|
// now update the world by sending the proper message
|
|
|
|
SendMessage(GetParent(hwnd),
|
|
WM_COMMAND,
|
|
(WPARAM)MAKELONG((WORD)GETWINDOWID(hwnd), EN_KILLFOCUS),
|
|
(LPARAM)hwnd);
|
|
|
|
return dwmSecs;
|
|
}
|
|
|