+ set (COMPILE_CPP_SOURCES windows.cpp

+ #naminglist.cpp

+ #componentimages.cpp

+ #componentlist.cpp

+ #advanceddialog.cpp

+ arduino.cpp

+ avr.cpp

+ pic16.cpp

+ interpreted.cpp

+ ansic.cpp

+ compilecommon.cpp

+ intcode.cpp

+ lang.cpp

+ miscutil.cpp

+ iolist.cpp

+ #confdialog.cpp

+ #lutdialog.cpp

+ #resetdialog.cpp

+ #simpledialog.cpp

+ #coildialog.cpp

+ #contactsdialog.cpp

+ #commentdialog.cpp

+ #simulate.cpp

+ loadsave.cpp

+ undoredo.cpp

+ circuit.cpp

+ draw_outputdev.cpp

+ #draw.cpp

+ schematic.cpp

+ #helpdialog.cpp

+ maincontrols.cpp

+ ldmicro.cpp)

+

+ add_executable (LDMicro ${COMPILE_CPP_SOURCES})

+ install (TARGETS LDMicro DESTINATION bin)

+ #add_executable (testMain testMain.cpp)

+ target_link_libraries (LDMicro LinuxUI)

+ target_link_libraries (LDMicro FreezeLD)

+ #install (TARGETS testMain DESTINATION bin)

+#include "linuxUI.h"

+#include <linuxUI.h>

+#include <linuxUI.h>

+#include <linuxUI.h>

+#include <linuxUI.h>

+//#include <commctrl.h>

+#include <linuxUI.h>

+//#include <commctrl.h>

+#include <linuxUI.h>

+#include <linuxUI.h>

+//#include <commctrl.h>

+#include <linuxUI.h>

+//#include <commctrl.h>

+// HIMAGELIST ComponentDiagrams;

+// static int ComponentCount;

+// ImageLocation ImageStack[MAX_SCREEN_ITEMS];

+// PinInfo PinStack[MAX_PINS];

+// int ImagesDrawn = 0;

+// int DragIndex = 0;

+// int DragOffsetX = 0;

+// int DragOffsetY = 0;

+// int DragX = 0;

+// int DragY = 0;

+// BOOL Dragging = FALSE;

+// UINT UniqueImgId = 0;

+ // int i;

+ // LVITEM lvi;

+ // for(i = 0; i < TOTAL_COMPONENTS; i++)

+ // {

+ // lvi.mask = LVIF_TEXT | LVIF_PARAM | LVIF_STATE;

+ // lvi.state = lvi.stateMask = 0;

+ // lvi.iItem = i;

+ // lvi.iSubItem = 0;

+ // lvi.pszText = rgCompData[i].ComponentName;

+ // lvi.lParam = rgCompData[i].Index;

+ // if(ListView_InsertItem(ComponentList, &lvi) < 0) oops();

+ // }

+ // switch(h->code) {

+ // case LVN_ITEMACTIVATE:

+ // {

+ // int Img, Index;

+ // NMITEMACTIVATE *i = (NMITEMACTIVATE *)h;

+ // LVITEM lvi;

+ // lvi.mask = LVIF_PARAM;

+ // lvi.iItem = ListView_GetNextItem(ComponentList, -1, LVNI_SELECTED);

+ // ListView_GetItem(ComponentList, &lvi);

+ // Index = (int) lvi.lParam;

+ // int CompId = rgCompData[Index].ComponentId;

+ // ImageStack[ImagesDrawn].Image =

+ // (ImageStruct *)AllocImageHeap(sizeof(ImageStruct));

+ // ImageStack[ImagesDrawn].Image->ComponentId = CompId;

+ // ImageStack[ImagesDrawn].Properties =

+ // AllocImageHeap(GetStructSize(CompId));

+ // ImageStack[ImagesDrawn].PinName =

+ // AllocImageHeap(GetNameSize(Index));

+ // ImageStack[ImagesDrawn].Id = ++UniqueImgId;

+ // ImageStack[ImagesDrawn].Index = Index;

+ // Img = InitializeComponentProperties(

+ // ImageStack[ImagesDrawn].Properties, CompId);

+ // InitializeImageList(&ImageStack[ImagesDrawn].Image->Images);

+ // InitializeComponentImage(Img,

+ // &ImageStack[ImagesDrawn].Image->Images);

+ // ImageStack[ImagesDrawn].x = 100;

+ // ImageStack[ImagesDrawn].y = 100;

+ // // RECT TempRect;

+ // // GetWindowRect(AdvancedWorkspace, &TempRect);

+ // InvalidateRect(AdvancedWorkspace, NULL, TRUE);

+

+ // ImagesDrawn++;

+ // // char a[4];

+ // // MessageBox(ComponentList, (LPCTSTR)itoa(lvi.lParam, a, 10), "Info", MB_OK | MB_ICONEXCLAMATION);

+ // // InitializeComponentImage((int)lvi.lParam);

+ // // int *temp;

+ // // temp = (int *)i->lParam;

+ // // MessageBox(ComponentList, (LPCTSTR)itoa(*temp, a, 10), "Info", MB_OK | MB_ICONEXCLAMATION);

+ // //Selection Code Here

+

+ // // test=LoadComponentImage(RELAY_NC);

+ // // if(test ==NULL){

+ // // MessageBox(ComponentList, "Could not load Bitmap!", "Error", MB_OK | MB_ICONEXCLAMATION);

+ // // }

+ // }

+ // break;

+ // default:

+ // break;

+ // }

+ // *il = ImageList_Create(COMPONENT_WIDTH, COMPONENT_HEIGHT, ILC_MASK | ILC_COLOR8, 0, MAX_SCREEN_ITEMS);

+ // if(*il == NULL){

+ // MessageBox(ComponentList, "Could not Initialize ImageList", "Error", MB_OK | MB_ICONEXCLAMATION);

+ // return;

+ // }

+ // InvalidateRect(AdvancedWorkspace, NULL, TRUE);

+ // InitializeComponentImage(Component,(HIMAGELIST*) il);

+ // int i;

+ // for(i = 0; i < ImagesDrawn; i++)

+ // if((((ImageStack[i].x + COMPONENT_WIDTH) > x) && (ImageStack[i].x < x)

+ // && (ImageStack[i].y < y) && ((ImageStack[i].y + COMPONENT_HEIGHT) > y)))

+ // {

+ // // RECT TempRect;

+ // // TempRect.left = ImageStack[i].x;

+ // // TempRect.top = ImageStack[i].y;

+ // // TempRect.right = ImageStack[i].x + 100;

+ // // TempRect.bottom = ImageStack[i].y + 100;

+

+ // DragOffsetX = x - ImageStack[i].x;

+ // DragOffsetY = y - ImageStack[i].y;

+ // DragX = x;

+ // DragY = y;

+

+ // // MessageBox(ComponentList, "Clicked Image", "Error", MB_OK | MB_ICONEXCLAMATION);

+ // ImageList_BeginDrag(ImageStack[i].Image->Images, 0, DragOffsetX, DragOffsetY);

+ // ImageList_SetDragCursorImage(ImageStack[i].Image->Images, 0, 0, 0);

+ // ImageList_DragEnter(AdvancedWorkspace, x, y);

+

+ // // ImageStack[i].x = -200;

+ // // ImageStack[i].y = -200;

+ // // InvalidateRect(AdvancedWorkspace, &TempRect, TRUE);

+ // DragIndex = i;

+ // Dragging = TRUE;

+ // return 0;

+ // }

+ // // HBITMAP temp=(HBITMAP)GetCurrentObject(GetDC(AdvancedWorkspace), OBJ_BITMAP);

+ // // if(temp == NULL)

+ // // {

+ // // MessageBox(ComponentList, "Bitmap Found", "Information", MB_OK | MB_ICONEXCLAMATION);

+ // // }

+ // return 0;

+ // if(Dragging)

+ // {

+ // ImageList_DragMove(x, y);

+ // // ImageStack[DragIndex].x = x - DragOffsetX;

+ // // ImageStack[DragIndex].y = y - DragOffsetY;

+ // // InvalidateRect(AdvancedWorkspace, NULL, TRUE);

+ // }

+ // else

+ // {

+ // SetCursor(LoadCursor(NULL, IDC_ARROW));

+ // }

+ // return 0;

+ // if(Dragging)

+ // {

+ // // HBITMAP TempBM;

+ // // HDC HdcMem2 = GetDC(AdvancedWorkspace);

+ // // HDC HdcMem =GetDC(AdvancedWorkspace);

+ // // RECT TempRect;

+ // // GetWindowRect(AdvancedWorkspace, &TempRect);

+ // ImageList_DragLeave(AdvancedWorkspace);

+ // ImageList_EndDrag();

+ // ImageStack[DragIndex].x = x - DragOffsetX;

+ // ImageStack[DragIndex].y = y - DragOffsetY;

+ // // InvalidateRect(AdvancedWorkspace, &TempRect, TRUE);

+ // InvalidateRect(AdvancedWorkspace, NULL, TRUE);

+ // // TempBM = CreateBitmap(COMPONENT_WIDTH, COMPONENT_HEIGHT, 1, 32, NULL);

+

+ // // BitBlt(HdcMem2, x, y, COMPONENT_WIDTH, COMPONENT_HEIGHT, HdcMem, 100, 100, SRCERASE);

+ // Dragging =FALSE;

+ // return DragIndex;

+ // }

+ // // IMAGEINFO imginfo;

+ // // ImageList_GetImageInfo(ComponentDiagrams,0, &imginfo);

+ // // char vx[4],vy[4];

+ // // itoa(imginfo.rcImage.right,vx,10);

+ // // itoa(imginfo.rcImage.bottom,vy,10);

+ // // MessageBox(ComponentList, _(vx), _(vy), MB_OK | MB_ICONEXCLAMATION);

+ // // imginfo.rcImage.left=x;

+ // // imginfo.rcImage.top=y;

+ // // ImageList_Draw(ComponentDiagrams, 0, GetDC(AdvancedWorkspace), x, y, ILD_TRANSPARENT);

+ // return NULL;

+#include <linuxUI.h>

+//#include <commctrl.h>

+// static HWND ConfDialog;

+// static HWND CrystalTextbox;

+// static HWND CycleTextbox;

+// static HWND BaudTextbox;

+// static LRESULT CALLBACK MyNumberProc(HWND hwnd, UINT msg, WPARAM wParam,

+// LPARAM lParam)

+// {

+// if(msg == WM_CHAR) {

+// if(!(isdigit(wParam) || wParam == '.' || wParam == '\b')) {

+// return 0;

+// }

+// }

+

+// LONG_PTR t;

+// if(hwnd == CrystalTextbox)

+// t = PrevCrystalProc;

+// else if(hwnd == CycleTextbox)

+// t = PrevCycleProc;

+// else if(hwnd == BaudTextbox)

+// t = PrevBaudProc;

+// else

+// oops();

+

+// return CallWindowProc((WNDPROC)t, hwnd, msg, wParam, lParam);

+// }

+

+// static void MakeControls(void)

+// {

+// HWND textLabel = CreateWindowEx(0, WC_STATIC, _("Cycle Time (ms):"),

+// WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE | SS_RIGHT,

+// 5, 13, 145, 21, ConfDialog, NULL, Instance, NULL);

+// NiceFont(textLabel);

+

+// CycleTextbox = CreateWindowEx(WS_EX_CLIENTEDGE, WC_EDIT, "",

+// WS_CHILD | ES_AUTOHSCROLL | WS_TABSTOP | WS_CLIPSIBLINGS | WS_VISIBLE,

+// 155, 12, 85, 21, ConfDialog, NULL, Instance, NULL);

+// NiceFont(CycleTextbox);

+

+// HWND textLabel2 = CreateWindowEx(0, WC_STATIC,

+// _("Crystal Frequency (MHz):"),

+// WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE | SS_RIGHT,

+// 0, 43, 150, 21, ConfDialog, NULL, Instance, NULL);

+// NiceFont(textLabel2);

+

+// CrystalTextbox = CreateWindowEx(WS_EX_CLIENTEDGE, WC_EDIT, "",

+// WS_CHILD | ES_AUTOHSCROLL | WS_TABSTOP | WS_CLIPSIBLINGS | WS_VISIBLE,

+// 155, 42, 85, 21, ConfDialog, NULL, Instance, NULL);

+// NiceFont(CrystalTextbox);

+

+// HWND textLabel3 = CreateWindowEx(0, WC_STATIC, _("UART Baud Rate (bps):"),

+// WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE | SS_RIGHT,

+// 5, 73, 145, 21, ConfDialog, NULL, Instance, NULL);

+// NiceFont(textLabel3);

+

+// BaudTextbox = CreateWindowEx(WS_EX_CLIENTEDGE, WC_EDIT, "",

+// WS_CHILD | ES_AUTOHSCROLL | WS_TABSTOP | WS_CLIPSIBLINGS | WS_VISIBLE,

