//-----------------------------------------------------------------------------
// Pop up the UART simulation window; like a terminal window where the
// characters that you type go into UART RECV instruction and whatever
// the program puts into UART SEND shows up as text.
//-----------------------------------------------------------------------------
void ShowUartSimulationWindow(void)
{
WNDCLASSEX wc;
memset(&wc, 0, sizeof(wc));
wc.cbSize = sizeof(wc);
wc.style = CS_BYTEALIGNCLIENT | CS_BYTEALIGNWINDOW | CS_OWNDC |
CS_DBLCLKS;
wc.lpfnWndProc = (WNDPROC)UartSimulationProc;
wc.hInstance = Instance;
wc.hbrBackground = (HBRUSH)COLOR_BTNSHADOW;
wc.lpszClassName = "LDmicroUartSimulationWindow";
wc.lpszMenuName = NULL;
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
RegisterClassEx(&wc);
DWORD TerminalX = 200, TerminalY = 200, TerminalW = 300, TerminalH = 150;
ThawDWORD(TerminalX);
ThawDWORD(TerminalY);
ThawDWORD(TerminalW);
ThawDWORD(TerminalH);
if(TerminalW > 800) TerminalW = 100;
if(TerminalH > 800) TerminalH = 100;
RECT r;
GetClientRect(GetDesktopWindow(), &r);
if(TerminalX >= (DWORD)(r.right - 10)) TerminalX = 100;
if(TerminalY >= (DWORD)(r.bottom - 10)) TerminalY = 100;
UartSimulationWindow = CreateWindowClient(WS_EX_TOOLWINDOW |
WS_EX_APPWINDOW, "LDmicroUartSimulationWindow",
"UART Simulation (Terminal)", WS_VISIBLE | WS_SIZEBOX,
TerminalX, TerminalY, TerminalW, TerminalH,
NULL, NULL, Instance, NULL);
UartSimulationTextControl = CreateWindowEx(0, WC_EDIT, "", WS_CHILD |
WS_CLIPSIBLINGS | WS_VISIBLE | ES_AUTOVSCROLL | ES_MULTILINE |
WS_VSCROLL, 0, 0, TerminalW, TerminalH, UartSimulationWindow, NULL,
Instance, NULL);
HFONT fixedFont = CreateFont(14, 0, 0, 0, FW_REGULAR, FALSE, FALSE, FALSE,
ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY,
FF_DONTCARE, "Lucida Console");
if(!fixedFont)
fixedFont = (HFONT)GetStockObject(SYSTEM_FONT);
SendMessage((HWND)UartSimulationTextControl, WM_SETFONT, (WPARAM)fixedFont,
TRUE);
PrevTextProc = SetWindowLongPtr(UartSimulationTextControl,
GWLP_WNDPROC, (LONG_PTR)UartSimulationTextProc);
ShowWindow(UartSimulationWindow, TRUE);
SetFocus(MainWindow);
}
void ShowCommentDialog(char *comment)
{
RECT r;
GetClientRect(MainWindow, &r);
CommentDialog = CreateWindowClient(0, "LDmicroDialog",
_("Comment"), WS_OVERLAPPED | WS_SYSMENU,
r.left+20, 100, r.right-r.left-40, 65, NULL, NULL, Instance, NULL);
MakeControls(r);
SendMessage(CommentTextbox, WM_SETTEXT, 0, (LPARAM)comment);
EnableWindow(MainWindow, FALSE);
ShowWindow(CommentDialog, TRUE);
SetFocus(CommentTextbox);
SendMessage(CommentTextbox, EM_SETSEL, 0, -1);
MSG msg;
DWORD ret;
DialogDone = FALSE;
DialogCancel = FALSE;
while((ret = GetMessage(&msg, NULL, 0, 0)) && !DialogDone) {
if(msg.message == WM_KEYDOWN) {
if(msg.wParam == VK_TAB && GetFocus() == CommentTextbox) {
SetFocus(OkButton);
continue;
} else if(msg.wParam == VK_ESCAPE) {
DialogDone = TRUE;
DialogCancel = TRUE;
break;
}
}
if(IsDialogMessage(CommentDialog, &msg)) continue;
TranslateMessage(&msg);
DispatchMessage(&msg);
}
if(!DialogCancel) {
SendMessage(CommentTextbox, WM_GETTEXT, (WPARAM)(MAX_COMMENT_LEN-1),
(LPARAM)comment);
}
EnableWindow(MainWindow, TRUE);
DestroyWindow(CommentDialog);
return;
}
void ShowIoDialog(int item)
{
if(!Prog.mcu) {
MessageBox(MainWindow,
_("No microcontroller has been selected. You must select a "
"microcontroller before you can assign I/O pins.\r\n\r\n"
"Select a microcontroller under the Settings menu and try "
"again."), _("I/O Pin Assignment"), MB_OK | MB_ICONWARNING);
return;
}
if(Prog.mcu->whichIsa == ISA_ANSIC) {
Error(_("Can't specify I/O assignment for ANSI C target; compile and "
"see comments in generated source code."));
return;
}
if(Prog.mcu->whichIsa == ISA_INTERPRETED) {
Error(_("Can't specify I/O assignment for interpretable target; see "
"comments in reference implementation of interpreter."));
return;
}
if(Prog.io.assignment[item].name[0] != 'X' &&
Prog.io.assignment[item].name[0] != 'Y' &&
Prog.io.assignment[item].name[0] != 'A')
{
Error(_("Can only assign pin number to input/output pins (Xname or "
"Yname or Aname)."));
return;
}
if(Prog.io.assignment[item].name[0] == 'A' && Prog.mcu->adcCount == 0) {
Error(_("No ADC or ADC not supported for this micro."));
return;
}
if(strcmp(Prog.io.assignment[item].name+1, "new")==0) {
Error(_("Rename I/O from default name ('%s') before assigning "
"MCU pin."), Prog.io.assignment[item].name);
return;
}
MakeWindowClass();
// We need the TOOLWINDOW style, or else the window will be forced to
// a minimum width greater than our current width. And without the
// APPWINDOW style, it becomes impossible to get the window back (by
// Alt+Tab or taskbar).
IoDialog = CreateWindowClient(WS_EX_TOOLWINDOW | WS_EX_APPWINDOW,
"LDmicroIo", _("I/O Pin"),
WS_OVERLAPPED | WS_SYSMENU,
100, 100, 107, 387, NULL, NULL, Instance, NULL);
MakeControls();
SendMessage(PinList, LB_ADDSTRING, 0, (LPARAM)_("(no pin)"));
int i;
for(i = 0; i < Prog.mcu->pinCount; i++) {
int j;
for(j = 0; j < Prog.io.count; j++) {
if(j == item) continue;
if(Prog.io.assignment[j].pin == Prog.mcu->pinInfo[i].pin) {
goto cant_use_this_io;
}
}
if(UartFunctionUsed() && Prog.mcu &&
((Prog.mcu->pinInfo[i].pin == Prog.mcu->uartNeeds.rxPin) ||
(Prog.mcu->pinInfo[i].pin == Prog.mcu->uartNeeds.txPin)))
{
goto cant_use_this_io;
}
if(PwmFunctionUsed() &&
Prog.mcu->pinInfo[i].pin == Prog.mcu->pwmNeedsPin)
{
goto cant_use_this_io;
}
if(Prog.io.assignment[item].name[0] == 'A') {
for(j = 0; j < Prog.mcu->adcCount; j++) {
if(Prog.mcu->adcInfo[j].pin == Prog.mcu->pinInfo[i].pin) {
// okay; we know how to connect it up to the ADC
break;
}
}
if(j == Prog.mcu->adcCount) {
goto cant_use_this_io;
}
}
char buf[40];
if(Prog.mcu->pinCount <= 21) {
sprintf(buf, "%3d %c%c%d", Prog.mcu->pinInfo[i].pin,
Prog.mcu->portPrefix, Prog.mcu->pinInfo[i].port,
Prog.mcu->pinInfo[i].bit);
} else {
sprintf(buf, "%3d %c%c%d", Prog.mcu->pinInfo[i].pin,
Prog.mcu->portPrefix, Prog.mcu->pinInfo[i].port,
Prog.mcu->pinInfo[i].bit);
}
SendMessage(PinList, LB_ADDSTRING, 0, (LPARAM)buf);
cant_use_this_io:;
}
EnableWindow(MainWindow, FALSE);
ShowWindow(IoDialog, TRUE);
SetFocus(PinList);
MSG msg;
DWORD ret;
DialogDone = FALSE;
DialogCancel = FALSE;
while((ret = GetMessage(&msg, NULL, 0, 0)) && !DialogDone) {
if(msg.message == WM_KEYDOWN) {
if(msg.wParam == VK_RETURN) {
DialogDone = TRUE;
break;
} else if(msg.wParam == VK_ESCAPE) {
DialogDone = TRUE;
DialogCancel = TRUE;
break;
}
}
if(IsDialogMessage(IoDialog, &msg)) continue;
TranslateMessage(&msg);
DispatchMessage(&msg);
}
if(!DialogCancel) {
int sel = SendMessage(PinList, LB_GETCURSEL, 0, 0);
char pin[16];
SendMessage(PinList, LB_GETTEXT, (WPARAM)sel, (LPARAM)pin);
if(strcmp(pin, _("(no pin)"))==0) {
int i;
for(i = 0; i < IoSeenPreviouslyCount; i++) {
if(strcmp(IoSeenPreviously[i].name,
Prog.io.assignment[item].name)==0)
{
IoSeenPreviously[i].pin = NO_PIN_ASSIGNED;
}
}
Prog.io.assignment[item].pin = NO_PIN_ASSIGNED;
} else {
Prog.io.assignment[item].pin = atoi(pin);
// Only one name can be bound to each pin; make sure that there's
// not another entry for this pin in the IoSeenPreviously list,
// that might get used if the user creates a new pin with that
// name.
int i;
for(i = 0; i < IoSeenPreviouslyCount; i++) {
if(IoSeenPreviously[i].pin == atoi(pin)) {
IoSeenPreviously[i].pin = NO_PIN_ASSIGNED;
}
}
}
}
EnableWindow(MainWindow, TRUE);
DestroyWindow(IoDialog);
return;
}
//-----------------------------------------------------------------------------
// A little toolbar-style window that pops up to allow the user to set the
// simulated value of an ADC pin.
//-----------------------------------------------------------------------------
void ShowAnalogSliderPopup(char *name)
{
WNDCLASSEX wc;
memset(&wc, 0, sizeof(wc));
wc.cbSize = sizeof(wc);
wc.style = CS_BYTEALIGNCLIENT | CS_BYTEALIGNWINDOW | CS_OWNDC |
CS_DBLCLKS;
wc.lpfnWndProc = (WNDPROC)AnalogSliderDialogProc;
wc.hInstance = Instance;
wc.hbrBackground = (HBRUSH)COLOR_BTNSHADOW;
wc.lpszClassName = "LDmicroAnalogSlider";
wc.lpszMenuName = NULL;
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
RegisterClassEx(&wc);
POINT pt;
GetCursorPos(&pt);
SWORD currentVal = GetAdcShadow(name);
SWORD maxVal;
if(Prog.mcu) {
maxVal = Prog.mcu->adcMax;
} else {
maxVal = 1023;
}
if(maxVal == 0) {
Error(_("No ADC or ADC not supported for selected micro."));
return;
}
int left = pt.x - 10;
// try to put the slider directly under the cursor (though later we might
// realize that that would put the popup off the screen)
int top = pt.y - (15 + (73*currentVal)/maxVal);
RECT r;
SystemParametersInfo(SPI_GETWORKAREA, 0, &r, 0);
if(top + 110 >= r.bottom) {
top = r.bottom - 110;
}
if(top < 0) top = 0;
AnalogSliderMain = CreateWindowClient(0, "LDmicroAnalogSlider", "I/O Pin",
WS_VISIBLE | WS_POPUP | WS_DLGFRAME,
left, top, 30, 100, NULL, NULL, Instance, NULL);
AnalogSliderTrackbar = CreateWindowEx(0, TRACKBAR_CLASS, "", WS_CHILD |
TBS_AUTOTICKS | TBS_VERT | TBS_TOOLTIPS | WS_CLIPSIBLINGS | WS_VISIBLE,
0, 0, 30, 100, AnalogSliderMain, NULL, Instance, NULL);
SendMessage(AnalogSliderTrackbar, TBM_SETRANGE, FALSE,
MAKELONG(0, maxVal));
SendMessage(AnalogSliderTrackbar, TBM_SETTICFREQ, (maxVal + 1)/8, 0);
SendMessage(AnalogSliderTrackbar, TBM_SETPOS, TRUE, currentVal);
EnableWindow(MainWindow, FALSE);
ShowWindow(AnalogSliderMain, TRUE);
SetFocus(AnalogSliderTrackbar);
DWORD ret;
MSG msg;
AnalogSliderDone = FALSE;
AnalogSliderCancel = FALSE;
SWORD orig = GetAdcShadow(name);
while(!AnalogSliderDone && (ret = GetMessage(&msg, NULL, 0, 0))) {
SWORD v = (SWORD)SendMessage(AnalogSliderTrackbar, TBM_GETPOS, 0, 0);
if(msg.message == WM_KEYDOWN) {
if(msg.wParam == VK_RETURN) {
AnalogSliderDone = TRUE;
break;
} else if(msg.wParam == VK_ESCAPE) {
AnalogSliderDone = TRUE;
AnalogSliderCancel = TRUE;
break;
}
} else if(msg.message == WM_LBUTTONUP) {
if(v != orig) {
AnalogSliderDone = TRUE;
}
}
SetAdcShadow(name, v);
TranslateMessage(&msg);
DispatchMessage(&msg);
}
if(!AnalogSliderCancel) {
SWORD v = (SWORD)SendMessage(AnalogSliderTrackbar, TBM_GETPOS, 0, 0);
SetAdcShadow(name, v);
}
EnableWindow(MainWindow, TRUE);
DestroyWindow(AnalogSliderMain);
ListView_RedrawItems(IoList, 0, Prog.io.count - 1);
}
BOOL ShowSimpleDialog(char *title, int boxes, char **labels, DWORD numOnlyMask,
DWORD alnumOnlyMask, DWORD fixedFontMask, char **dests)
{
BOOL didCancel;
if(boxes > MAX_BOXES) oops();
SimpleDialog = CreateWindowClient(0, "LDmicroDialog", title,
WS_OVERLAPPED | WS_SYSMENU,
100, 100, 304, 15 + 30*(boxes < 2 ? 2 : boxes), NULL, NULL,
Instance, NULL);
MakeControls(boxes, labels, fixedFontMask);
int i;
for(i = 0; i < boxes; i++) {
SendMessage(Textboxes[i], WM_SETTEXT, 0, (LPARAM)dests[i]);
if(numOnlyMask & (1 << i)) {
PrevNumOnlyProc[i] = SetWindowLongPtr(Textboxes[i], GWLP_WNDPROC,
(LONG_PTR)MyNumOnlyProc);
}
if(alnumOnlyMask & (1 << i)) {
PrevAlnumOnlyProc[i] = SetWindowLongPtr(Textboxes[i], GWLP_WNDPROC,
(LONG_PTR)MyAlnumOnlyProc);
}
}
EnableWindow(MainWindow, FALSE);
ShowWindow(SimpleDialog, TRUE);
SetFocus(Textboxes[0]);
SendMessage(Textboxes[0], EM_SETSEL, 0, -1);
MSG msg;
DWORD ret;
DialogDone = FALSE;
DialogCancel = FALSE;
while((ret = GetMessage(&msg, NULL, 0, 0)) && !DialogDone) {
if(msg.message == WM_KEYDOWN) {
if(msg.wParam == VK_RETURN) {
DialogDone = TRUE;
break;
} else if(msg.wParam == VK_ESCAPE) {
DialogDone = TRUE;
DialogCancel = TRUE;
break;
}
}
if(IsDialogMessage(SimpleDialog, &msg)) continue;
TranslateMessage(&msg);
DispatchMessage(&msg);
}
didCancel = DialogCancel;
if(!didCancel) {
for(i = 0; i < boxes; i++) {
if(NoCheckingOnBox[i]) {
char get[64];
SendMessage(Textboxes[i], WM_GETTEXT, 60, (LPARAM)get);
strcpy(dests[i], get);
} else {
char get[20];
SendMessage(Textboxes[i], WM_GETTEXT, 15, (LPARAM)get);
if( (!strchr(get, '\'')) ||
(get[0] == '\'' && get[2] == '\'' && strlen(get)==3) )
{
if(strlen(get) == 0) {
Error(_("Empty textbox; not permitted."));
} else {
strcpy(dests[i], get);
}
} else {
Error(_("Bad use of quotes: <%s>"), get);
}
}
}
}
EnableWindow(MainWindow, TRUE);
DestroyWindow(SimpleDialog);
return !didCancel;
}
void SolveSpace::DoMessageBox(const char *str, int rows, int cols, bool error)
{
EnableWindow(GraphicsWnd, false);
EnableWindow(TextWnd, false);
//HWND h = GetForegroundWindow();
// Register the window class for our dialog.
WNDCLASSEX wc;
memset(&wc, 0, sizeof(wc));
wc.cbSize = sizeof(wc);
wc.style = CS_BYTEALIGNCLIENT | CS_BYTEALIGNWINDOW | CS_OWNDC;
wc.lpfnWndProc = (WNDPROC)MessageProc;
wc.hInstance = Instance;
wc.hbrBackground = (HBRUSH)COLOR_BTNSHADOW;
wc.lpszClassName = "MessageWnd";
wc.lpszMenuName = NULL;
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hIcon = (HICON)LoadImage(Instance, MAKEINTRESOURCE(4000),
IMAGE_ICON, 32, 32, 0);
wc.hIconSm = (HICON)LoadImage(Instance, MAKEINTRESOURCE(4000),
IMAGE_ICON, 16, 16, 0);
RegisterClassEx(&wc);
// Create the window.
MessageString = str;
RECT r;
GetWindowRect(GraphicsWnd, &r);
const char *title = error ? "SolveSpace - Error" : "SolveSpace - Message";
int width = cols*SS.TW.CHAR_WIDTH + 20,
height = rows*SS.TW.LINE_HEIGHT + 60;
MessageWnd = CreateWindowClient(0, "MessageWnd", title,
WS_OVERLAPPED | WS_SYSMENU,
r.left + 100, r.top + 100, width, height, NULL, NULL, Instance, NULL);
OkButton = CreateWindowEx(0, WC_BUTTON, "OK",
WS_CHILD | WS_TABSTOP | WS_CLIPSIBLINGS | WS_VISIBLE | BS_DEFPUSHBUTTON,
(width - 70)/2, rows*SS.TW.LINE_HEIGHT + 20,
70, 25, MessageWnd, NULL, Instance, NULL);
SendMessage(OkButton, WM_SETFONT, (WPARAM)FixedFont, true);
ShowWindow(MessageWnd, true);
SetFocus(OkButton);
MSG msg;
DWORD ret;
MessageDone = false;
while((ret = GetMessage(&msg, NULL, 0, 0)) != 0 && !MessageDone) {
if((msg.message == WM_KEYDOWN &&
(msg.wParam == VK_RETURN ||
msg.wParam == VK_ESCAPE)) ||
(msg.message == WM_KEYUP &&
(msg.wParam == VK_SPACE)))
{
MessageDone = true;
break;
}
TranslateMessage(&msg);
DispatchMessage(&msg);
}
MessageString = NULL;
EnableWindow(TextWnd, true);
EnableWindow(GraphicsWnd, true);
SetForegroundWindow(GraphicsWnd);
DestroyWindow(MessageWnd);
}
//-----------------------------------------------------------------------------
// Show the piecewise linear table dialog. This one can only be edited in
// only a single format, which makes things easier than before.
//-----------------------------------------------------------------------------
void ShowPiecewiseLinearDialog(ElemLeaf *l)
{
ElemPiecewiseLinear *t = &(l->d.piecewiseLinear);
// First copy over all the stuff from the leaf structure; in particular,
// we need our own local copy of the table entries, because it would be
// bad to update those in the leaf before the user clicks okay (as he
// might cancel).
int count = t->count;
memset(ValuesCache, 0, sizeof(ValuesCache));
int i;
for(i = 0; i < count*2; i++) {
ValuesCache[i] = t->vals[i];
}
// Now create the dialog's fixed controls, plus the changing (depending
// on show style/entry count) controls for the initial configuration.
LutDialog = CreateWindowClient(0, "LDmicroDialog",
_("Piecewise Linear Table"), WS_OVERLAPPED | WS_SYSMENU,
100, 100, 320, 375, NULL, NULL, Instance, NULL);
MakeFixedControls(TRUE);
MakeLutControls(FALSE, count*2, TRUE);
// Set up the controls to reflect the initial configuration.
SendMessage(DestTextbox, WM_SETTEXT, 0, (LPARAM)(t->dest));
SendMessage(IndexTextbox, WM_SETTEXT, 0, (LPARAM)(t->index));
char buf[30];
sprintf(buf, "%d", t->count);
SendMessage(CountTextbox, WM_SETTEXT, 0, (LPARAM)buf);
// And show the window
EnableWindow(MainWindow, FALSE);
ShowWindow(LutDialog, TRUE);
SetFocus(DestTextbox);
SendMessage(DestTextbox, EM_SETSEL, 0, -1);
MSG msg;
DWORD ret;
DialogDone = FALSE;
DialogCancel = FALSE;
while((ret = GetMessage(&msg, NULL, 0, 0)) && !DialogDone) {
if(msg.message == WM_KEYDOWN) {
if(msg.wParam == VK_RETURN) {
DialogDone = TRUE;
break;
} else if(msg.wParam == VK_ESCAPE) {
DialogDone = TRUE;
DialogCancel = TRUE;
break;
}
}
if(!IsDialogMessage(LutDialog, &msg)) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
// Watch the (user-editable) count field, and use that to
// determine how many textboxes to show.
char buf[20];
SendMessage(CountTextbox, WM_GETTEXT, (WPARAM)16, (LPARAM)buf);
if(atoi(buf) != count) {
count = atoi(buf);
if(count < 0 || count > 10) {
count = 0;
SendMessage(CountTextbox, WM_SETTEXT, 0, (LPARAM)"");
}
DestroyLutControls();
MakeLutControls(FALSE, count*2, TRUE);
}
}
if(!DialogCancel) {
SendMessage(DestTextbox, WM_GETTEXT, (WPARAM)16, (LPARAM)(t->dest));
SendMessage(IndexTextbox, WM_GETTEXT, (WPARAM)16, (LPARAM)(t->index));
DestroyLutControls();
// The call to DestroyLutControls updated ValuesCache, so just read
// them out of there.
int i;
for(i = 0; i < count*2; i++) {
t->vals[i] = ValuesCache[i];
}
t->count = count;
}
EnableWindow(MainWindow, TRUE);
DestroyWindow(LutDialog);
}
//-----------------------------------------------------------------------------
// Show the look-up table dialog. This one is nasty, mostly because there are
// two ways to enter a look-up table: as a table, or as a string. Presumably
// I should convert between those two representations on the fly, as the user
// edit things, so I do.
//-----------------------------------------------------------------------------
void ShowLookUpTableDialog(ElemLeaf *l)
{
ElemLookUpTable *t = &(l->d.lookUpTable);
// First copy over all the stuff from the leaf structure; in particular,
// we need our own local copy of the table entries, because it would be
// bad to update those in the leaf before the user clicks okay (as he
// might cancel).
int count = t->count;
BOOL asString = t->editAsString;
memset(ValuesCache, 0, sizeof(ValuesCache));
int i;
for(i = 0; i < count; i++) {
ValuesCache[i] = t->vals[i];
}
// Now create the dialog's fixed controls, plus the changing (depending
// on show style/entry count) controls for the initial configuration.
LutDialog = CreateWindowClient(0, "LDmicroDialog",
_("Look-Up Table"), WS_OVERLAPPED | WS_SYSMENU,
100, 100, 320, 375, NULL, NULL, Instance, NULL);
MakeFixedControls(FALSE);
MakeLutControls(asString, count, FALSE);
// Set up the controls to reflect the initial configuration.
SendMessage(DestTextbox, WM_SETTEXT, 0, (LPARAM)(t->dest));
SendMessage(IndexTextbox, WM_SETTEXT, 0, (LPARAM)(t->index));
char buf[30];
sprintf(buf, "%d", t->count);
SendMessage(CountTextbox, WM_SETTEXT, 0, (LPARAM)buf);
if(asString) {
SendMessage(AsStringCheckbox, BM_SETCHECK, BST_CHECKED, 0);
}
// And show the window
EnableWindow(MainWindow, FALSE);
ShowWindow(LutDialog, TRUE);
SetFocus(DestTextbox);
SendMessage(DestTextbox, EM_SETSEL, 0, -1);
char PrevTableAsString[1024] = "";
MSG msg;
DWORD ret;
DialogDone = FALSE;
DialogCancel = FALSE;
while((ret = GetMessage(&msg, NULL, 0, 0)) && !DialogDone) {
if(msg.message == WM_KEYDOWN) {
if(msg.wParam == VK_RETURN) {
DialogDone = TRUE;
break;
} else if(msg.wParam == VK_ESCAPE) {
DialogDone = TRUE;
DialogCancel = TRUE;
break;
}
}
if(!IsDialogMessage(LutDialog, &msg)) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
// Are we in table mode? In that case watch the (user-editable) count
// field, and use that to determine how many textboxes to show.
char buf[20];
SendMessage(CountTextbox, WM_GETTEXT, (WPARAM)16, (LPARAM)buf);
if(atoi(buf) != count && !asString) {
count = atoi(buf);
if(count < 0 || count > 32) {
count = 0;
SendMessage(CountTextbox, WM_SETTEXT, 0, (LPARAM)"");
}
DestroyLutControls();
MakeLutControls(asString, count, FALSE);
}
// Are we in string mode? In that case watch the string textbox,
// and use that to update the (read-only) count field.
if(asString) {
char scratch[1024];
SendMessage(StringTextbox, WM_GETTEXT, (WPARAM)sizeof(scratch),
(LPARAM)scratch);
if(strcmp(scratch, PrevTableAsString)!=0) {
if(StringToValuesCache(scratch, &count)) {
strcpy(PrevTableAsString, scratch);
} else {
// Too long; put back the old one
SendMessage(StringTextbox, WM_SETTEXT, 0,
(LPARAM)PrevTableAsString);
}
}
}
// Did we just change modes?
BOOL x = SendMessage(AsStringCheckbox, BM_GETCHECK, 0, 0)==BST_CHECKED;
if((x && !asString) || (!x && asString)) {
asString = x;
DestroyLutControls();
MakeLutControls(asString, count, FALSE);
}
}
if(!DialogCancel) {
SendMessage(DestTextbox, WM_GETTEXT, (WPARAM)16, (LPARAM)(t->dest));
SendMessage(IndexTextbox, WM_GETTEXT, (WPARAM)16, (LPARAM)(t->index));
DestroyLutControls();
// The call to DestroyLutControls updated ValuesCache, so just read
// them out of there (whichever mode we were in before).
int i;
for(i = 0; i < count; i++) {
t->vals[i] = ValuesCache[i];
}
t->count = count;
t->editAsString = asString;
}
EnableWindow(MainWindow, TRUE);
DestroyWindow(LutDialog);
}
void ShowConfDialog(void)
{
// The window's height will be resized later, to fit the explanation text.
ConfDialog = CreateWindowClient(0, "LDmicroDialog", _("PLC Configuration"),
WS_OVERLAPPED | WS_SYSMENU,
100, 100, 0, 0, NULL, NULL, Instance, NULL);
MakeControls();
char buf[16];
sprintf(buf, "%.1f", (Prog.cycleTime / 1000.0));
SendMessage(CycleTextbox, WM_SETTEXT, 0, (LPARAM)buf);
sprintf(buf, "%.6f", Prog.mcuClock / 1e6);
SendMessage(CrystalTextbox, WM_SETTEXT, 0, (LPARAM)buf);
sprintf(buf, "%d", Prog.baudRate);
SendMessage(BaudTextbox, WM_SETTEXT, 0, (LPARAM)buf);
EnableWindow(MainWindow, FALSE);
ShowWindow(ConfDialog, TRUE);
SetFocus(CycleTextbox);
MSG msg;
DWORD ret;
DialogDone = FALSE;
DialogCancel = FALSE;
while((ret = GetMessage(&msg, NULL, 0, 0)) && !DialogDone) {
if(msg.message == WM_KEYDOWN) {
if(msg.wParam == VK_RETURN) {
DialogDone = TRUE;
break;
} else if(msg.wParam == VK_ESCAPE) {
DialogDone = TRUE;
DialogCancel = TRUE;
break;
}
}
if(IsDialogMessage(ConfDialog, &msg)) continue;
TranslateMessage(&msg);
DispatchMessage(&msg);
}
if(!DialogCancel) {
char buf[16];
SendMessage(CycleTextbox, WM_GETTEXT, (WPARAM)sizeof(buf),
(LPARAM)(buf));
Prog.cycleTime = (int)(1000*atof(buf) + 0.5);
if(Prog.cycleTime == 0) {
Error(_("Zero cycle time not valid; resetting to 10 ms."));
Prog.cycleTime = 10000;
}
SendMessage(CrystalTextbox, WM_GETTEXT, (WPARAM)sizeof(buf),
(LPARAM)(buf));
Prog.mcuClock = (int)(1e6*atof(buf) + 0.5);
SendMessage(BaudTextbox, WM_GETTEXT, (WPARAM)sizeof(buf),
(LPARAM)(buf));
Prog.baudRate = atoi(buf);
}
EnableWindow(MainWindow, TRUE);
DestroyWindow(ConfDialog);
return;
}
void ShowCoilDialog(BOOL *negated, BOOL *setOnly, BOOL *resetOnly, BOOL *ttrigger, char *name)
{
char nameSave[MAX_NAME_LEN];
strcpy(nameSave, name);
CoilDialog = CreateWindowClient(0, "LDmicroDialog",
_("Coil"), WS_OVERLAPPED | WS_SYSMENU,
100, 100, 375, 135, NULL, NULL, Instance, NULL);
RECT r;
GetClientRect(CoilDialog, &r);
MakeControls();
switch (name[0]) {
case 'R':
SendMessage(SourceInternalRelayRadio, BM_SETCHECK, BST_CHECKED, 0);
break;
case 'Y':
SendMessage(SourceMcuPinRadio, BM_SETCHECK, BST_CHECKED, 0);
break;
case 'M':
SendMessage(SourceModbusRadio, BM_SETCHECK, BST_CHECKED, 0);
break;
default:
oops();
break;
}
SendMessage(NameTextbox, WM_SETTEXT, 0, (LPARAM)(name + 1));
if(*negated) {
SendMessage(NegatedRadio, BM_SETCHECK, BST_CHECKED, 0);
} else if(*setOnly) {
SendMessage(SetOnlyRadio, BM_SETCHECK, BST_CHECKED, 0);
} else if(*resetOnly) {
SendMessage(ResetOnlyRadio, BM_SETCHECK, BST_CHECKED, 0);
} else if(*ttrigger) {
SendMessage(TtriggerRadio, BM_SETCHECK, BST_CHECKED, 0);
} else {
SendMessage(NormalRadio, BM_SETCHECK, BST_CHECKED, 0);
}
EnableWindow(MainWindow, FALSE);
ShowWindow(CoilDialog, TRUE);
SetFocus(NameTextbox);
SendMessage(NameTextbox, EM_SETSEL, 0, -1);
MSG msg;
DWORD ret;
DialogDone = FALSE;
DialogCancel = FALSE;
while((ret = GetMessage(&msg, NULL, 0, 0)) && !DialogDone) {
if(msg.message == WM_KEYDOWN) {
if(msg.wParam == VK_RETURN) {
DialogDone = TRUE;
break;
} else if(msg.wParam == VK_ESCAPE) {
DialogDone = TRUE;
DialogCancel = TRUE;
break;
}
}
if(IsDialogMessage(CoilDialog, &msg)) continue;
TranslateMessage(&msg);
DispatchMessage(&msg);
}
if(!DialogCancel) {
if(SendMessage(SourceInternalRelayRadio, BM_GETSTATE, 0, 0)
& BST_CHECKED)
{
name[0] = 'R';
} else if (SendMessage(SourceModbusRadio, BM_GETSTATE, 0, 0)
& BST_CHECKED)
{
name[0] = 'M';
} else {
name[0] = 'Y';
}
SendMessage(NameTextbox, WM_GETTEXT, (WPARAM)(MAX_NAME_LEN-1), (LPARAM)(name+1));
if(SendMessage(NormalRadio, BM_GETSTATE, 0, 0) & BST_CHECKED) {
*negated = FALSE;
*setOnly = FALSE;
*resetOnly = FALSE;
*ttrigger = FALSE;
} else if(SendMessage(NegatedRadio, BM_GETSTATE, 0, 0) & BST_CHECKED) {
*negated = TRUE;
*setOnly = FALSE;
*resetOnly = FALSE;
*ttrigger = FALSE;
} else if(SendMessage(SetOnlyRadio, BM_GETSTATE, 0, 0) & BST_CHECKED) {
*negated = FALSE;
*setOnly = TRUE;
*resetOnly = FALSE;
*ttrigger = FALSE;
} else if(SendMessage(ResetOnlyRadio, BM_GETSTATE, 0, 0) & BST_CHECKED) {
*negated = FALSE;
*setOnly = FALSE;
*resetOnly = TRUE;
*ttrigger = FALSE;
} else if(SendMessage(TtriggerRadio, BM_GETSTATE, 0, 0) & BST_CHECKED) {
*negated = FALSE;
*setOnly = FALSE;
*resetOnly = FALSE;
*ttrigger = TRUE;
}
if(strcmp(name, nameSave)) {
int n = CountWhich(ELEM_CONTACTS, ELEM_COIL, nameSave);
if(n >= 1) {
BOOL rename = FALSE;
char str[1000];
sprintf(str, _("Rename the ALL other %d coils/contacts named '%s' to '%s' ?"), n, nameSave, name);
rename = IDYES == MessageBox(MainWindow,
str, "LDmicro",
MB_YESNO | MB_ICONQUESTION);
if(rename)
RenameSet1(ELEM_COIL, nameSave, name, FALSE); // rename and reset
}
}
}
EnableWindow(MainWindow, TRUE);
DestroyWindow(CoilDialog);
return;
}
