void CXTPSkinObjectFrame::TrackCaptionButton()
{
SetCapture();
BOOL bAccept = FALSE;
m_pButtonPressed = m_pButtonHot;
CCaptionButton* pButtonPressed = m_pButtonHot;
ASSERT(pButtonPressed);
RedrawFrame();
while (::GetCapture() == m_hWnd)
{
MSG msg;
if (!::GetMessage(&msg, NULL, 0, 0))
{
AfxPostQuitMessage((int)msg.wParam);
break;
}
if (msg.message == WM_LBUTTONUP)
{
bAccept = m_pButtonPressed == pButtonPressed;
break;
}
else if (msg.message == WM_NCMOUSELEAVE)
{
}
else if (msg.message == WM_MOUSEMOVE)
{
POINT point = msg.pt;
ScreenToFrame(&point);
CCaptionButton* pButton = HitTestButton(point) == pButtonPressed ? pButtonPressed : NULL;
if (pButton != m_pButtonPressed)
{
m_pButtonPressed = pButton;
RedrawFrame();
}
}
else
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
m_pButtonPressed = NULL;
m_pButtonHot = NULL;
ReleaseCapture();
RedrawFrame();
if (bAccept)
{
SendMessage(WM_SYSCOMMAND, pButtonPressed->m_nCommand);
}
}
BOOL CXTPSkinObjectFrame::PreHookMessage(UINT nMessage)
{
if ((nMessage == WM_ENTERIDLE) && (m_pManager->GetApplyOptions() & xtpSkinApplyFrame) &&
((GetStyle() & (WS_CAPTION | WS_MINIMIZE | WS_VISIBLE)) == (WS_CAPTION | WS_MINIMIZE | WS_VISIBLE)))
{
RedrawFrame();
}
if (nMessage >= WM_LBUTTONDOWN && nMessage <= WM_MBUTTONDBLCLK)
m_bMenuStatus = FALSE;
if (m_bLockFrameDraw && (nMessage == WM_NCCALCSIZE || nMessage == WM_STYLECHANGED || nMessage == WM_STYLECHANGING))
return TRUE;
if ((m_pManager->GetApplyOptions() & xtpSkinApplyFrame) == 0)
{
if (nMessage == WM_NCPAINT || nMessage == WM_NCCALCSIZE ||
nMessage == WM_NCHITTEST || nMessage == WM_NCLBUTTONDOWN ||
nMessage == WM_NCLBUTTONDBLCLK ||
nMessage == WM_WINDOWPOSCHANGED || nMessage == WM_NCMOUSEMOVE ||
nMessage == WM_NCMOUSELEAVE || nMessage == WM_NCACTIVATE ||
nMessage == WM_WINDOWPOSCHANGING || nMessage == WM_PRINT)
return TRUE;
}
return CXTPSkinObject::PreHookMessage(nMessage);
}
LRESULT CXTPSkinObjectFrame::OnSetIcon(WPARAM, LPARAM)
{
LRESULT lResult = Default();
RedrawFrame();
return lResult;
}
void CXTPSkinObjectFrame::OnSysCommand(UINT nID, LPARAM lParam)
{
UINT nCmd = (nID & 0xFFF0);
if ((nCmd == SC_MAXIMIZE) && m_pManager->HasApplyOptions(xtpSkinApplyMetrics | xtpSkinApplyFrame) &&
((GetExStyle() & WS_EX_MDICHILD) == WS_EX_MDICHILD) &&
((GetStyle() & WS_MAXIMIZE) == 0))
{
CXTPSkinObject::OnSysCommand(nID, lParam);
RECT rc;
GetParent()->GetClientRect(&rc);
int cx = rc.right - rc.left;
int cy = rc.bottom - rc.top;
rc.left = -m_rcBorders.left;
rc.top = -m_rcBorders.top;
rc.right = cx + m_rcBorders.right;
rc.bottom = cy + m_rcBorders.bottom;
MoveWindow(rc.left, rc.top,
rc.right - rc.left, rc.bottom - rc.top, TRUE);
return;
}
if (HandleSysCommand(nID, lParam))
return;
if ((nCmd == SC_MOVE) && (GetStyle() & WS_MINIMIZE) && (GetSkinManager()->GetApplyOptions() & xtpSkinApplyFrame))
{
DoDefWindowProc(WM_NCPAINT, 0, 0);
RedrawFrame();
}
CXTPSkinObject::OnSysCommand(nID, lParam);
if ((nCmd == SC_MINIMIZE) && (GetSkinManager()->GetApplyOptions() & xtpSkinApplyFrame))
{
RedrawFrame();
}
}
BOOL CXTPSkinObjectFrame::DrawMenuBar()
{
m_dwStyle = m_dwExStyle = (DWORD)-1;
UpdateButtons();
UpdateMenuBar();
RedrawFrame();
return TRUE;
}
static int ColorChanged(WPARAM wparam, LPARAM lparam)
{
ColourID cid = {0};
cid.cbSize = sizeof(ColourID);
lstrcpynA(cid.group, "My Details", sizeof(cid.group));
lstrcpynA(cid.name, "Background", sizeof(cid.name));
opts.bkg_color = (COLORREF) CallService(MS_COLOUR_GET, (WPARAM) &cid, 0);
RedrawFrame();
return 0;
}
BOOL CElcSkinFrameBase::NcActivate(BOOL bActive)
{
m_bActivated = bActive;
if (!bActive) {
m_nActiveItem = -1;
m_bMenuActivated = FALSE;
m_nActiveButton = -1;
m_nLBDownItem = ESNWT_NONE;
}
RedrawFrame();
return TRUE;
}
LRESULT CXTPSkinObjectFrame::OnSetText(WPARAM wParam, LPARAM lParam)
{
if (((GetStyle() & WS_CAPTION) == WS_CAPTION) && (GetSkinManager()->GetApplyOptions() & xtpSkinApplyFrame))
{
LRESULT lRet = DefWindowProc(WM_SETTEXT, wParam, lParam);
RedrawFrame();
if ((GetExStyle() & WS_EX_MDICHILD) && (GetStyle() & (WS_MAXIMIZE | WS_CHILD)) == (WS_MAXIMIZE | WS_CHILD))
{
CWnd* pWnd = GetTopLevelParent();
pWnd->SendMessage(WM_NCPAINT, 0, 0);
}
return lRet;
}
return Default();
}
BOOL CXTPSkinObjectFrame::OnNcActivate(BOOL bActive)
{
if (HasCaption())
{
CallDefDlgProc(WM_NCACTIVATE, (WPARAM)bActive, 0);
if (!bActive)
{
CWnd* pWnd = CWnd::FromHandlePermanent(m_hWnd);
// Mimic MFC kludge to stay active if WF_STAYACTIVE bit is on
//
if (pWnd && pWnd->m_nFlags & WF_STAYACTIVE)
bActive = TRUE;
if (!IsWindowEnabled())
bActive = FALSE;
}
HWND hWndClient = FindMDIClient();
HWND hWndActive = hWndClient ? (HWND)::SendMessage(hWndClient, WM_MDIGETACTIVE, 0, 0) : NULL;
if (hWndActive != m_hWnd && hWndActive)
{
::SendMessage(hWndActive, WM_NCACTIVATE, bActive, 0);
::SendMessage(hWndActive, WM_NCPAINT, 0, 0);
}
m_bActive = bActive; // update state
RedrawFrame();
return TRUE;
}
return CXTPSkinObject::OnNcActivate(bActive);
}
/* read an X event */
void ReadXServer (void)
{
static XEvent event;
int old_cursor = 0, keypress;
Item *item, *old_item;
KeySym ks;
char *sp, *dp;
static unsigned char buf[10]; /* unsigned for international */
static int n;
while (FEventsQueued(dpy, QueuedAfterReading)) {
FNextEvent(dpy, &event);
if (event.xany.window == CF.frame) {
switch (event.type) {
case ClientMessage:
{
if(event.xclient.format == 32 &&
event.xclient.data.l[0] == wm_del_win)
{
exit(0);
}
}
break;
case ConfigureNotify: /* has window be reconfigured */
{
XEvent tmpe;
while (FCheckTypedWindowEvent(
dpy, CF.frame, ConfigureNotify, &tmpe))
{
if (!tmpe.xconfigure.send_event)
continue;
event.xconfigure.x = tmpe.xconfigure.x;
event.xconfigure.y = tmpe.xconfigure.y;
event.xconfigure.send_event = True;
}
if (CF.max_width != event.xconfigure.width ||
CF.total_height != event.xconfigure.height)
{
/* adjust yourself... do noting */
ResizeFrame();
CF.max_width = event.xconfigure.width;
CF.total_height = event.xconfigure.height;
UpdateRootTransapency(False, True);
if (!CSET_IS_TRANSPARENT(colorset))
{
RedrawFrame(NULL);
}
}
else if (event.xconfigure.send_event)
{
UpdateRootTransapency(False, True);
}
}
break;
#if 0
case SelectionClear:
selection_clear ();
break;
case SelectionNotify:
selection_paste ();
break;
case SelectionRequest:
selection_send ();
break;
#endif
case Expose:
{
int ex = event.xexpose.x;
int ey = event.xexpose.y;
int ex2 = event.xexpose.x + event.xexpose.width;
int ey2 = event.xexpose.y + event.xexpose.height;
while (FCheckTypedWindowEvent(dpy, CF.frame, Expose, &event))
{
ex = min(ex, event.xexpose.x);
ey = min(ey, event.xexpose.y);
ex2 = max(ex2, event.xexpose.x + event.xexpose.width);
ey2 = max(ey2 , event.xexpose.y + event.xexpose.height);
}
event.xexpose.x = ex;
event.xexpose.y = ey;
event.xexpose.width = ex2 - ex;
event.xexpose.height = ey2 - ey;
RedrawFrame(&event);
if (CF.grab_server && !CF.server_grabbed)
{
if (GrabSuccess ==
XGrabPointer(dpy, CF.frame, True, 0,
GrabModeAsync, GrabModeAsync,
None, None, CurrentTime))
CF.server_grabbed = 1;
}
}
break;
case VisibilityNotify:
if (CF.server_grabbed &&
event.xvisibility.state != VisibilityUnobscured)
{
/* raise our window to the top */
XRaiseWindow(dpy, CF.frame);
XSync(dpy, 0);
}
break;
case KeyPress: /* we do text input here */
n = XLookupString(&event.xkey, (char *)buf, sizeof(buf), &ks, NULL);
keypress = buf[0];
myfprintf((stderr, "Keypress [%s]\n", buf));
if (n == 0) { /* not a regular key, translate it into one */
switch (ks) {
case XK_Home:
case XK_Begin:
buf[0] = '\001'; /* ^A */
break;
case XK_End:
buf[0] = '\005'; /* ^E */
break;
case XK_Left:
buf[0] = '\002'; /* ^B */
break;
case XK_Right:
buf[0] = '\006'; /* ^F */
break;
case XK_Up:
buf[0] = '\020'; /* ^P */
break;
case XK_Down:
buf[0] = '\016'; /* ^N */
break;
default:
if (ks >= XK_F1 && ks <= XK_F35) {
buf[0] = '\0';
keypress = 257 + ks - XK_F1;
} else
goto no_redraw; /* no action for this event */
}
}
switch (ks) { /* regular key, may need adjustment */
case XK_Tab:
#ifdef XK_XKB_KEYS
case XK_ISO_Left_Tab:
#endif
if (event.xkey.state & ShiftMask) { /* shifted key */
buf[0] = '\020'; /* chg shift tab to ^P */
}
break;
case '>':
if (event.xkey.state & Mod1Mask) { /* Meta, shift > */
process_history(1);
goto redraw_newcursor;
}
break;
case '<':
if (event.xkey.state & Mod1Mask) { /* Meta, shift < */
process_history(-1);
goto redraw_newcursor;
}
break;
}
if (!CF.cur_input) { /* no text input fields */
for (item = root_item_ptr; item != 0;
item = item->header.next) {/* all items */
if (item->type == I_BUTTON && item->button.keypress == keypress) {
RedrawItem(item, 1, NULL);
usleep(MICRO_S_FOR_10MS);
RedrawItem(item, 0, NULL);
DoCommand(item);
goto no_redraw;
}
}
break;
} else if (CF.cur_input == CF.cur_input->input.next_input) {
/* 1 ip field */
switch (buf[0]) {
case '\020': /* ^P previous field */
process_history(-1);
goto redraw_newcursor;
break;
case '\016': /* ^N next field */
process_history(1);
goto redraw_newcursor;
break;
} /* end switch */
} /* end one input field */
switch (buf[0]) {
case '\001': /* ^A */
old_cursor = CF.abs_cursor;
CF.rel_cursor = 0;
CF.abs_cursor = 0;
CF.cur_input->input.left = 0;
goto redraw_newcursor;
break;
case '\005': /* ^E */
old_cursor = CF.abs_cursor;
CF.rel_cursor = CF.cur_input->input.n;
if ((CF.cur_input->input.left =
CF.rel_cursor - CF.cur_input->input.size) < 0)
CF.cur_input->input.left = 0;
CF.abs_cursor = CF.rel_cursor - CF.cur_input->input.left;
goto redraw_newcursor;
break;
case '\002': /* ^B */
old_cursor = CF.abs_cursor;
if (CF.rel_cursor > 0) {
CF.rel_cursor--;
CF.abs_cursor--;
if (CF.abs_cursor <= 0 && CF.rel_cursor > 0) {
CF.abs_cursor++;
CF.cur_input->input.left--;
}
}
goto redraw_newcursor;
break;
case '\006': /* ^F */
old_cursor = CF.abs_cursor;
if (CF.rel_cursor < CF.cur_input->input.n) {
CF.rel_cursor++;
CF.abs_cursor++;
if (CF.abs_cursor >= CF.cur_input->input.size &&
CF.rel_cursor < CF.cur_input->input.n) {
CF.abs_cursor--;
CF.cur_input->input.left++;
}
}
goto redraw_newcursor;
break;
case '\010': /* ^H */
old_cursor = CF.abs_cursor;
if (CF.rel_cursor > 0) {
sp = CF.cur_input->input.value + CF.rel_cursor;
dp = sp - 1;
for (; *dp = *sp, *sp != '\0'; dp++, sp++);
CF.cur_input->input.n--;
CF.rel_cursor--;
if (CF.rel_cursor < CF.abs_cursor) {
CF.abs_cursor--;
if (CF.abs_cursor <= 0 && CF.rel_cursor > 0) {
CF.abs_cursor++;
CF.cur_input->input.left--;
}
} else
CF.cur_input->input.left--;
}
goto redraw_newcursor;
break;
case '\177': /* DEL */
case '\004': /* ^D */
if (CF.rel_cursor < CF.cur_input->input.n) {
sp = CF.cur_input->input.value + CF.rel_cursor + 1;
dp = sp - 1;
for (; *dp = *sp, *sp != '\0'; dp++, sp++);
CF.cur_input->input.n--;
goto redraw_newcursor;
}
break;
case '\013': /* ^K */
CF.cur_input->input.value[CF.rel_cursor] = '\0';
CF.cur_input->input.n = CF.rel_cursor;
goto redraw_newcursor;
case '\025': /* ^U */
CF.cur_input->input.value[0] = '\0';
CF.cur_input->input.n = CF.cur_input->input.left = 0;
CF.rel_cursor = CF.abs_cursor = 0;
goto redraw_newcursor;
case '\020': /* ^P previous field */
old_item = CF.cur_input;
CF.cur_input = old_item->input.prev_input; /* new current input fld */
RedrawItem(old_item, 1, NULL);
CF.rel_cursor = CF.abs_cursor = 0; /* home cursor in new input field */
goto redraw;
break;
case '\t':
case '\n':
case '\015':
case '\016': /* LINEFEED, TAB, RETURN, ^N, jump to the next field */
switch (process_tabtypes(&buf[0])) {
case 0: goto no_redraw;break;
case 1: goto redraw;break;
}
break;
default:
old_cursor = CF.abs_cursor;
if((buf[0] >= ' ' &&
buf[0] < '\177') ||
(buf[0] >= 160)) { /* regular or intl char */
process_regular_char_input(&buf[0]); /* insert into input field */
goto redraw_newcursor;
}
/* unrecognized key press, check for buttons */
for (item = root_item_ptr; item != 0; item = item->header.next)
{
/* all items */
myfprintf((stderr, "Button: keypress==%d\n",
item->button.keypress));
if (item->type == I_BUTTON && item->button.keypress == keypress) {
RedrawItem(item, 1, NULL);
usleep(MICRO_S_FOR_10MS); /* .1 seconds */
RedrawItem(item, 0, NULL);
DoCommand(item);
goto no_redraw;
}
}
break;
}
redraw_newcursor:
{
XSetForeground(dpy, CF.cur_input->header.dt_ptr->dt_item_GC,
CF.cur_input->header.dt_ptr->dt_colors[c_item_bg]);
/* Since DrawString is being used, I changed this to clear the
entire input field. dje 10/24/99. */
XClearArea(dpy, CF.cur_input->header.win,
BOX_SPC + TEXT_SPC - 1, BOX_SPC,
CF.cur_input->header.size_x
- (2 * BOX_SPC) - 2 - TEXT_SPC,
(CF.cur_input->header.size_y - 1)
- 2 * BOX_SPC + 1, False);
}
redraw:
{
int len, x, dy;
len = CF.cur_input->input.n - CF.cur_input->input.left;
XSetForeground(dpy, CF.cur_input->header.dt_ptr->dt_item_GC,
CF.cur_input->header.dt_ptr->dt_colors[c_item_fg]);
if (len > CF.cur_input->input.size)
len = CF.cur_input->input.size;
CF.cur_input->header.dt_ptr->dt_Fstr->win = CF.cur_input->header.win;
CF.cur_input->header.dt_ptr->dt_Fstr->gc =
CF.cur_input->header.dt_ptr->dt_item_GC;
CF.cur_input->header.dt_ptr->dt_Fstr->flags.has_colorset = False;
if (itemcolorset >= 0)
{
CF.cur_input->header.dt_ptr->dt_Fstr->colorset =
&Colorset[itemcolorset];
CF.cur_input->header.dt_ptr->dt_Fstr->flags.has_colorset = True;
}
CF.cur_input->header.dt_ptr->dt_Fstr->str = CF.cur_input->input.value;
CF.cur_input->header.dt_ptr->dt_Fstr->x = BOX_SPC + TEXT_SPC;
CF.cur_input->header.dt_ptr->dt_Fstr->y = BOX_SPC + TEXT_SPC
+ CF.cur_input->header.dt_ptr->dt_Ffont->ascent;
CF.cur_input->header.dt_ptr->dt_Fstr->len = len;
FlocaleDrawString(dpy,
CF.cur_input->header.dt_ptr->dt_Ffont,
CF.cur_input->header.dt_ptr->dt_Fstr,
FWS_HAVE_LENGTH);
x = BOX_SPC + TEXT_SPC +
FlocaleTextWidth(CF.cur_input->header.dt_ptr->dt_Ffont,
CF.cur_input->input.value,CF.abs_cursor)
- 1;
dy = CF.cur_input->header.size_y - 1;
XDrawLine(dpy, CF.cur_input->header.win,
CF.cur_input->header.dt_ptr->dt_item_GC,
x, BOX_SPC, x, dy - BOX_SPC);
myfprintf((stderr,"Line %d/%d - %d/%d (char)\n",
x, BOX_SPC, x, dy - BOX_SPC));
}
no_redraw:
break; /* end of case KeyPress */
} /* end of switch (event.type) */
continue;
} /* end of if (event.xany.window == CF.frame) */
for (item = root_item_ptr; item != 0;
item = item->header.next) { /* all items */
if (event.xany.window == item->header.win) {
switch (event.type) {
case Expose:
{
int ex = event.xexpose.x;
int ey = event.xexpose.y;
int ex2 = event.xexpose.x + event.xexpose.width;
int ey2 = event.xexpose.y + event.xexpose.height;
while (FCheckTypedWindowEvent(
dpy, item->header.win, Expose, &event))
{
ex = min(ex, event.xexpose.x);
ey = min(ey, event.xexpose.y);
ex2 = max(ex2, event.xexpose.x + event.xexpose.width);
ey2 = max(ey2 , event.xexpose.y + event.xexpose.height);
}
event.xexpose.x = ex;
event.xexpose.y = ey;
event.xexpose.width = ex2 - ex;
event.xexpose.height = ey2 - ey;
RedrawItem(item, 0, &event);
}
break;
case ButtonPress:
if (item->type == I_INPUT) {
old_item = CF.cur_input;
CF.cur_input = item;
RedrawItem(old_item, 1, NULL);
{
Bool done = False;
CF.abs_cursor = 0;
while(CF.abs_cursor <= item->input.size && !done)
{
if (FlocaleTextWidth(item->header.dt_ptr->dt_Ffont,
item->input.value,
CF.abs_cursor) >=
event.xbutton.x - BOX_SPC - TEXT_SPC)
{
done = True;
CF.abs_cursor--;
}
else
{
CF.abs_cursor++;
}
}
}
if (CF.abs_cursor < 0)
CF.abs_cursor = 0;
if (CF.abs_cursor > item->input.size)
CF.abs_cursor = item->input.size;
CF.rel_cursor = CF.abs_cursor + item->input.left;
if (CF.rel_cursor < 0)
CF.rel_cursor = 0;
if (CF.rel_cursor > item->input.n)
CF.rel_cursor = item->input.n;
if (CF.rel_cursor > 0 && CF.rel_cursor == item->input.left)
item->input.left--;
if (CF.rel_cursor < item->input.n &&
CF.rel_cursor == item->input.left + item->input.size)
item->input.left++;
CF.abs_cursor = CF.rel_cursor - item->input.left;
if (event.xbutton.button == Button2) { /* if paste request */
process_paste_request (&event, item);
}
RedrawItem(item, 0, NULL);
}
if (item->type == I_CHOICE)
ToggleChoice(item);
if (item->type == I_BUTTON) {
RedrawItem(item, 1, NULL); /* push button in */
if (CF.activate_on_press) {
usleep(MICRO_S_FOR_10MS); /* make sure its visible */
RedrawItem(item, 0, NULL); /* pop button out */
DoCommand(item); /* execute the button command */
} else {
XGrabPointer(dpy, item->header.win,
False, /* owner of events */
ButtonReleaseMask, /* events to report */
GrabModeAsync, /* keyboard mode */
GrabModeAsync, /* pointer mode */
None, /* confine to */
/* I sort of like this, the hand points in
the other direction and the color is
reversed. I don't know what other GUIs do,
Java doesn't do anything, neither does anything
else I can find...dje */
CF.pointer[button_in_pointer], /* cursor */
CurrentTime);
} /* end activate on press */
}
break;
case ButtonRelease:
if (!CF.activate_on_press) {
RedrawItem(item, 0, NULL);
if (CF.grab_server && CF.server_grabbed) {
/* You have to regrab the pointer, or focus
can go to another window.
grab...
*/
XGrabPointer(dpy, CF.frame, True, 0, GrabModeAsync, GrabModeAsync,
None, None, CurrentTime);
XFlush(dpy);
} else {
XUngrabPointer(dpy, CurrentTime);
XFlush(dpy);
}
if (event.xbutton.x >= 0 &&
event.xbutton.x < item->header.size_x &&
event.xbutton.y >= 0 &&
event.xbutton.y < item->header.size_y) {
DoCommand(item);
}
}
break;
}
}
} /* end of for (i = 0) */
} /* while loop */
}
// weather options
INT_PTR CALLBACK OptionsProc(HWND hdlg, UINT msg, WPARAM wparam, LPARAM lparam)
{
TCHAR str[512];
switch (msg) {
case WM_INITDIALOG:
opt_startup = TRUE;
TranslateDialogDefault(hdlg);
// load settings
_ltot(opt.UpdateTime, str, 10);
SetDlgItemText(hdlg, IDC_UPDATETIME, str);
SetDlgItemText(hdlg, IDC_DEGREE, opt.DegreeSign);
SendDlgItemMessage(hdlg, IDC_AVATARSPIN, UDM_SETRANGE32, 0, 999);
SendDlgItemMessage(hdlg, IDC_AVATARSPIN, UDM_SETPOS, 0, opt.AvatarSize);
SendDlgItemMessage(hdlg, IDC_AVATARSIZE, EM_LIMITTEXT, 3, 0);
CheckDlgButton(hdlg, IDC_STARTUPUPD, opt.StartupUpdate ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hdlg, IDC_UPDATE, opt.AutoUpdate ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hdlg, IDC_PROTOCOND, !opt.NoProtoCondition ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hdlg, IDC_UPDCONDCHG, opt.UpdateOnlyConditionChanged ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hdlg, IDC_REMOVEOLD, opt.RemoveOldData ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hdlg, IDC_MAKEI, opt.MakeItalic ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hdlg, IDC_DISCONDICON, opt.DisCondIcon ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hdlg, IDC_DONOTAPPUNITS, opt.DoNotAppendUnit ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hdlg, IDC_NOFRAC, opt.NoFrac ? BST_CHECKED : BST_UNCHECKED);
// load units
switch (opt.tUnit) { // temperature
case 1: CheckRadioButton(hdlg, IDC_T1, IDC_T2, IDC_T1); break;
case 2: CheckRadioButton(hdlg, IDC_T1, IDC_T2, IDC_T2); break;
}
switch (opt.wUnit) { // wind
case 1: CheckRadioButton(hdlg, IDC_W1, IDC_W4, IDC_W1); break;
case 2: CheckRadioButton(hdlg, IDC_W1, IDC_W4, IDC_W2); break;
case 3: CheckRadioButton(hdlg, IDC_W1, IDC_W4, IDC_W3); break;
case 4: CheckRadioButton(hdlg, IDC_W1, IDC_W4, IDC_W4); break;
}
switch (opt.vUnit) { // visibility
case 1: CheckRadioButton(hdlg, IDC_V1, IDC_V2, IDC_V1); break;
case 2: CheckRadioButton(hdlg, IDC_V1, IDC_V2, IDC_V2); break;
}
switch (opt.pUnit) { // pressure
case 1: CheckRadioButton(hdlg, IDC_P1, IDC_P4, IDC_P1); break;
case 2: CheckRadioButton(hdlg, IDC_P1, IDC_P4, IDC_P2); break;
case 3: CheckRadioButton(hdlg, IDC_P1, IDC_P4, IDC_P3); break;
case 4: CheckRadioButton(hdlg, IDC_P1, IDC_P4, IDC_P4); break;
}
switch (opt.dUnit) { // pressure
case 1: CheckRadioButton(hdlg, IDC_D1, IDC_D3, IDC_D1); break;
case 2: CheckRadioButton(hdlg, IDC_D1, IDC_D3, IDC_D2); break;
case 3: CheckRadioButton(hdlg, IDC_D1, IDC_D3, IDC_D3); break;
}
switch (opt.eUnit) { // elev
case 1: CheckRadioButton(hdlg, IDC_E1, IDC_E2, IDC_E1); break;
case 2: CheckRadioButton(hdlg, IDC_E1, IDC_E2, IDC_E2); break;
}
opt_startup = FALSE;
return 0;
case WM_COMMAND:
if (HIWORD(wparam) == BN_CLICKED && GetFocus() == (HWND)lparam)
if (!opt_startup) SendMessage(GetParent(hdlg), PSM_CHANGED, 0, 0);
if (!((LOWORD(wparam) == IDC_UPDATE || LOWORD(wparam) == IDC_DEGREE) &&
(HIWORD(wparam) != EN_CHANGE || (HWND)lparam != GetFocus())))
if (!opt_startup) SendMessage(GetParent(hdlg), PSM_CHANGED, 0, 0);
return 0;
case WM_NOTIFY:
switch (((LPNMHDR)lparam)->code) {
case PSN_APPLY:
// change the status for weather protocol
if (IsDlgButtonChecked(hdlg, IDC_PROTOCOND) && opt.DefStn != NULL) {
old_status = status;
status = db_get_w(opt.DefStn, WEATHERPROTONAME, "StatusIcon", NOSTATUSDATA);
ProtoBroadcastAck(WEATHERPROTONAME, NULL, ACKTYPE_STATUS, ACKRESULT_SUCCESS, (HANDLE)old_status, status);
}
// get update time and remove the old timer
GetDlgItemText(hdlg, IDC_UPDATETIME, str, _countof(str));
opt.UpdateTime = (WORD)_ttoi(str);
if (opt.UpdateTime < 1) opt.UpdateTime = 1;
KillTimer(NULL, timerId);
timerId = SetTimer(NULL, 0, opt.UpdateTime * 60000, (TIMERPROC)timerProc);
// other general options
GetDlgItemText(hdlg, IDC_DEGREE, opt.DegreeSign, _countof(opt.DegreeSign));
opt.StartupUpdate = IsDlgButtonChecked(hdlg, IDC_STARTUPUPD);
opt.AutoUpdate = IsDlgButtonChecked(hdlg, IDC_UPDATE);
opt.NoProtoCondition = BST_UNCHECKED == IsDlgButtonChecked(hdlg, IDC_PROTOCOND);
opt.DisCondIcon = IsDlgButtonChecked(hdlg, IDC_DISCONDICON);
opt.UpdateOnlyConditionChanged = (BYTE)IsDlgButtonChecked(hdlg, IDC_UPDCONDCHG);
opt.RemoveOldData = IsDlgButtonChecked(hdlg, IDC_REMOVEOLD);
opt.MakeItalic = IsDlgButtonChecked(hdlg, IDC_MAKEI);
opt.AvatarSize = GetDlgItemInt(hdlg, IDC_AVATARSIZE, NULL, FALSE);
opt.DoNotAppendUnit = IsDlgButtonChecked(hdlg, IDC_DONOTAPPUNITS);
opt.NoFrac = IsDlgButtonChecked(hdlg, IDC_NOFRAC);
UpdateMenu(opt.AutoUpdate);
// save the units
if (IsDlgButtonChecked(hdlg, IDC_T1)) opt.tUnit = 1;
if (IsDlgButtonChecked(hdlg, IDC_T2)) opt.tUnit = 2;
if (IsDlgButtonChecked(hdlg, IDC_W1)) opt.wUnit = 1;
if (IsDlgButtonChecked(hdlg, IDC_W2)) opt.wUnit = 2;
if (IsDlgButtonChecked(hdlg, IDC_W3)) opt.wUnit = 3;
if (IsDlgButtonChecked(hdlg, IDC_W4)) opt.wUnit = 4;
if (IsDlgButtonChecked(hdlg, IDC_V1)) opt.vUnit = 1;
if (IsDlgButtonChecked(hdlg, IDC_V2)) opt.vUnit = 2;
if (IsDlgButtonChecked(hdlg, IDC_P1)) opt.pUnit = 1;
if (IsDlgButtonChecked(hdlg, IDC_P2)) opt.pUnit = 2;
if (IsDlgButtonChecked(hdlg, IDC_P3)) opt.pUnit = 3;
if (IsDlgButtonChecked(hdlg, IDC_P4)) opt.pUnit = 4;
if (IsDlgButtonChecked(hdlg, IDC_D1)) opt.dUnit = 1;
if (IsDlgButtonChecked(hdlg, IDC_D2)) opt.dUnit = 2;
if (IsDlgButtonChecked(hdlg, IDC_D3)) opt.dUnit = 3;
if (IsDlgButtonChecked(hdlg, IDC_E1)) opt.eUnit = 1;
if (IsDlgButtonChecked(hdlg, IDC_E2)) opt.eUnit = 2;
// save the new weather options
SaveOptions();
RedrawFrame(0, 0);
return 1;
}
break;
}
return 0;
}
static void SkinChanged(void *param, SKINNED_DIALOG dlg)
{
RedrawFrame();
}
void CXTPSkinObjectFrame::InvalidateButtons()
{
RedrawFrame();
}