+// 155, 72, 85, 21, ConfDialog, NULL, Instance, NULL);

+// NiceFont(BaudTextbox);

+

+// if(!UartFunctionUsed()) {

+// EnableWindow(BaudTextbox, FALSE);

+// EnableWindow(textLabel3, FALSE);

+// }

+

+// if(Prog.mcu && (Prog.mcu->whichIsa == ISA_ANSIC ||

+// Prog.mcu->whichIsa == ISA_INTERPRETED))

+// {

+// EnableWindow(CrystalTextbox, FALSE);

+// EnableWindow(textLabel2, FALSE);

+// }

+

+// OkButton = CreateWindowEx(0, WC_BUTTON, _("OK"),

+// WS_CHILD | WS_TABSTOP | WS_CLIPSIBLINGS | WS_VISIBLE | BS_DEFPUSHBUTTON,

+// 258, 11, 70, 23, ConfDialog, NULL, Instance, NULL);

+// NiceFont(OkButton);

+

+// CancelButton = CreateWindowEx(0, WC_BUTTON, _("Cancel"),

+// WS_CHILD | WS_TABSTOP | WS_CLIPSIBLINGS | WS_VISIBLE,

+// 258, 41, 70, 23, ConfDialog, NULL, Instance, NULL);

+// NiceFont(CancelButton);

+

+// char explanation[1024] = "";

+

+// if(UartFunctionUsed()) {

+// if(Prog.mcu && Prog.mcu->uartNeeds.rxPin != 0) {

+// sprintf(explanation,

+// _("Serial (UART) will use pins %d and %d.\r\n\r\n"),

+// Prog.mcu->uartNeeds.rxPin, Prog.mcu->uartNeeds.txPin);

+// } else {

+// strcpy(explanation,

+// _("Please select a micro with a UART.\r\n\r\n"));

+// }

+// } else {

+// strcpy(explanation, _("No serial instructions (UART Send/UART Receive) "

+// "are in use; add one to program before setting baud rate.\r\n\r\n")

+// );

+// }

+

+// strcat(explanation,

+// _("The cycle time for the 'PLC' runtime generated by LDmicro is user-"

+// "configurable. Very short cycle times may not be achievable due "

+// "to processor speed constraints, and very long cycle times may not "

+// "be achievable due to hardware overflows. Cycle times between 10 ms "

+// "and 100 ms will usually be practical.\r\n\r\n"

+// "The compiler must know what speed crystal you are using with the "

+// "micro to convert between timing in clock cycles and timing in "

+// "seconds. A 4 MHz to 20 MHz crystal is typical; check the speed "

+// "grade of the part you are using to determine the maximum allowable "

+// "clock speed before choosing a crystal."));

+

+// HWND textLabel4 = CreateWindowEx(0, WC_STATIC, explanation,

+// WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE,

+// 11, 104, 310, 400, ConfDialog, NULL, Instance, NULL);

+// NiceFont(textLabel4);

+

+// // Measure the explanation string, so that we know how to size our window

+// RECT tr, cr;

+// HDC hdc = CreateCompatibleDC(NULL);

+// SelectObject(hdc, MyNiceFont);

+// SetRect(&tr, 0, 0, 310, 400);

+// DrawText(hdc, explanation, -1, &tr, DT_CALCRECT |

+// DT_LEFT | DT_TOP | DT_WORDBREAK);

+// DeleteDC(hdc);

+// int h = 104 + tr.bottom + 10;

+// SetWindowPos(ConfDialog, NULL, 0, 0, 344, h, SWP_NOMOVE);

+// // h is the desired client height, but SetWindowPos includes title bar;

+// // so fix it up by hand

+// GetClientRect(ConfDialog, &cr);

+// int nh = h + (h - (cr.bottom - cr.top));

+// SetWindowPos(ConfDialog, NULL, 0, 0, 344, nh, SWP_NOMOVE);

+

+

+// PrevCycleProc = SetWindowLongPtr(CycleTextbox, GWLP_WNDPROC,

+// (LONG_PTR)MyNumberProc);

+

+// PrevCrystalProc = SetWindowLongPtr(CrystalTextbox, GWLP_WNDPROC,

+// (LONG_PTR)MyNumberProc);

+

+// PrevBaudProc = SetWindowLongPtr(BaudTextbox, GWLP_WNDPROC,

+// (LONG_PTR)MyNumberProc);

+// }

+

+// 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;

+// }

+#include <linuxUI.h>

+//#include <commctrl.h>

+#include "linuxUI.h"

+ // if(!isFocus(MainWindow) && !CursorDrawn) return;

+ // if(Cursor.left == 0) return;

+ // PlcCursor c;

+ // memcpy(&c, &Cursor, sizeof(c));

+ // c.top -= ScrollYOffset*POS_HEIGHT*FONT_HEIGHT;

+ // c.left -= ScrollXOffset;

+ // if(c.top >= IoListTop) return;

+ // if(c.top + c.height >= IoListTop) {

+ // c.height = IoListTop - c.top - 3;

+ // }

+ // Hdc = GetDC(MainWindow);

+ // SelectObject(Hdc, GetStockObject(WHITE_BRUSH));

+ // PatBlt(Hdc, c.left, c.top, c.width, c.height, PATINVERT);

+ // CursorDrawn = !CursorDrawn;

+ // ReleaseDC(MainWindow, Hdc);

+ // cy -= ScrollYOffset*POS_HEIGHT;

+ // if(cy < -2) return;

+ // if(cy*FONT_HEIGHT + Y_PADDING > IoListTop) return;

+

+ // COLORREF prev;

+ // BOOL firstTime = TRUE;

+ // BOOL inNumber = FALSE;

+ // BOOL inComment = FALSE;

+ // int inBrace = 0;

+ // for(; *str; str++, cx++) {

+ // int x = cx*FONT_WIDTH + X_PADDING;

+ // int y = cy*FONT_HEIGHT + Y_PADDING;

+

+ // BOOL hiOk = !(InSimulationMode || ThisHighlighted);

+

+ // if(strchr("{}[]", *str) && hiOk && !inComment) {

+ // if(*str == '{' || *str == '[') inBrace++;

+ // if(inBrace == 1) {

+ // prev = GetTextColor(Hdc);

+ // SetTextColor(Hdc, HighlightColours.punct);

+ // TextOut(Hdc, x, y, str, 1);

+ // SetTextColor(Hdc, prev);

+ // } else {

+ // TextOut(Hdc, x, y, str, 1);

+ // }

+ // if(*str == ']' || *str == '}') inBrace--;

+ // } else if((

+ // (isdigit(*str) && (firstTime || isspace(str[-1])

+ // || str[-1] == ':' || str[-1] == '[')) ||

+ // (*str == '-' && isdigit(str[1]))) && hiOk && !inComment)

+ // {

+ // prev = GetTextColor(Hdc);

+ // SetTextColor(Hdc, HighlightColours.lit);

+ // TextOut(Hdc, x, y, str, 1);

+ // SetTextColor(Hdc, prev);

+ // inNumber = TRUE;

+ // } else if(*str == '\x01') {

+ // cx--;

+ // if(hiOk) {

+ // prev = GetTextColor(Hdc);

+ // SetTextColor(Hdc, HighlightColours.op);

+ // }

+ // } else if(*str == '\x02') {

+ // cx--;

+ // if(hiOk) {

+ // SetTextColor(Hdc, prev);

+ // inComment = FALSE;

+ // }

+ // } else if(*str == '\x03') {

+ // cx--;

+ // if(hiOk) {

+ // prev = GetTextColor(Hdc);

+ // SetTextColor(Hdc, HighlightColours.comment);

+ // inComment = TRUE;

+ // }

+ // } else if(inNumber) {

+ // if(isdigit(*str) || *str == '.') {

+ // prev = GetTextColor(Hdc);

+ // SetTextColor(Hdc, HighlightColours.lit);

+ // TextOut(Hdc, x, y, str, 1);

+ // SetTextColor(Hdc, prev);

+ // } else {

+ // TextOut(Hdc, x, y, str, 1);

+ // inNumber = FALSE;

+ // }

+ // } else {

+ // TextOut(Hdc, x, y, str, 1);

+ // }

+

+ // firstTime = FALSE;

+ // }

+ // RECT r;

+ // GetClientRect(MainWindow, &r);

+ // return (r.right - (X_PADDING + X_RIGHT_PADDING)) / (POS_WIDTH*FONT_WIDTH);

+ // int adj;

+ // if(ScrollXOffsetMax == 0) {

+ // adj = 0;

+ // } else {

+ // adj = 18;

+ // }

+ // return (IoListTop - Y_PADDING - adj) / (POS_HEIGHT*FONT_HEIGHT);

+ // static HBITMAP BackBitmap;

+ // static HDC BackDc;

+ // static int BitmapWidth;

+

+ // ok();

+

+ // RECT r;

+ // GetClientRect(MainWindow, &r);

+ // int bw = r.right;

+ // int bh = IoListTop;

+

+ // HDC paintDc;

+ // if(!BackDc) {

+ // HWND desktop = GetDesktopWindow();

+ // RECT dk;

+ // GetClientRect(desktop, &dk);

+

+ // BitmapWidth = max(2000, dk.right + 300);

+ // BackBitmap = CreateCompatibleBitmap(Hdc, BitmapWidth, dk.bottom + 300);

+ // BackDc = CreateCompatibleDC(Hdc);

+ // SelectObject(BackDc, BackBitmap);

+ // }

+ // paintDc = Hdc;

+ // Hdc = BackDc;

+

+ // RECT fi;

+ // fi.left = 0; fi.top = 0;

+ // fi.right = BitmapWidth; fi.bottom = bh;

+ // FillRect(Hdc, &fi, InSimulationMode ? SimBgBrush : BgBrush);

+ // // now figure out how we should draw the ladder logic

+ // ColsAvailable = ProgCountWidestRow();

+ // if(ColsAvailable < ScreenColsAvailable()) {

+ // ColsAvailable = ScreenColsAvailable();

+ // }

+ // memset(DisplayMatrix, 0, sizeof(DisplayMatrix));

+ // SelectionActive = FALSE;

+ // memset(&Cursor, 0, sizeof(Cursor));

+

+ // DrawChars = DrawCharsToScreen;

+

+ // int i;

+ // int cy = 0;

+ // int rowsAvailable = ScreenRowsAvailable();

+ // for(i = 0; i < Prog.numRungs; i++) {

+ // int thisHeight = POS_HEIGHT*CountHeightOfElement(ELEM_SERIES_SUBCKT,

+ // Prog.rungs[i]);

+

+ // // For speed, there is no need to draw everything all the time, but

+ // // we still must draw a bit above and below so that the DisplayMatrix

+ // // is filled in enough to make it possible to reselect using the

+ // // cursor keys.

+ // if(((cy + thisHeight) >= (ScrollYOffset - 8)*POS_HEIGHT) &&

+ // (cy < (ScrollYOffset + rowsAvailable + 8)*POS_HEIGHT))

+ // {

+ // SetBkColor(Hdc, InSimulationMode ? HighlightColours.simBg :

+ // HighlightColours.bg);

+ // SetTextColor(Hdc, InSimulationMode ? HighlightColours.simRungNum :

+ // HighlightColours.rungNum);

+ // SelectObject(Hdc, FixedWidthFont);

+ // int rung = i + 1;

+ // int y = Y_PADDING + FONT_HEIGHT*cy;

+ // int yp = y + FONT_HEIGHT*(POS_HEIGHT/2) -

+ // POS_HEIGHT*FONT_HEIGHT*ScrollYOffset;

+

+ // if(rung < 10) {

+ // char r[1] = { rung + '0' };

+ // TextOut(Hdc, 8 + FONT_WIDTH, yp, r, 1);

+ // } else {

+ // char r[2] = { (rung / 10) + '0', (rung % 10) + '0' };

+ // TextOut(Hdc, 8, yp, r, 2);

+ // }

+

+ // int cx = 0;

+ // DrawElement(ELEM_SERIES_SUBCKT, Prog.rungs[i], &cx, &cy,

+ // Prog.rungPowered[i]);

+ // }

+

+ // cy += thisHeight;

+ // cy += POS_HEIGHT;

+ // }

+ // cy -= 2;

+ // DrawEndRung(0, cy);

+

+ // if(SelectedGxAfterNextPaint >= 0) {

+ // MoveCursorNear(SelectedGxAfterNextPaint, SelectedGyAfterNextPaint);

+ // InvalidateRect(MainWindow, NULL, FALSE);

+ // SelectedGxAfterNextPaint = -1;

+ // SelectedGyAfterNextPaint = -1;

+ // } else if(ScrollSelectedIntoViewAfterNextPaint && Selected) {

+ // SelectElement(-1, -1, Selected->selectedState);

+ // ScrollSelectedIntoViewAfterNextPaint = FALSE;

+ // InvalidateRect(MainWindow, NULL, FALSE);

+ // } else {

+ // if(!SelectionActive) {

+ // if(Prog.numRungs > 0) {

+ // if(MoveCursorTopLeft()) {

+ // InvalidateRect(MainWindow, NULL, FALSE);

+ // }

+ // }

+ // }

+ // }

+

+ // // draw the `buses' at either side of the screen

+ // r.left = X_PADDING - FONT_WIDTH;

+ // r.top = 0;

+ // r.right = r.left + 4;

+ // r.bottom = IoListTop;

+ // FillRect(Hdc, &r, InSimulationMode ? BusLeftBrush : BusBrush);

+

+ // r.left += POS_WIDTH*FONT_WIDTH*ColsAvailable + 2;

+ // r.right += POS_WIDTH*FONT_WIDTH*ColsAvailable + 2;

+ // FillRect(Hdc, &r, InSimulationMode ? BusRightBus : BusBrush);

+ // CursorDrawn = FALSE;

+ // BitBlt(paintDc, 0, 0, bw, bh, BackDc, ScrollXOffset, 0, SRCCOPY);

+ // if(InSimulationMode) {

+ // KillTimer(MainWindow, TIMER_BLINK_CURSOR);

+ // } else {

+ // KillTimer(MainWindow, TIMER_BLINK_CURSOR);

+ // BlinkCursor(NULL, 0, NULL, 0);

+ // SetTimer(MainWindow, TIMER_BLINK_CURSOR, 800, BlinkCursor);

+ // }

+ // Hdc = paintDc;

+ // ok();

+ // SetSyntaxHighlightingColours();

+

+ // FixedWidthFont = CreateFont(

+ // FONT_HEIGHT, FONT_WIDTH,

+ // 0, 0,

+ // FW_REGULAR,

+ // FALSE,

+ // FALSE,

+ // FALSE,

+ // ANSI_CHARSET,

+ // OUT_DEFAULT_PRECIS,

+ // CLIP_DEFAULT_PRECIS,

+ // DEFAULT_QUALITY,

+ // FF_DONTCARE,

+ // "Lucida Console");

+

+ // FixedWidthFontBold = CreateFont(

+ // FONT_HEIGHT, FONT_WIDTH,

+ // 0, 0,

+ // FW_REGULAR, // the bold text renders funny under Vista

+ // FALSE,

+ // FALSE,

+ // FALSE,

+ // ANSI_CHARSET,

+ // OUT_DEFAULT_PRECIS,

+ // CLIP_DEFAULT_PRECIS,

+ // DEFAULT_QUALITY,

+ // FF_DONTCARE,

+ // "Lucida Console");

+

+ // LOGBRUSH lb;

+ // lb.lbStyle = BS_SOLID;

+ // lb.lbColor = HighlightColours.simBusRight;

+ // BusRightBus = CreateBrushIndirect(&lb);

+

+ // lb.lbColor = HighlightColours.simBusLeft;

+ // BusLeftBrush = CreateBrushIndirect(&lb);

+

+ // lb.lbColor = HighlightColours.bus;

+ // BusBrush = CreateBrushIndirect(&lb);

+

+ // lb.lbColor = HighlightColours.bg;

+ // BgBrush = CreateBrushIndirect(&lb);

+

+ // lb.lbColor = HighlightColours.simBg;

+ // SimBgBrush = CreateBrushIndirect(&lb);

+ // int maxWidth = ProgCountWidestRow();

+ // ColsAvailable = maxWidth;

+

+ // int totalHeight = 0;

+ // int i;

+ // for(i = 0; i < Prog.numRungs; i++) {

+ // totalHeight += CountHeightOfElement(ELEM_SERIES_SUBCKT, Prog.rungs[i]);

+ // totalHeight += 1;

+ // }

+ // totalHeight *= POS_HEIGHT;

+ // totalHeight += 3;

+

+ // ExportBuffer = (char **)CheckMalloc(totalHeight * sizeof(char *));

+ // int l = maxWidth*POS_WIDTH + 8;

+ // for(i = 0; i < totalHeight; i++) {

+ // ExportBuffer[i] = (char *)CheckMalloc(l);

+ // memset(ExportBuffer[i], ' ', l-1);

+ // ExportBuffer[i][4] = '|';

+ // ExportBuffer[i][3] = '|';

+ // ExportBuffer[i][l-3] = '|';

+ // ExportBuffer[i][l-2] = '|';

+ // ExportBuffer[i][l-1] = '\0';

+ // }

+

+ // DrawChars = DrawCharsToExportBuffer;

+

+ // int cy = 1;

+ // for(i = 0; i < Prog.numRungs; i++) {

+ // int cx = 5;

+ // DrawElement(ELEM_SERIES_SUBCKT, Prog.rungs[i], &cx, &cy,

+ // Prog.rungPowered[i]);

+

+ // if((i + 1) < 10) {

+ // ExportBuffer[cy+1][1] = '0' + (i + 1);

+ // } else {

+ // ExportBuffer[cy+1][1] = '0' + ((i + 1) % 10);

+ // ExportBuffer[cy+1][0] = '0' + ((i + 1) / 10);

+ // }

+

+ // cy += POS_HEIGHT*CountHeightOfElement(ELEM_SERIES_SUBCKT,

+ // Prog.rungs[i]);

+ // cy += POS_HEIGHT;

+ // }

+ // cy -= 2;

+ // DrawEndRung(5, cy);

+

+ // FILE *f = fopen(file, "w");

+ // if(!f) {

+ // Error(_("Couldn't open '%s'\n"), f);

+ // return;

+ // }

+

+ // fprintf(f, "LDmicro export text\n");

+

+ // if(Prog.mcu) {

+ // fprintf(f, "for '%s', %.6f MHz crystal, %.1f ms cycle time\n\n",

+ // Prog.mcu->mcuName, Prog.mcuClock/1e6, Prog.cycleTime/1e3);

+ // } else {

+ // fprintf(f, "no MCU assigned, %.6f MHz crystal, %.1f ms cycle time\n\n",

+ // Prog.mcuClock/1e6, Prog.cycleTime/1e3);

+ // }

+

+ // fprintf(f, "\nLADDER DIAGRAM:\n\n");

+

+ // for(i = 0; i < totalHeight; i++) {

+ // ExportBuffer[i][4] = '|';

+ // fprintf(f, "%s\n", ExportBuffer[i]);

+ // CheckFree(ExportBuffer[i]);

+ // }

+ // CheckFree(ExportBuffer);

+ // ExportBuffer = NULL;

+

+ // fprintf(f, _("\n\nI/O ASSIGNMENT:\n\n"));

+ // fprintf(f, _(" Name | Type | Pin\n"));

+ // fprintf(f, " ----------------------------+--------------------+------\n");

+ // for(i = 0; i < Prog.io.count; i++) {

+ // char b[1024];

+ // memset(b, '\0', sizeof(b));

+ // PlcProgramSingleIo *io = &Prog.io.assignment[i];

+ // char *type = IoTypeToString(io->type);

+ // char pin[MAX_NAME_LEN];

+ // PinNumberForIo(pin, io);

+ // sprintf(b, " | | %s\n",

+ // pin);

+ // memcpy(b+2, io->name, strlen(io->name));

+ // memcpy(b+31, type, strlen(type));

+ // fprintf(f, "%s", b);

+ // }

+ // fclose(f);

+ // // we may have trashed the grid tables a bit; a repaint will fix that

+ // InvalidateRect(MainWindow, NULL, FALSE);

+ // int totalHeight = 0;

+ // int i;

+ // for(i = 0; i < Prog.numRungs; i++) {

+ // totalHeight += CountHeightOfElement(ELEM_SERIES_SUBCKT, Prog.rungs[i]);

+ // totalHeight++;

+ // }

+ // totalHeight += 1; // for the end rung

+

+ // int totalWidth = ProgCountWidestRow();

+

+ // if(totalWidth <= ScreenColsAvailable()) {

+ // *horizShown = FALSE;

+ // ScrollXOffset = 0;

+ // ScrollXOffsetMax = 0;

+ // } else {

+ // *horizShown = TRUE;

+ // memset(horiz, 0, sizeof(*horiz));

+ // horiz->cbSize = sizeof(*horiz);

+ // horiz->fMask = SIF_DISABLENOSCROLL | SIF_ALL;

+ // horiz->nMin = 0;

+ // horiz->nMax = X_PADDING + totalWidth*POS_WIDTH*FONT_WIDTH;

+ // RECT r;

+ // GetClientRect(MainWindow, &r);

+ // horiz->nPage = r.right - X_PADDING;

+ // horiz->nPos = ScrollXOffset;

+

+ // ScrollXOffsetMax = horiz->nMax - horiz->nPage + 1;

+ // if(ScrollXOffset > ScrollXOffsetMax) ScrollXOffset = ScrollXOffsetMax;

+ // if(ScrollXOffset < 0) ScrollXOffset = 0;

+ // }

+

+ // vert->cbSize = sizeof(*vert);

+ // vert->fMask = SIF_DISABLENOSCROLL | SIF_ALL;

+ // vert->nMin = 0;

+ // vert->nMax = totalHeight - 1;

+ // vert->nPos = ScrollYOffset;

+ // vert->nPage = ScreenRowsAvailable();

+

+ // ScrollYOffsetMax = vert->nMax - vert->nPage + 1;

+

+ // if(ScrollYOffset > ScrollYOffsetMax) ScrollYOffset = ScrollYOffsetMax;

+ // if(ScrollYOffset < 0) ScrollYOffset = 0;

+#include "linuxUI.h"

+//#include <commctrl.h>

+// #ifndef _ADVANCED_DIALOG_H

+// #define _ADVANCED_DIALOG_H

+

+// #define MAX_PIN_NAME 128

+

+// /*Advanced Dialog Menus*/

+// #define MNU_ADV_NEW 0x01

+// #define MNU_ADV_OPEN 0x02

+// #define MNU_ADV_SAVE 0x03

+// #define MNU_ADV_SAVE_AS 0x04

+// #define MNU_ADV_EXIT 0x05

+

+// #define MNU_ADV_UNDO 0x10

+// #define MNU_ADV_REDO 0x11

+// #define MNU_ADV_CUT 0x12

+// #define MNU_ADV_COPY 0x13

+// #define MNU_ADV_PASTE 0x14

+// #define MNU_ADV_DEL 0x15

+

+// #define MNU_ADV_SIMULATION_MODE 0x20

+// #define MNU_ADV_START_SIMULATION 0x21

+// #define MNU_ADV_STOP_SIMULATION 0x22

+// #define MNU_ADV_SINGLE_CYCLE 0x23

+

+// #define MNU_ADV_MANUAL 0x30

+// #define MNU_ADV_ABOUT 0x31

+

+// #define MAX_NAME_LENGTH 128

+// #define MAX_SCREEN_ITEMS 512

+// #define MAX_PINS 4000

+// #define MCU_PIN_FLAG 4000

+// #define MAX_MCU_PINS 128

+// #define TIMER_ADV_SIMULATE 101

+

+

+// typedef struct ImageStructTag {

+// int selectedState;

+// HIMAGELIST Images;

+// int ComponentId;

+// } ImageStruct;

+

+// typedef struct ImageLocationTag{

+// int Id;

+// ImageStruct* Image;

+// int Index;

+// int x;

+// int y;

+// void* Properties;

+// void* PinId;

+// void* PinName;

+// }ImageLocation;

+

+// typedef struct PinInfoTag{

+// double Volt;

+// double OperatingVolt;

+// void** ImageId;

+// int* Index;

+// int* ImageType; //To compare with imagelocation array

+// int LinkCount; //No of valid entries in array

+// double ProgVolt;

+// void* ProgComponent;

+// }PinInfo;

+

+// typedef struct PinMcuTag{

+// UINT PinId;

+// UINT state;

+// int type;

+// BOOL InternalPullup;

+// }PinMcu;

+

+// typedef struct PinNameTag{

+// UINT PinId; //Need to generate unique pinid every time user saves a name

+// TCHAR Name[MAX_NAME_LENGTH];

+// PinInfo PinData;

+// }PinName;

+

+// typedef struct PinComponentTag{

+// UINT PinId;

+// void** ComponentAddress;

+// int Count;

+// void* Next;

+// }PinComponent;

+

+// extern HANDLE ImageHeap;

+// extern HFONT AdvNiceFont;

+// extern HFONT AdvFixedFont;

+// extern UINT NameCount;

+// extern ImageLocation ImageStack[MAX_SCREEN_ITEMS];

+// // extern PinInfo PinData[MAX_PINS];

+// extern PinMcu McuPin[MAX_MCU_PINS];

+// extern PinName NameId[MAX_PINS];

+// extern HWND AdvancedDialog;

+// extern PinComponent ComponentPin;

+

+// /*Advanced Dialog Functions*/

+// void MakeAdvancedDialogControls(void);

+// void AdvancedDialogResized(void);

+// void MakeAdvancedWindowMenus(void);

+// void ProcessEvent(int x, int y, int Event);

+// void AdvancedWindowClosing(void);

+// void ToggleAdvancedSimulationMode(void);

+// void SimulateOneAdvCycle(BOOL ForceRefresh);

+// int IsMCUPin(int PinId);

+// // void CreateVoltRequest(int PinId, int Index, double VoltReq);

+

+// // Heap Functions

+// void* AllocImageHeap(size_t n);

+// void* ReallocImageHeap(LPVOID lpMem, size_t n);

+// void FreeImageHeap(void *p);

+

+// // Component Functions

+

+// void InitComponents(void);

+

+// double GetGlobalVoltage(int PinId, void* ComponentAddress);

+// double RefreshVolt(int PinId, int Index, UINT Id, void* ComponentAddress, double volt);

+// double RefreshProcessorStat(int PinId, UINT Id);

+

+

+// int RegisterPinName(LPCTSTR Name);

+// int SetPinImage(int PinId,void* ImageId,int ImageType, int Index);

+// int FlushPinNames(void); //Clear Pins which are deleted from MainWindow

+// int DeRegisterPinName(LPCTSTR Name, void* ImageId);

+// int DeletePinImage(LPCTSTR Name, void* ImageId, int Index);

+// int DeletePinName(UINT Index);

+// void SetMcu(int PinId, int Type);

+// void RefreshNamingList(void);

+// void PopulateNamingList(void);

+

+// double RequestVoltChange(int PinId, int Index, void *ComponentAddress, double volt);

+

+// int DeleteComponentPin(int PinId, void* ComponentAddress);

+// int AddComponentPin(int PinId, void* ComponentAddress);

+// // int RegisterPinState(int Index, double Volt);

+

+// //NamingList functions

+// void ToggleInternalPullup(int PinId);

+

+

+// extern BOOL SimulationStarted;

+

+// #endif

+

+

+extern HINSTANCE Instance;

+// extern void (*DrawChars)(int, int, char *);

+// void CALLBACK BlinkCursor(HWND hwnd, UINT msg, UINT_PTR id, DWORD time);

+// void PaintWindow(void);

+// void ExportDrawingAsText(char *file);

+// void InitForDrawing(void);

+// void SetUpScrollbars(BOOL *horizShown, SCROLLINFO *horiz, SCROLLINFO *vert);

+// int ScreenRowsAvailable(void);

+// int ScreenColsAvailable(void);

+

+

+#include "linuxUI.h"

+#include "linuxUI.h"

+#include "linuxUI.h"

+//#include <commctrl.h>

+// // stuff for the dialog box that lets you choose pin assignments

+// static BOOL DialogDone;

+// static BOOL DialogCancel;

+// static HWND IoDialog;

+// static HWND PinList;

+// static HWND OkButton;

+// static HWND CancelButton;

+// // stuff for the popup that lets you set the simulated value of an analog in

+// static HWND AnalogSliderMain;

+// static HWND AnalogSliderTrackbar;

+// static BOOL AnalogSliderDone;

+// static BOOL AnalogSliderCancel;

+// static LRESULT CALLBACK AnalogSliderDialogProc(HWND hwnd, UINT msg,

+// WPARAM wParam, LPARAM lParam)

+// {

+// switch (msg) {

+// case WM_CLOSE:

+// case WM_DESTROY:

+// AnalogSliderDone = TRUE;

+// AnalogSliderCancel = TRUE;

+// return 1;

+

+// default:

+// return DefWindowProc(hwnd, msg, wParam, lParam);

+// }

+// }

+// 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);

+// }

+// static LRESULT CALLBACK IoDialogProc(HWND hwnd, UINT msg, WPARAM wParam,

+// LPARAM lParam)

+// {

+// switch (msg) {

+// case WM_COMMAND: {

+// HWND h = (HWND)lParam;

+// if(h == OkButton && wParam == BN_CLICKED) {

+// DialogDone = TRUE;

+// } else if(h == CancelButton && wParam == BN_CLICKED) {

+// DialogDone = TRUE;

+// DialogCancel = TRUE;

+// } else if(h == PinList && HIWORD(wParam) == LBN_DBLCLK) {

+// DialogDone = TRUE;

+// }

+// break;

+// }

+

+// case WM_CLOSE:

+// case WM_DESTROY:

+// DialogDone = TRUE;

+// DialogCancel = TRUE;

+// return 1;

+

+// default:

+// return DefWindowProc(hwnd, msg, wParam, lParam);

+// }

+

+// return 1;

+// }

+// static BOOL MakeWindowClass()

+// {

+// WNDCLASSEX wc;

+// memset(&wc, 0, sizeof(wc));

+// wc.cbSize = sizeof(wc);

+

+// wc.style = CS_BYTEALIGNCLIENT | CS_BYTEALIGNWINDOW | CS_OWNDC |

+// CS_DBLCLKS;

+// wc.lpfnWndProc = (WNDPROC)IoDialogProc;

+// wc.hInstance = Instance;

+// wc.hbrBackground = (HBRUSH)COLOR_BTNSHADOW;

+// wc.lpszClassName = "LDmicroIo";

+// 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);

+

+// return RegisterClassEx(&wc);

+// }

+

+// static void MakeControls(void)

+// {

+// HWND textLabel = CreateWindowEx(0, WC_STATIC, _("Assign:"),

+// WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE,

+// 6, 1, 80, 17, IoDialog, NULL, Instance, NULL);

+// NiceFont(textLabel);

+

+// PinList = CreateWindowEx(WS_EX_CLIENTEDGE, WC_LISTBOX, "",

+// WS_CHILD | WS_TABSTOP | WS_CLIPSIBLINGS | WS_VISIBLE | WS_VSCROLL |

+// LBS_NOTIFY, 6, 18, 95, 320, IoDialog, NULL, Instance, NULL);

+// FixedFont(PinList);

+

+// OkButton = CreateWindowEx(0, WC_BUTTON, _("OK"),

+// WS_CHILD | WS_TABSTOP | WS_CLIPSIBLINGS | WS_VISIBLE | BS_DEFPUSHBUTTON,

+// 6, 325, 95, 23, IoDialog, NULL, Instance, NULL);

+// NiceFont(OkButton);

+

+// CancelButton = CreateWindowEx(0, WC_BUTTON, _("Cancel"),

+// WS_CHILD | WS_TABSTOP | WS_CLIPSIBLINGS | WS_VISIBLE,

+// 6, 356, 95, 23, IoDialog, NULL, Instance, NULL);

+// NiceFont(CancelButton);

+// }

+

+// 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;

+// }

+// void IoListProc(NMHDR *h)

+// {

+// switch(h->code) {

+// case LVN_GETDISPINFO: {

+// NMLVDISPINFO *i = (NMLVDISPINFO *)h;

+// int item = i->item.iItem;

+// switch(i->item.iSubItem) {

+// case LV_IO_PIN:

+// // Don't confuse people by displaying bogus pin assignments

+// // for the C target.

+// if(Prog.mcu && (Prog.mcu->whichIsa == ISA_ANSIC ||

+// Prog.mcu->whichIsa == ISA_INTERPRETED) )

+// {

+// strcpy(i->item.pszText, "");

+// break;

+// }

+

+// PinNumberForIo(i->item.pszText,

+// &(Prog.io.assignment[item]));

+// break;

+

+// case LV_IO_TYPE: {

+// char *s = IoTypeToString(Prog.io.assignment[item].type);

+// strcpy(i->item.pszText, s);

+// break;

+// }

+// case LV_IO_NAME:

+// strcpy(i->item.pszText, Prog.io.assignment[item].name);

+// break;

+

+// case LV_IO_PORT: {

+// // Don't confuse people by displaying bogus pin assignments

+// // for the C target.

+// if(Prog.mcu && Prog.mcu->whichIsa == ISA_ANSIC) {

+// strcpy(i->item.pszText, "");

+// break;

+// }

+

+// int type = Prog.io.assignment[item].type;

+// if(type != IO_TYPE_DIG_INPUT && type != IO_TYPE_DIG_OUTPUT

+// && type != IO_TYPE_READ_ADC)

+// {

+// strcpy(i->item.pszText, "");

+// break;

+// }

+

+// int pin = Prog.io.assignment[item].pin;

+// if(pin == NO_PIN_ASSIGNED || !Prog.mcu) {

+// strcpy(i->item.pszText, "");

+// break;

+// }

+

+// if(UartFunctionUsed() && Prog.mcu) {

+// if((Prog.mcu->uartNeeds.rxPin == pin) ||

+// (Prog.mcu->uartNeeds.txPin == pin))

+// {

+// strcpy(i->item.pszText, _("<UART needs!>"));

+// break;

+// }

+// }

+

+// if(PwmFunctionUsed() && Prog.mcu) {

+// if(Prog.mcu->pwmNeedsPin == pin) {

+// strcpy(i->item.pszText, _("<PWM needs!>"));

+// break;

+// }

+// }

+

+// int j;

+// for(j = 0; j < Prog.mcu->pinCount; j++) {

+// if(Prog.mcu->pinInfo[j].pin == pin) {

+// sprintf(i->item.pszText, "%c%c%d",

+// Prog.mcu->portPrefix,

+// Prog.mcu->pinInfo[j].port,

+// Prog.mcu->pinInfo[j].bit);

+// break;

+// }

+// }

+// if(j == Prog.mcu->pinCount) {

+// sprintf(i->item.pszText, _("<not an I/O!>"));

+// }

+// break;

+// }

+

+// case LV_IO_STATE: {

+// if(InSimulationMode) {

+// char *name = Prog.io.assignment[item].name;

+// DescribeForIoList(name, i->item.pszText);

+// } else {

+// strcpy(i->item.pszText, "");

+// }

+// break;

+// }

+

+// }

+// break;

+// }

+// case LVN_ITEMACTIVATE: {

+// NMITEMACTIVATE *i = (NMITEMACTIVATE *)h;

+// if(InSimulationMode) {

+// char *name = Prog.io.assignment[i->iItem].name;

+// if(name[0] == 'X') {

+// SimulationToggleContact(name);

+// } else if(name[0] == 'A') {

+// ShowAnalogSliderPopup(name);

+// }

+// } else {

+// UndoRemember();

+// ShowIoDialog(i->iItem);

+// ProgramChanged();

+// InvalidateRect(MainWindow, NULL, FALSE);

+// }

+// break;

+// }

+// }

+// }

+#include "linuxUI.h"

+//#include "obj/lang-tables.h"

+#define LDLANG_EN

+#include "linuxUI.h"

+//static HHOOK MouseHookHandle;

+// static BOOL SaveAsDialog(void)

+// {

+// OPENFILENAME ofn;

+

+// memset(&ofn, 0, sizeof(ofn));

+// ofn.lStructSize = sizeof(ofn);

+// ofn.hInstance = Instance;

+// ofn.lpstrFilter = LDMICRO_PATTERN;

+// ofn.lpstrDefExt = "ld";

+// ofn.lpstrFile = CurrentSaveFile;

+// ofn.nMaxFile = sizeof(CurrentSaveFile);

+// ofn.Flags = OFN_PATHMUSTEXIST | OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT;

+

+// if(!GetSaveFileName(&ofn))

+// return FALSE;

+

+// if(!SaveProjectToFile(CurrentSaveFile)) {

+// Error(_("Couldn't write to '%s'."), CurrentSaveFile);

+// return FALSE;

+// } else {

+// ProgramChangedNotSaved = FALSE;

+// return TRUE;

+// }

+// }

+// static void ExportDialog(void)

+// {

+// char exportFile[MAX_PATH];

+// OPENFILENAME ofn;

+// exportFile[0] = '\0';

+// memset(&ofn, 0, sizeof(ofn));

+// ofn.lStructSize = sizeof(ofn);

+// ofn.hInstance = Instance;

+// ofn.lpstrFilter = TXT_PATTERN;

+// ofn.lpstrFile = exportFile;

+// ofn.lpstrTitle = _("Export As Text");

+// ofn.nMaxFile = sizeof(exportFile);

+// ofn.Flags = OFN_PATHMUSTEXIST | OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT;

+// if(!GetSaveFileName(&ofn))

+// return;

+// ExportDrawingAsText(exportFile);

+// }

+// static BOOL SaveProgram(void)

+// {

+// if(strlen(CurrentSaveFile)) {

+// if(!SaveProjectToFile(CurrentSaveFile)) {

+// Error(_("Couldn't write to '%s'."), CurrentSaveFile);

+// return FALSE;

+// } else {

+// ProgramChangedNotSaved = FALSE;

+// return TRUE;

+// }

+// } else {

+// return SaveAsDialog();

+// }

+// }

+// BOOL CheckSaveUserCancels(void)

+// {

+// if(!ProgramChangedNotSaved) {

+// // no problem

+// return FALSE;

+// }

+

+// int r = MessageBox(MainWindow,

+// _("The program has changed since it was last saved.\r\n\r\n"

+// "Do you want to save the changes?"), "LDmicro",

+// MB_YESNOCANCEL | MB_ICONWARNING);

+// switch(r) {

+// case IDYES:

+// if(SaveProgram())

+// return FALSE;

+// else

+// return TRUE;

+

+// case IDNO:

+// return FALSE;

+

+// case IDCANCEL:

+// return TRUE;

+

+// default:

+// oops();

+// }

+// }

+// static void OpenDialog(void)

+// {

+// OPENFILENAME ofn;

+

+// char tempSaveFile[MAX_PATH] = "";

+

+// memset(&ofn, 0, sizeof(ofn));

+// ofn.lStructSize = sizeof(ofn);

+// ofn.hInstance = Instance;

+// ofn.lpstrFilter = LDMICRO_PATTERN;

+// ofn.lpstrDefExt = "ld";

+// ofn.lpstrFile = tempSaveFile;

+// ofn.nMaxFile = sizeof(tempSaveFile);

+// ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST | OFN_HIDEREADONLY;

+

+// if(!GetOpenFileName(&ofn))

+// return;

+

+// if(!LoadProjectFromFile(tempSaveFile)) {

+// Error(_("Couldn't open '%s'."), tempSaveFile);

+// CurrentSaveFile[0] = '\0';

+// } else {

+// ProgramChangedNotSaved = FALSE;

+// strcpy(CurrentSaveFile, tempSaveFile);

+// UndoFlush();

+// }

+

+// GenerateIoListDontLoseSelection();

+// RefreshScrollbars();

+// UpdateMainWindowTitleBar();

+// }

+// void ProgramChanged(void)

+// {

+// ProgramChangedNotSaved = TRUE;

+// GenerateIoListDontLoseSelection();

+// RefreshScrollbars();

+// if(AdvancedWindowOpen)

+// {

+// FlushPinNames();

+// PopulateNamingList();

+// }

+// }

+// #define CHANGING_PROGRAM(x) { \

+// UndoRemember(); \

+// x; \

+// ProgramChanged(); \

+// }

+// static LRESULT CALLBACK MouseHook(int code, WPARAM wParam, LPARAM lParam)

+// {

+// switch(code) {

+// case HC_ACTION: {

+// MSLLHOOKSTRUCT *mhs = (MSLLHOOKSTRUCT *)lParam;

+

+// switch(wParam) {

+// case WM_MOUSEMOVE: {

+// int dy = MouseY - mhs->pt.y;

+// IoListHeight += dy;

+// if(IoListHeight < 50) IoListHeight = 50;

+// MouseY = mhs->pt.y;

+// MainWindowResized();

+

+// break;

+// }

+

+// case WM_LBUTTONUP:

+// UnhookWindowsHookEx(MouseHookHandle);

+// break;

+// }

+// break;

+// }

+// }

+// return CallNextHookEx(MouseHookHandle, code, wParam, lParam);

+// }

+// static void ProcessMenu(int code)

+// {

+// if(code >= MNU_PROCESSOR_0 && code < MNU_PROCESSOR_0+NUM_SUPPORTED_MCUS) {

+// strcpy(CurrentCompileFile, "");

+// Prog.mcu = &SupportedMcus[code - MNU_PROCESSOR_0];

+// RefreshControlsToSettings();

+// return;

+// }

+// if(code == MNU_PROCESSOR_0+NUM_SUPPORTED_MCUS) {

+// Prog.mcu = NULL;

+// strcpy(CurrentCompileFile, "");

+// RefreshControlsToSettings();

+// return;

+// }

+

+// switch(code) {

+// case MNU_NEW:

+// if(CheckSaveUserCancels()) break;

+// NewProgram();

+// strcpy(CurrentSaveFile, "");

+// strcpy(CurrentCompileFile, "");

+// GenerateIoListDontLoseSelection();

+// RefreshScrollbars();

+// UpdateMainWindowTitleBar();

+// break;

+

+// case MNU_OPEN:

+// if(CheckSaveUserCancels()) break;

+// OpenDialog();

+// break;

+

+// case MNU_SAVE:

+// SaveProgram();

+// UpdateMainWindowTitleBar();

+// break;

+

+// case MNU_SAVE_AS:

+// SaveAsDialog();

+// UpdateMainWindowTitleBar();

+// break;

+

+// case MNU_EXPORT:

+// ExportDialog();

+// break;

+

+// case MNU_EXIT:

+// if(CheckSaveUserCancels()) break;

+// PostQuitMessage(0);

+// break;

+

+// case MNU_INSERT_COMMENT:

+// CHANGING_PROGRAM(AddComment(_("--add comment here--")));

+// break;

+

+// case MNU_INSERT_CONTACTS:

+// CHANGING_PROGRAM(AddContact());

+// break;

+

+// case MNU_INSERT_COIL:

+// CHANGING_PROGRAM(AddCoil());

+// break;

+

+// case MNU_INSERT_TON:

+// CHANGING_PROGRAM(AddTimer(ELEM_TON));

+// break;

+

+// case MNU_INSERT_TOF:

+// CHANGING_PROGRAM(AddTimer(ELEM_TOF));

+// break;

+

+// case MNU_INSERT_RTO:

+// CHANGING_PROGRAM(AddTimer(ELEM_RTO));

+// break;

+

+// case MNU_INSERT_CTU:

+// CHANGING_PROGRAM(AddCounter(ELEM_CTU));

+// break;

+

+// case MNU_INSERT_CTD:

+// CHANGING_PROGRAM(AddCounter(ELEM_CTD));

+// break;

+

+// case MNU_INSERT_CTC:

+// CHANGING_PROGRAM(AddCounter(ELEM_CTC));

+// break;

+

+// case MNU_INSERT_RES:

+// CHANGING_PROGRAM(AddReset());

+// break;

+

+// case MNU_INSERT_OPEN:

+// CHANGING_PROGRAM(AddEmpty(ELEM_OPEN));

+// break;

+

+// case MNU_INSERT_SHORT:

+// CHANGING_PROGRAM(AddEmpty(ELEM_SHORT));

+// break;

+

+// case MNU_INSERT_MASTER_RLY:

+// CHANGING_PROGRAM(AddMasterRelay());

+// break;

+

+// case MNU_INSERT_SHIFT_REG:

+// CHANGING_PROGRAM(AddShiftRegister());

+// break;

+

+// case MNU_INSERT_LUT:

+// CHANGING_PROGRAM(AddLookUpTable());

+// break;

+// case MNU_INSERT_PWL:

+// CHANGING_PROGRAM(AddPiecewiseLinear());

+// break;

+// case MNU_INSERT_FMTD_STR:

+// CHANGING_PROGRAM(AddFormattedString());

+// break;

+

+// case MNU_INSERT_OSR:

+// CHANGING_PROGRAM(AddEmpty(ELEM_ONE_SHOT_RISING));

+// break;

+

+// case MNU_INSERT_OSF:

+// CHANGING_PROGRAM(AddEmpty(ELEM_ONE_SHOT_FALLING));

+// break;

+

+// case MNU_INSERT_MOV:

+// CHANGING_PROGRAM(AddMove());

+// break;

+

+// case MNU_INSERT_SET_PWM:

+// CHANGING_PROGRAM(AddSetPwm());

+// break;

+

+// case MNU_INSERT_READ_ADC:

+// CHANGING_PROGRAM(AddReadAdc());

+// break;

+

+// case MNU_INSERT_UART_SEND:

+// CHANGING_PROGRAM(AddUart(ELEM_UART_SEND));

+// break;

+

+// case MNU_INSERT_UART_RECV:

+// CHANGING_PROGRAM(AddUart(ELEM_UART_RECV));

+// break;

+

+// case MNU_INSERT_PERSIST:

+// CHANGING_PROGRAM(AddPersist());

+// break;

+

+// {

+// int elem;

+// case MNU_INSERT_ADD: elem = ELEM_ADD; goto math;

+// case MNU_INSERT_SUB: elem = ELEM_SUB; goto math;

+// case MNU_INSERT_MUL: elem = ELEM_MUL; goto math;

+// case MNU_INSERT_DIV: elem = ELEM_DIV; goto math;

+// math:

+// CHANGING_PROGRAM(AddMath(elem));

+// break;

+// }

+

+// {

+// int elem;

+// case MNU_INSERT_EQU: elem = ELEM_EQU; goto cmp;

+// case MNU_INSERT_NEQ: elem = ELEM_NEQ; goto cmp;

+// case MNU_INSERT_GRT: elem = ELEM_GRT; goto cmp;

+// case MNU_INSERT_GEQ: elem = ELEM_GEQ; goto cmp;

+// case MNU_INSERT_LES: elem = ELEM_LES; goto cmp;

+// case MNU_INSERT_LEQ: elem = ELEM_LEQ; goto cmp;

+// cmp:

+// CHANGING_PROGRAM(AddCmp(elem));

+// break;

+// }

+

+// case MNU_MAKE_NORMAL:

+// CHANGING_PROGRAM(MakeNormalSelected());

+// break;

+

+// case MNU_NEGATE:

+// CHANGING_PROGRAM(NegateSelected());

+// break;

+

+// case MNU_MAKE_SET_ONLY:

+// CHANGING_PROGRAM(MakeSetOnlySelected());

+// break;

+

+// case MNU_MAKE_RESET_ONLY:

+// CHANGING_PROGRAM(MakeResetOnlySelected());

+// break;

+

+// case MNU_UNDO:

+// UndoUndo();

+// break;

+

+// case MNU_REDO:

+// UndoRedo();

+// break;

+

+// case MNU_INSERT_RUNG_BEFORE:

+// CHANGING_PROGRAM(InsertRung(FALSE));

+// break;

+

+// case MNU_INSERT_RUNG_AFTER:

+// CHANGING_PROGRAM(InsertRung(TRUE));

+// break;

+

+// case MNU_DELETE_RUNG:

+// CHANGING_PROGRAM(DeleteSelectedRung());

+// break;

+

+// case MNU_PUSH_RUNG_UP:

+// CHANGING_PROGRAM(PushRungUp());

+// break;

+

+// case MNU_PUSH_RUNG_DOWN:

+// CHANGING_PROGRAM(PushRungDown());

+// break;

+

+// case MNU_DELETE_ELEMENT:

+// CHANGING_PROGRAM(DeleteSelectedFromProgram());

+// break;

+

+// case MNU_MCU_SETTINGS:

+// CHANGING_PROGRAM(ShowConfDialog());

+// break;

+

+// case MNU_SIMULATION_MODE:

+// ToggleSimulationMode();

+// ToggleAdvancedSimulationMode();

+// break;

+

+// case MNU_START_SIMULATION:

+// StartSimulation();

+// StartAdvSimulation();

+// break;

+

+// case MNU_STOP_SIMULATION:

+// StopSimulation();

+// StopAdvSimulation();

+// break;

+

+// case MNU_SINGLE_CYCLE:

+// SimulateOneCycle(TRUE);

+// break;

+

+// case MNU_COMPILE:

+// CompileProgram(FALSE);

+// break;

+

+// case MNU_COMPILE_AS:

+// CompileProgram(TRUE);

+// break;

+

+// case MNU_MANUAL:

+// ShowHelpDialog(FALSE);

+// break;

+

+// case MNU_ABOUT:

+// ShowHelpDialog(TRUE);

+// break;

+

+// case MNU_ADV_SIMULATION:

+// ShowAdvancedDialog();

+// }

+// }

+// LRESULT CALLBACK MainWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)

+// {

+// switch (msg) {

+// case WM_ERASEBKGND:

+// break;

+

+// case WM_SETFOCUS:

+// InvalidateRect(MainWindow, NULL, FALSE);

+// break;

+

+// case WM_PAINT: {

+// PAINTSTRUCT ps;

+// Hdc = BeginPaint(hwnd, &ps);

+

+// // This draws the schematic.

+// PaintWindow();

+

+// RECT r;

+// // Fill around the scroll bars

+// if(NeedHoriz) {

+// r.top = IoListTop - ScrollHeight - 2;

+// r.bottom = IoListTop - 2;

+// FillRect(Hdc, &r, (HBRUSH)GetStockObject(LTGRAY_BRUSH));

+// }

+// GetClientRect(MainWindow, &r);

+// r.left = r.right - ScrollWidth - 2;

+// FillRect(Hdc, &r, (HBRUSH)GetStockObject(LTGRAY_BRUSH));

+

+// // Draw the splitter thing to grab to resize the I/O listview.

+// GetClientRect(MainWindow, &r);

+// r.top = IoListTop - 2;

+// r.bottom = IoListTop;

+// FillRect(Hdc, &r, (HBRUSH)GetStockObject(LTGRAY_BRUSH));

+// r.top = IoListTop - 2;

+// r.bottom = IoListTop - 1;

+// FillRect(Hdc, &r, (HBRUSH)GetStockObject(WHITE_BRUSH));

+// r.top = IoListTop;

+// r.bottom = IoListTop + 1;

+// FillRect(Hdc, &r, (HBRUSH)GetStockObject(DKGRAY_BRUSH));

+

+// EndPaint(hwnd, &ps);

+// return 1;

+// }

+

+// case WM_KEYDOWN: {

+// if(wParam == 'M') {

+// if(GetAsyncKeyState(VK_CONTROL) & 0x8000) {

+// ToggleSimulationMode();

+// ToggleAdvancedSimulationMode();

+// break;

+// }

+// } else if(wParam == VK_TAB) {

+// SetFocus(IoList);

+// BlinkCursor(0, 0, 0, 0);

+// break;

+// } else if(wParam == VK_F1) {

+// ShowHelpDialog(FALSE);

+// break;

+// }

+

+// if(wParam == 'A') {

+// if(GetAsyncKeyState(VK_CONTROL) & 0x8000) {

+// ShowAdvancedDialog();

+// break;

+// }

+// }

+

+// if(InSimulationMode) {

+// switch(wParam) {

+// case ' ':

+// SimulateOneCycle(TRUE);

+// break;

+

+// case 'R':

+// if(GetAsyncKeyState(VK_CONTROL) & 0x8000)

+// StartSimulation();

+// StartAdvSimulation();

+// break;

+

+// case 'H':

+// if(GetAsyncKeyState(VK_CONTROL) & 0x8000)

+// StopSimulation();

+// StopAdvSimulation();

+// break;

+

+// case VK_DOWN:

+// if(ScrollYOffset < ScrollYOffsetMax)

+// ScrollYOffset++;

+// RefreshScrollbars();

+// InvalidateRect(MainWindow, NULL, FALSE);

+// break;

+

+// case VK_UP:

+// if(ScrollYOffset > 0)

+// ScrollYOffset--;

+// RefreshScrollbars();

+// InvalidateRect(MainWindow, NULL, FALSE);

+// break;

+

+// case VK_LEFT:

+// ScrollXOffset -= FONT_WIDTH;

+// if(ScrollXOffset < 0) ScrollXOffset = 0;

+// RefreshScrollbars();

+// InvalidateRect(MainWindow, NULL, FALSE);

+// break;

+

+// case VK_RIGHT:

+// ScrollXOffset += FONT_WIDTH;

+// if(ScrollXOffset >= ScrollXOffsetMax)

+// ScrollXOffset = ScrollXOffsetMax;

+// RefreshScrollbars();

+// InvalidateRect(MainWindow, NULL, FALSE);

+// break;

+

+// case VK_RETURN:

+// case VK_ESCAPE:

+// ToggleSimulationMode();

+// break;

+// }

+// break;

+// }

+

+// switch(wParam) {

+// case VK_F5:

+// CompileProgram(FALSE);

+// break;

+

+// case VK_UP:

+// if(GetAsyncKeyState(VK_SHIFT) & 0x8000) {

+// CHANGING_PROGRAM(PushRungUp());

+// } else {

+// MoveCursorKeyboard(wParam);

+// }

+// break;

+

+// case VK_DOWN:

+// if(GetAsyncKeyState(VK_SHIFT) & 0x8000) {

+// CHANGING_PROGRAM(PushRungDown());

+// } else {

+// MoveCursorKeyboard(wParam);

+// }

+// break;

+

+// case VK_RIGHT:

+// case VK_LEFT:

+// MoveCursorKeyboard(wParam);

+// break;

+

+// case VK_RETURN:

+// CHANGING_PROGRAM(EditSelectedElement());

+// break;

+

+// case VK_DELETE:

+// if(GetAsyncKeyState(VK_SHIFT) & 0x8000) {

+// CHANGING_PROGRAM(DeleteSelectedRung());

+// } else {

+// CHANGING_PROGRAM(DeleteSelectedFromProgram());

+// }

+// break;

+

+// case VK_OEM_1:

+// CHANGING_PROGRAM(AddComment(_("--add comment here--")));

+// break;

+

+// case 'C':

+// CHANGING_PROGRAM(AddContact());

+// break;

+

+// // TODO: rather country-specific here

+// case VK_OEM_2:

+// CHANGING_PROGRAM(AddEmpty(ELEM_ONE_SHOT_RISING));

+// break;

+

+// case VK_OEM_5:

+// CHANGING_PROGRAM(AddEmpty(ELEM_ONE_SHOT_FALLING));

+// break;

+

+// case 'L':

+// CHANGING_PROGRAM(AddCoil());

+// break;

+

+// case 'R':

+// CHANGING_PROGRAM(MakeResetOnlySelected());

+// break;

+

+// case 'E':

+// if(GetAsyncKeyState(VK_CONTROL) & 0x8000) {

+// ExportDialog();

+// } else {

+// CHANGING_PROGRAM(AddReset());

+// }

+// break;

+

+// case 'S':

+// if(GetAsyncKeyState(VK_CONTROL) & 0x8000) {

+// SaveProgram();

+// UpdateMainWindowTitleBar();

+// } else {

+// CHANGING_PROGRAM(MakeSetOnlySelected());

+// }

+// break;

+

+// case 'N':

+// if(GetAsyncKeyState(VK_CONTROL) & 0x8000) {

+// if(CheckSaveUserCancels()) break;

+// if(!ProgramChangedNotSaved) {

+// int r = MessageBox(MainWindow,

+// _("Start new program?"),

+// "LDmicro", MB_YESNO | MB_DEFBUTTON2 |

+// MB_ICONQUESTION);

+// if(r == IDNO) break;

+// }

+// NewProgram();

+// strcpy(CurrentSaveFile, "");

+// strcpy(CurrentCompileFile, "");

+// GenerateIoListDontLoseSelection();

+// RefreshScrollbars();

+// UpdateMainWindowTitleBar();

+// } else {

+// CHANGING_PROGRAM(NegateSelected());

+// }

+// break;

+

+// case 'A':

+// CHANGING_PROGRAM(MakeNormalSelected());

+// break;

+

+// case 'T':

+// CHANGING_PROGRAM(AddTimer(ELEM_RTO));

+// break;

+

+// case 'O':

+// if(GetAsyncKeyState(VK_CONTROL) & 0x8000) {

+// if(CheckSaveUserCancels()) break;

+// OpenDialog();

+// } else {

+// CHANGING_PROGRAM(AddTimer(ELEM_TON));

+// }

+// break;

+

+// case 'F':

+// CHANGING_PROGRAM(AddTimer(ELEM_TOF));

+// break;

+

+// case 'U':

+// CHANGING_PROGRAM(AddCounter(ELEM_CTU));

+// break;

+

+// case 'I':

+// CHANGING_PROGRAM(AddCounter(ELEM_CTD));

+// break;

+

+// case 'J':

+// CHANGING_PROGRAM(AddCounter(ELEM_CTC));

+// break;

+

+// case 'M':

+// CHANGING_PROGRAM(AddMove());

+// break;

+

+// case 'P':

+// CHANGING_PROGRAM(AddReadAdc());

+// break;

+

+// case VK_OEM_PLUS:

+// if(GetAsyncKeyState(VK_SHIFT) & 0x8000) {

+// CHANGING_PROGRAM(AddMath(ELEM_ADD));

+// } else {

+// CHANGING_PROGRAM(AddCmp(ELEM_EQU));

+// }

+// break;

+

+// case VK_OEM_MINUS:

+// if(GetAsyncKeyState(VK_SHIFT) & 0x8000) {

+// } else {

+// CHANGING_PROGRAM(AddMath(ELEM_SUB));

+// }

+// break;

+

+// case '8':

+// if(GetAsyncKeyState(VK_SHIFT) & 0x8000) {

+// CHANGING_PROGRAM(AddMath(ELEM_MUL));

+// }

+// break;

+

+// case 'D':

+// CHANGING_PROGRAM(AddMath(ELEM_DIV));

+// break;

+

+// case VK_OEM_PERIOD:

+// if(GetAsyncKeyState(VK_SHIFT) & 0x8000) {

+// CHANGING_PROGRAM(AddCmp(ELEM_GRT));

+// } else {

+// CHANGING_PROGRAM(AddCmp(ELEM_GEQ));

+// }

+// break;

+

+// case VK_OEM_COMMA:

+// if(GetAsyncKeyState(VK_SHIFT) & 0x8000) {

+// CHANGING_PROGRAM(AddCmp(ELEM_LES));

+// } else {

+// CHANGING_PROGRAM(AddCmp(ELEM_LEQ));

+// }

+// break;

+

+// case 'V':

+// if(GetAsyncKeyState(VK_SHIFT) & 0x8000) {

+// CHANGING_PROGRAM(InsertRung(TRUE));

+// }

+// break;

+

+// case '6':

+// if(GetAsyncKeyState(VK_SHIFT) & 0x8000) {

+// CHANGING_PROGRAM(InsertRung(FALSE));

+// }

+// break;

+

+// case 'Z':

+// if(GetAsyncKeyState(VK_CONTROL) & 0x8000) {

+// UndoUndo();

+// }

+// break;

+

+// case 'Y':

+// if(GetAsyncKeyState(VK_CONTROL) & 0x8000) {

+// UndoRedo();

+// }

+// break;

+

+// default:

+// break;

+// }

+// if(wParam != VK_SHIFT && wParam != VK_CONTROL) {

+// InvalidateRect(MainWindow, NULL, FALSE);

+// }

+// break;

+// }

+

+// case WM_LBUTTONDBLCLK: {

+// int x = LOWORD(lParam);

+// int y = HIWORD(lParam);

+// if(InSimulationMode) {

+// EditElementMouseDoubleclick(x, y);

+// } else {

+// CHANGING_PROGRAM(EditElementMouseDoubleclick(x, y));

+// }

+// InvalidateRect(MainWindow, NULL, FALSE);

+// break;

+// }

+

+// case WM_LBUTTONDOWN: {

+// int x = LOWORD(lParam);

+// int y = HIWORD(lParam);

+// if((y > (IoListTop - 9)) && (y < (IoListTop + 3))) {

+// POINT pt;

+// pt.x = x; pt.y = y;

+// ClientToScreen(MainWindow, &pt);

+// MouseY = pt.y;

+// MouseHookHandle = SetWindowsHookEx(WH_MOUSE_LL,

+// (HOOKPROC)MouseHook, Instance, 0);

+// }

+// if(!InSimulationMode) MoveCursorMouseClick(x, y);

+

+// SetFocus(MainWindow);

+// InvalidateRect(MainWindow, NULL, FALSE);

+// break;

+// }

+// case WM_MOUSEMOVE: {

+// int x = LOWORD(lParam);

+// int y = HIWORD(lParam);

+

+// if((y > (IoListTop - 9)) && (y < (IoListTop + 3))) {

+// SetCursor(LoadCursor(NULL, IDC_SIZENS));

+// } else {

+// SetCursor(LoadCursor(NULL, IDC_ARROW));

+// }

+// break;

+// }

+// case WM_MOUSEWHEEL: {

+// if((GET_WHEEL_DELTA_WPARAM(wParam)) > 0) {

+// VscrollProc(SB_LINEUP);

+// } else {

+// VscrollProc(SB_LINEDOWN);

+// }

+// break;

+// }

+

+// case WM_SIZE:

+// MainWindowResized();

+// break;

+

+// case WM_NOTIFY: {

+// NMHDR *h = (NMHDR *)lParam;

+// if(h->hwndFrom == IoList) {

+// IoListProc(h);

+// }

+// return 0;

+// }

+// case WM_VSCROLL:

+// VscrollProc(wParam);

+// break;

+

+// case WM_HSCROLL:

+// HscrollProc(wParam);

+// break;

+

+// case WM_COMMAND:

+// ProcessMenu(LOWORD(wParam));

+// InvalidateRect(MainWindow, NULL, FALSE);

+// break;

+

+// case WM_CLOSE:

+// case WM_DESTROY:

+// if(CheckSaveUserCancels()) break;

+

+// PostQuitMessage(0);

+// return 1;

+// default:

+// return DefWindowProc(hwnd, msg, wParam, lParam);

+// }

+

+// return 1;

+// }

+// static BOOL MakeWindowClass()

+// {

+// WNDCLASSEX wc;

+// memset(&wc, 0, sizeof(wc));

+// wc.cbSize = sizeof(wc);

+

+// wc.style = CS_BYTEALIGNCLIENT | CS_BYTEALIGNWINDOW | CS_OWNDC |

+// CS_DBLCLKS;

+// wc.lpfnWndProc = (WNDPROC)MainWndProc;

+// wc.hInstance = Instance;

+// wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);

+// wc.lpszClassName = "LDmicro";

+// 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);

+

+// return RegisterClassEx(&wc);

+// }

+ /// Check if we're running in non-interactive mode; in that case we should

+ /// load the file, compile, and exit.

+

+ if (argc < 4)

+ {

+ printf("throwing error...\n");

+ Error(err);

+ exit(-1);

+ }

+

+ char *source = (char*)malloc(strlen(argv[2]) + strlen(argv[3]) + 2);

+ sprintf(source, "%s %s", argv[2], argv[3]);

+

+ if(*source == '\0')

+ {

+ Error(err);

+ free(source);

+ exit(-1);

+ }

+

+ if(*dest == '\0')

+ {

+ Error(err);

+ free(source);

+ exit(-1);

+ }

+

+ if(*dest == '\0')

+ {

+ Error(err);

+ free(source);

+ exit(-1);

+ }

+

+ Error("Couldn't open '%s', running non-interactively.\n", source);

+ free(source);

+ // /// ~~~

+ // Instance = hInstance; /// parent window

+

+ // MainHeap = HeapCreate(0, 1024*64, 0);

+

+ // // MakeWindowClass();

+ // // MakeDialogBoxClass();

+ // // MakeAdvancedDialogClass();

+ // // MakeAdvancedWorkspaceClass();

+ // // MakeComponentListClass();

+ // // MakeSmplDialogClass();

+ // // MakeNamingListClass();

+ // HMENU top = MakeMainWindowMenus();

+

+ // /// Make main window

+ // // MainWindow = CreateWindowEx(0, "LDmicro", "",

+ // // WS_OVERLAPPED | WS_THICKFRAME | WS_CLIPCHILDREN | WS_MAXIMIZEBOX |

+ // // WS_MINIMIZEBOX | WS_SYSMENU | WS_SIZEBOX,

+ // // 10, 10, 800, 600, NULL, top, Instance, NULL);

+ // ThawWindowPos(MainWindow);

+ // IoListHeight = 100;

+ // ThawDWORD(IoListHeight);

+

+ // InitCommonControls();

+ // InitForDrawing();

+

+ // MakeMainWindowControls();

+ // MainWindowResized();

+ // NewProgram();

+ // strcpy(CurrentSaveFile, "");

+

+ // // We are running interactively, or we would already have exited. We

+ // // can therefore show the window now, and otherwise set up the GUI.

+

+ // ShowWindow(MainWindow, SW_SHOW);

+ // SetTimer(MainWindow, TIMER_BLINK_CURSOR, 800, BlinkCursor);

+ // if(strlen(lpCmdLine) > 0) {

+ // char line[MAX_PATH];

+ // if(*lpCmdLine == '"') {

+ // strcpy(line, lpCmdLine+1);

+ // } else {

+ // strcpy(line, lpCmdLine);

+ // }

+ // if(strchr(line, '"')) *strchr(line, '"') = '\0';

+

+ // char *s;

+ // GetFullPathName(line, sizeof(CurrentSaveFile), CurrentSaveFile, &s);

+ // if(!LoadProjectFromFile(CurrentSaveFile)) {

+ // NewProgram();

+ // Error(_("Couldn't open '%s'."), CurrentSaveFile);

+ // CurrentSaveFile[0] = '\0';

+ // }

+ // UndoFlush();

+ // }

+

+ // GenerateIoListDontLoseSelection();

+ // RefreshScrollbars();

+ // UpdateMainWindowTitleBar();

+

+ // MSG msg;

+ // DWORD ret;

+ // while(ret = GetMessage(&msg, NULL, 0, 0)) {

+ // if(msg.hwnd == IoList && msg.message == WM_KEYDOWN) {

+ // if(msg.wParam == VK_TAB) {

+ // SetFocus(MainWindow);

+ // continue;

+ // }

+ // }

+ // if(msg.message == WM_KEYDOWN && msg.wParam != VK_UP &&

+ // msg.wParam != VK_DOWN && msg.wParam != VK_RETURN && msg.wParam

+ // != VK_SHIFT)

+ // {

+ // if(msg.hwnd == IoList) {

+ // msg.hwnd = MainWindow;

+ // SetFocus(MainWindow);

+ // }

+ // }

+ // TranslateMessage(&msg);

+ // DispatchMessage(&msg);

+ // }

+ // FreezeWindowPos(MainWindow);

+ // FreezeDWORD(IoListHeight);

+std::vector<HEAPRECORD> HeapRecords;

+

+HANDLE HeapCreate(DWORD flOptions, SIZE_T dwInitialSize, SIZE_T dwMaximumSize)

+{

+ HANDLE hHeap = NULL;

+ HEAPRECORD hHeapRecord;

+ hHeapRecord.dwMaximumSize = dwMaximumSize;

+ hHeap = malloc(dwInitialSize);

+

+ if (hHeap == NULL)

+ return NULL;

+

+ hHeapRecord.dwSize = dwInitialSize;

+ hHeapRecord.hHeap = hHeap;

+ hHeapRecord.dwAllocatedSizeOffset = 0;

+ hHeapRecord.HeapID = HeapRecords.size()+1;

+ HeapRecords.push_back(hHeapRecord);

+

+ return hHeap;

+}

+

+LPVOID HeapAlloc(HANDLE hHeap, DWORD dwFlags, SIZE_T dwBytes)

+{

+ if (hHeap == NULL)

+ {

+ printf("Alloc**********NULL HEAP***************\n");

+ LPVOID p = malloc(dwBytes);

+ return p;

+ }

+

+ auto it = std::find_if(HeapRecords.begin(), HeapRecords.end(), [&hHeap](HEAPRECORD &Record) { return Record.hHeap == hHeap; });

+

+ if (it == HeapRecords.end())

+ return NULL;

+

+ if ((*it).dwAllocatedSizeOffset + dwBytes > (*it).dwSize)

+ {

+ if ((*it).dwMaximumSize != 0)

+ if((*it).dwAllocatedSizeOffset + dwBytes > (*it).dwMaximumSize)

+ return NULL;

+

+ (*it).hHeap = realloc((*it).hHeap, (*it).dwAllocatedSizeOffset + dwBytes);

+ hHeap = (*it).hHeap;

+ }

+

+ /// HEAP_ZERO_MEMORY is set by default

+ DWORD flags = MAP_ANONYMOUS;

+

+ // if ( !((dwFlags & HEAP_ZERO_MEMORY) == HEAP_ZERO_MEMORY) )

+ // flags = MAP_ANONYMOUS | MAP_UNINITIALIZED;

+

+ /* Use for setting a meamory chunck with some value

+ * void * memset ( void * ptr, int value, size_t num );

+ */

+ LPVOID p = mmap(hHeap + (*it).dwAllocatedSizeOffset, dwBytes, PROT_EXEC, flags, -1, 0);

+

+ if (p == NULL)

+ return NULL;

+

+ (*it).dwAllocatedSizeOffset += dwBytes;

+ HEAPCHUNCK chunck;

+ chunck.Chunck = p;

+ chunck.dwSize = dwBytes;

+ (*it).Element.push_back(chunck);

+

+ return p;

+}

+

+BOOL HeapFree(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem)

+{

+ /// if NULL free()

+ if (hHeap == NULL)

+ {

+ printf("free*********NULL HEAP***************\n");

+ free(lpMem);

+ return TRUE;

+ }

+ auto heap_it = std::find_if(HeapRecords.begin(), HeapRecords.end(), [&hHeap](HEAPRECORD &Record) { return Record.hHeap == hHeap; });

+

+ if (heap_it == HeapRecords.end())

+ return FALSE;

+

+ auto chunck_it = std::find_if((*heap_it).Element.begin(), (*heap_it).Element.end(), [&lpMem](HEAPCHUNCK &Chunck) { return Chunck.Chunck == lpMem; });

+

+ if (chunck_it == (*heap_it).Element.end())

+ return FALSE;

+

+ int result = munmap((*chunck_it).Chunck, (*chunck_it).dwSize);

+

+ if (result == 0)

+ {

+ (*heap_it).Element.erase(chunck_it);

+ return TRUE;

+ }

+ else

+ return FALSE;

+

+}

+

+void OutputDebugString(char* str)

+{

+

+}

+

+double GetTickCount(void)

+{

+// timespec now;

+// clock_gettime()

+// if (clock_gettime(CLOCK_MONOTONIC, &now))

+// return 0;

+ return 10.2;//now.tv_sec * 1000.0 + now.tv_nsec / 1000000.0;

+} \ No newline at end of file

+#include <ctype.h>

+#include <vector>

+#include <algorithm>

+#include <sys/mman.h>

+

+#define HEAP_ZERO_MEMORY 0x00000008

+

+/// Typedefs

+typedef unsigned short WORD;

+typedef unsigned int UINT;

+typedef size_t SIZE_T;

+

+typedef void *PVOID;

+typedef void *LPVOID;

+typedef PVOID HFONT;

+typedef PVOID HMODULE;

+typedef PVOID HHOOK;

+typedef PVOID HBRUSH;

+typedef PVOID HFONT;

+typedef GtkWidget *HWID;

+typedef GtkWidget *HMENU;

+typedef GtkWindow *HWND;

+typedef GtkApplication *HAPP;

+#if defined(__UNIX64)

+ typedef __int64_t LONG_PTR;

+#else

+ typedef long LONG_PTR;

+#endif

+

+typedef LONG_PTR LPARAM;

+typedef LONG_PTR LRESULT;

+

+/// Custom classes

+/// Custom structures

+typedef struct HeapRecordChunckTag{

+ PVOID Chunck;

+ SIZE_T dwSize;

+} HEAPCHUNCK;

+

+typedef struct HeapRecordTag{

+ PVOID hHeap;

+ DWORD HeapID;

+ std::vector<HEAPCHUNCK> Element;

+ SIZE_T dwMaximumSize;

+ SIZE_T dwSize;

+ SIZE_T dwAllocatedSizeOffset;

+} HEAPRECORD;

+

+typedef struct tagSCROLLINFO {

+ UINT cbSize;

+ UINT fMask;

+ int nMin;

+ int nMax;

+ UINT nPage;

+ int nPos;

+ int nTrackPos;

+} SCROLLINFO, *LPCSCROLLINFO;

+

+typedef struct tagNMHDR {

+ HWND hwndFrom;

+ UINT_PTR idFrom;

+ UINT code;

+} NMHDR;

+

+/// Variables

+extern std::vector<HEAPRECORD> HeapRecord;

+

+/// Functions

+HANDLE HeapCreate(

+ DWORD flOptions,

+ SIZE_T dwInitialSize,

+ SIZE_T dwMaximumSize);

+

+LPVOID HeapAlloc(

+ HANDLE hHeap,

+ DWORD dwFlags,

+ SIZE_T dwBytes);

+

+BOOL HeapFree(

+ HANDLE hHeap,

+ DWORD dwFlags,

+ LPVOID lpMem);

+

+/// functions to be ported

+void OutputDebugString(char*);

+double GetTickCount(void);

+//#include "windows.h"

+#include "linuxUI.h"

+ } else if(sscanf(line, "CONTACTS %s %d", l->d.contacts.name, &l->d.contacts.negated)==2)

+ } else if(sscanf(line, "COIL %s %d %d %d", l->d.coil.name, &l->d.coil.negated, &l->d.coil.setOnly, &l->d.coil.resetOnly)==4)

+ } else if(sscanf(line, "SHIFT_REGISTER %s %d", l->d.shiftRegister.name, &(l->d.shiftRegister.stages))==2)

+ } else if((sscanf(line, "TON %s %d", l->d.timer.name, &l->d.timer.delay)==2))

+ } else if((sscanf(line, "TOF %s %d", l->d.timer.name, &l->d.timer.delay)==2))

+ } else if((sscanf(line, "RTO %s %d", l->d.timer.name, &l->d.timer.delay)==2))

+ } else if((sscanf(line, "CTD %s %d", l->d.counter.name, &l->d.counter.max)==2))

+ } else if((sscanf(line, "CTU %s %d", l->d.counter.name, &l->d.counter.max)==2))

+ } else if((sscanf(line, "CTC %s %d", l->d.counter.name, &l->d.counter.max)==2))

+ } else if(sscanf(line, "ADD %s %s %s", l->d.math.dest, l->d.math.op1, l->d.math.op2)==3)

+ } else if(sscanf(line, "SUB %s %s %s", l->d.math.dest, l->d.math.op1, l->d.math.op2)==3)

+ } else if(sscanf(line, "MUL %s %s %s", l->d.math.dest, l->d.math.op1, l->d.math.op2)==3)

+ } else if(sscanf(line, "DIV %s %s %s", l->d.math.dest, l->d.math.op1, l->d.math.op2)==3)

+ } else if(sscanf(line, "SET_PWM %s %d", l->d.setPwm.name, &(l->d.setPwm.targetFreq))==2)

+ } else if(sscanf(line, "FORMATTED_STRING %s %d", l->d.fmtdStr.var, &x)==2)

+

+

+

+

+

+

+

+

+

+

+

+

+ if(!Prog.rungs[rung])

+ goto failed;

+

+#include "linuxUI.h"

+//#include <commctrl.h>

+// static HWND LutDialog;

+// static HWND AsStringCheckbox;

+// static HWND CountTextbox;

+// static HWND DestTextbox;

+// static HWND IndexTextbox;

+// static HWND Labels[3];

+// static HWND StringTextbox;

+//static HWND ValuesTextbox[MAX_LOOK_UP_TABLE_LEN];

+//static HWND ValuesLabel[MAX_LOOK_UP_TABLE_LEN];

+// static LRESULT CALLBACK MyNumberProc(HWND hwnd, UINT msg, WPARAM wParam,

+// LPARAM lParam)

+// {

+// if(msg == WM_CHAR) {

+// if(!(isdigit(wParam) || wParam == '\b' || wParam == '-')) {

+// return 0;

+// }

+// }

+// WNDPROC w;

+// int i;

+// for(i = 0; i < MAX_LOOK_UP_TABLE_LEN; i++) {

+// if(hwnd == ValuesTextbox[i]) {

+// w = (WNDPROC)PrevValuesProc[i];

+// break;

+// }

+// }

+// if(i == MAX_LOOK_UP_TABLE_LEN) oops();

+

+// return CallWindowProc(w, hwnd, msg, wParam, lParam);

+// }

+// static LRESULT CALLBACK MyDigitsProc(HWND hwnd, UINT msg, WPARAM wParam,

+// LPARAM lParam)

+// {

+// if(msg == WM_CHAR) {

+// if(!(isdigit(wParam) || wParam == '\b')) {

+// return 0;

+// }

+// }

+

+// return CallWindowProc((WNDPROC)PrevCountProc, hwnd, msg, wParam, lParam);

+// }

+// static LRESULT CALLBACK MyNameProc(HWND hwnd, UINT msg, WPARAM wParam,

+// LPARAM lParam)

+// {

+// if(msg == WM_CHAR) {

+// if(!(isalpha(wParam) || isdigit(wParam) || wParam == '_' ||

+// wParam == '\b'))

+// {

+// return 0;

+// }

+// }

+

+// WNDPROC w;

+// if(hwnd == DestTextbox) {

+// w = (WNDPROC)PrevDestProc;

+// } else if(hwnd == IndexTextbox) {

+// w = (WNDPROC)PrevIndexProc;

+// }

+// return CallWindowProc(w, hwnd, msg, wParam, lParam);

+// }

+// static void MakeFixedControls(BOOL forPwl)

+// {

+// Labels[0] = CreateWindowEx(0, WC_STATIC, _("Destination:"),

+// WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE | SS_RIGHT,

+// 0, 10, 78, 21, LutDialog, NULL, Instance, NULL);

+// NiceFont(Labels[0]);

+

+// DestTextbox = CreateWindowEx(WS_EX_CLIENTEDGE, WC_EDIT, "",

+// WS_CHILD | ES_AUTOHSCROLL | WS_TABSTOP | WS_CLIPSIBLINGS | WS_VISIBLE,

+// 85, 10, 120, 21, LutDialog, NULL, Instance, NULL);

+// FixedFont(DestTextbox);

+

+// Labels[1] = CreateWindowEx(0, WC_STATIC, _("Index:"),

+// WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE | SS_RIGHT,

+// 10, 40, 68, 21, LutDialog, NULL, Instance, NULL);

+// NiceFont(Labels[1]);

+

+// IndexTextbox = CreateWindowEx(WS_EX_CLIENTEDGE, WC_EDIT, "",

+// WS_CHILD | ES_AUTOHSCROLL | WS_TABSTOP | WS_CLIPSIBLINGS | WS_VISIBLE,

+// 85, 40, 120, 21, LutDialog, NULL, Instance, NULL);

+// FixedFont(IndexTextbox);

+

+// Labels[2] = CreateWindowEx(0,WC_STATIC, forPwl ? _("Points:") : _("Count:"),

+// WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE | SS_RIGHT,

+// 0, 70, 78, 21, LutDialog, NULL, Instance, NULL);

+// NiceFont(Labels[2]);

+

+// CountTextbox = CreateWindowEx(WS_EX_CLIENTEDGE, WC_EDIT, "",

+// WS_CHILD | ES_AUTOHSCROLL | WS_TABSTOP | WS_CLIPSIBLINGS | WS_VISIBLE,

+// 85, 70, 120, 21, LutDialog, NULL, Instance, NULL);

+// NiceFont(CountTextbox);

+

+// if(!forPwl) {

+// AsStringCheckbox = CreateWindowEx(0, WC_BUTTON,

+// _("Edit table of ASCII values like a string"), WS_CHILD |

+// WS_TABSTOP | WS_CLIPSIBLINGS | WS_VISIBLE | BS_AUTOCHECKBOX,

+// 10, 100, 300, 21, LutDialog, NULL, Instance, NULL);

+// NiceFont(AsStringCheckbox);

+// }

+

+// OkButton = CreateWindowEx(0, WC_BUTTON, _("OK"),

+// WS_CHILD | WS_TABSTOP | WS_CLIPSIBLINGS | WS_VISIBLE | BS_DEFPUSHBUTTON,

+// 231, 10, 70, 23, LutDialog, NULL, Instance, NULL);

+// NiceFont(OkButton);

+

+// CancelButton = CreateWindowEx(0, WC_BUTTON, _("Cancel"),

+// WS_CHILD | WS_TABSTOP | WS_CLIPSIBLINGS | WS_VISIBLE,

+// 231, 40, 70, 23, LutDialog, NULL, Instance, NULL);

+// NiceFont(CancelButton);

+

+// PrevDestProc = SetWindowLongPtr(DestTextbox, GWLP_WNDPROC,

+// (LONG_PTR)MyNameProc);

+// PrevIndexProc = SetWindowLongPtr(IndexTextbox, GWLP_WNDPROC,

+// (LONG_PTR)MyNameProc);

+// PrevCountProc = SetWindowLongPtr(CountTextbox, GWLP_WNDPROC,

+// (LONG_PTR)MyDigitsProc);

+// }

+// static void DestroyLutControls(void)

+// {

+// if(WasAsString) {

+// // Nothing to do; we constantly update the cache from the user-

+// // specified string, because we might as well do that when we

+// // calculate the length.

+// } else {

+// int i;

+// for(i = 0; i < WasCount; i++) {

+// char buf[20];

+// SendMessage(ValuesTextbox[i], WM_GETTEXT, (WPARAM)16, (LPARAM)buf);

+// ValuesCache[i] = atoi(buf);

+// }

+// }

+

+// DestroyWindow(StringTextbox);

+

+// int i;

+// for(i = 0; i < MAX_LOOK_UP_TABLE_LEN; i++) {

+// DestroyWindow(ValuesTextbox[i]);

+// DestroyWindow(ValuesLabel[i]);

+// }

+// }

+// static void MakeLutControls(BOOL asString, int count, BOOL forPwl)

+// {

+// // Remember these, so that we know from where to cache stuff if we have

+// // to destroy these textboxes and make something new later.

+// WasAsString = asString;

+// WasCount = count;

+

+// if(forPwl && asString) oops();

+

+// if(asString) {

+// char str[3*MAX_LOOK_UP_TABLE_LEN+1];

+// int i, j;

+// j = 0;

+// for(i = 0; i < count; i++) {

+// int c = ValuesCache[i];

+// if(c >= 32 && c <= 127 && c != '\\') {

+// str[j++] = c;

+// } else if(c == '\\') {

+// str[j++] = '\\';

+// str[j++] = '\\';

+// } else if(c == '\r') {

+// str[j++] = '\\';

+// str[j++] = 'r';

+// } else if(c == '\b') {

+// str[j++] = '\\';

+// str[j++] = 'b';

+// } else if(c == '\f') {

+// str[j++] = '\\';

+// str[j++] = 'f';

+// } else if(c == '\n') {

+// str[j++] = '\\';

+// str[j++] = 'n';

+// } else {

+// str[j++] = 'X';

+// }

+// }

+// str[j++] = '\0';

+// StringTextbox = CreateWindowEx(WS_EX_CLIENTEDGE, WC_EDIT, str,

+// WS_CHILD | ES_AUTOHSCROLL | WS_TABSTOP | WS_CLIPSIBLINGS |

+// WS_VISIBLE,

+// 10, 130, 294, 21, LutDialog, NULL, Instance, NULL);

+// FixedFont(StringTextbox);

+// SendMessage(CountTextbox, EM_SETREADONLY, (WPARAM)TRUE, 0);

+// MoveWindow(LutDialog, 100, 30, 320, 185, TRUE);

+// } else {

+// int i;

+// int base;

+// if(forPwl) {

+// base = 100;

+// } else {

+// base = 140;

+// }

+// for(i = 0; i < count; i++) {

+// int x, y;

+

+// if(i < 16) {

+// x = 10;

+// y = base+30*i;

+// } else {

+// x = 160;

+// y = base+30*(i-16);

+// }

+

+// char buf[20];

+// sprintf(buf, "%d", ValuesCache[i]);

+// ValuesTextbox[i] = CreateWindowEx(WS_EX_CLIENTEDGE, WC_EDIT, buf,

+// WS_CHILD | ES_AUTOHSCROLL | WS_TABSTOP | WS_CLIPSIBLINGS |

+// WS_VISIBLE,

+// x+30, y, 80, 21, LutDialog, NULL, Instance, NULL);

+// NiceFont(ValuesTextbox[i]);

+

+// if(forPwl) {

+// sprintf(buf, "%c%d:", (i & 1) ? 'y' : 'x', i/2);

+// } else {

+// sprintf(buf, "%2d:", i);

+// }

+// ValuesLabel[i] = CreateWindowEx(0, WC_STATIC, buf,

+// WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE,

+// x, y+3, 100, 21, LutDialog, NULL, Instance, NULL);

+// FixedFont(ValuesLabel[i]);

+

+// PrevValuesProc[i] = SetWindowLongPtr(ValuesTextbox[i],

+// GWLP_WNDPROC, (LONG_PTR)MyNumberProc);

+// }

+// if(count > 16) count = 16;

+// SendMessage(CountTextbox, EM_SETREADONLY, (WPARAM)FALSE, 0);

+

+// MoveWindow(LutDialog, 100, 30, 320, base + 30 + count*30, TRUE);

+// }

+// }

+// BOOL StringToValuesCache(char *str, int *c)

+// {

+// int count = 0;

+// while(*str) {

+// if(*str == '\\') {

+// str++;

+// switch(*str) {

+// case 'r': ValuesCache[count++] = '\r'; break;

+// case 'n': ValuesCache[count++] = '\n'; break;

+// case 'f': ValuesCache[count++] = '\f'; break;

+// case 'b': ValuesCache[count++] = '\b'; break;

+// default: ValuesCache[count++] = *str; break;

+// }

+// } else {

+// ValuesCache[count++] = *str;

+// }

+// if(*str) {

+// str++;

+// }

+// if(count >= 32) {

+// return FALSE;

+// }

+// }

+

+// char buf[10];

+// sprintf(buf, "%d", count);

+// SendMessage(CountTextbox, WM_SETTEXT, 0, (LPARAM)(buf));

+// *c = count;

+// return TRUE;

+// }

+// 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 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);

+// }

+#include "linuxUI.h"

+//#include <commctrl.h>

+//#include <commdlg.h>

+// static HWND HorizScrollBar;

+// static HWND VertScrollBar;

+// static HWND StatusBar;

+// static HMENU FileMenu;

+// static HMENU EditMenu;

+// static HMENU InstructionMenu;

+// static HMENU ProcessorMenu;

+// static HMENU SimulateMenu;

+// static HMENU TopMenu;

+// HWND IoList;

+ // EnableMenuItem(EditMenu, MNU_PUSH_RUNG_UP,

+ // canPushUp ? MF_ENABLED : MF_GRAYED);

+ // EnableMenuItem(EditMenu, MNU_PUSH_RUNG_DOWN,

+ // canPushDown ? MF_ENABLED : MF_GRAYED);

+ // EnableMenuItem(EditMenu, MNU_DELETE_RUNG,

+ // (Prog.numRungs > 1) ? MF_ENABLED : MF_GRAYED);

+

+ // EnableMenuItem(InstructionMenu, MNU_NEGATE,

+ // canNegate ? MF_ENABLED : MF_GRAYED);

+ // EnableMenuItem(InstructionMenu, MNU_MAKE_NORMAL,

+ // canNormal ? MF_ENABLED : MF_GRAYED);

+ // EnableMenuItem(InstructionMenu, MNU_MAKE_RESET_ONLY,

+ // canResetOnly ? MF_ENABLED : MF_GRAYED);

+ // EnableMenuItem(InstructionMenu, MNU_MAKE_SET_ONLY,

+ // canSetOnly ? MF_ENABLED : MF_GRAYED);

+

+ // EnableMenuItem(InstructionMenu, MNU_INSERT_COMMENT,

+ // canInsertComment ? MF_ENABLED : MF_GRAYED);

+

+ // EnableMenuItem(EditMenu, MNU_DELETE_ELEMENT,

+ // canDelete ? MF_ENABLED : MF_GRAYED);

+