//----------------------------------------------------------------------------- // Copyright 2007 Jonathan Westhues // // This file is part of LDmicro. // // LDmicro is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // LDmicro is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with LDmicro. If not, see . //------ // // A ladder logic compiler for 8 bit micros: user draws a ladder diagram, // with an appropriately constrained `schematic editor,' and then we can // simulated it under Windows or generate PIC/AVR code that performs the // requested operations. This files contains the program entry point, plus // most of the UI logic relating to the main window. // Jonathan Westhues, Oct 2004 //----------------------------------------------------------------------------- #include "linuxUI.h" #include #include #include "ldmicro.h" #include "freezeLD.h" #include "mcutable.h" #include #include #include // #include using namespace std; HINSTANCE Instance; QApplication* LDmicroApp; HWID MainWindow; QIcon* MWIcon; QMenuBar* MainMenu; QGroupBox* CursorObject; HWID DrawWindow; // parameters used to capture the mouse when implementing our totally non- // general splitter control //static HHOOK MouseHookHandle; static int MouseY; int CursorTimer; int SimulateTimer; ProgramSlots MenuHandle; // For the open/save dialog boxes #define LDMICRO_PATTERN "LDmicro Ladder Logic Programs (*.ld)\0*.ld\0" \ "All files\0*\0\0" char CurrentSaveFile[MAX_PATH]; static BOOL ProgramChangedNotSaved = FALSE; #define HEX_PATTERN "Intel Hex Files (*.hex)\0*.hex\0All files\0*\0\0" #define C_PATTERN "C Source Files (*.c)\0*.c\0All Files\0*\0\0" #define INTERPRETED_PATTERN \ "Interpretable Byte Code Files (*.int)\0*.int\0All Files\0*\0\0" char CurrentCompileFile[MAX_PATH]; #define TXT_PATTERN "Text Files (*.txt)\0*.txt\0All files\0*\0\0" // Everything relating to the PLC's program, I/O configuration, processor // choice, and so on--basically everything that would be saved in the // project file. PlcProgram Prog; /// Function to safely quit program gtk main loop gboolean LD_WM_Close_call(GtkWidget *widget, GdkEvent *event, gpointer user_data); //----------------------------------------------------------------------------- // Get a filename with a common dialog box and then save the program to that // file and then set our default filename to that. //----------------------------------------------------------------------------- static BOOL SaveAsDialog(void) { OPENFILENAME ofn; memset(&ofn, 0, sizeof(ofn)); ofn.lStructSize = sizeof(ofn); ofn.parentWindow = MainWindow; 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; } } //----------------------------------------------------------------------------- // Get a filename with a common dialog box and then export the program as // an ASCII art drawing. //----------------------------------------------------------------------------- static void ExportDialog(void) { char exportFile[MAX_PATH]; OPENFILENAME ofn; exportFile[0] = '\0'; memset(&ofn, 0, sizeof(ofn)); ofn.lStructSize = sizeof(ofn); ofn.parentWindow = MainWindow; ofn.lpstrFilter = TXT_PATTERN; ofn.lpstrFile = exportFile; ofn.lpstrDefExt = "txt"; ofn.lpstrTitle = _("Export As Text"); ofn.nMaxFile = sizeof(exportFile); ofn.Flags = OFN_PATHMUSTEXIST | OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT; if(!GetSaveFileName(&ofn)) return; ExportDrawingAsText(exportFile); } //----------------------------------------------------------------------------- // If we already have a filename, save the program to that. Otherwise same // as Save As. Returns TRUE if it worked, else returns FALSE. //----------------------------------------------------------------------------- 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(); } } //----------------------------------------------------------------------------- // Compile the program to a hex file for the target micro. Get the output // file name if necessary, then call the micro-specific compile routines. //----------------------------------------------------------------------------- static void CompileProgram(BOOL compileAs) { if(compileAs || strlen(CurrentCompileFile)==0) { OPENFILENAME ofn; memset(&ofn, 0, sizeof(ofn)); ofn.lStructSize = sizeof(ofn); ofn.parentWindow = MainWindow; ofn.lpstrTitle = _("Compile To"); if(Prog.mcu && Prog.mcu->whichIsa == ISA_ANSIC) { ofn.lpstrFilter = C_PATTERN; ofn.lpstrDefExt = "c"; } else if(Prog.mcu && Prog.mcu->whichIsa == ISA_INTERPRETED) { ofn.lpstrFilter = INTERPRETED_PATTERN; ofn.lpstrDefExt = "int"; } else { ofn.lpstrFilter = HEX_PATTERN; ofn.lpstrDefExt = "hex"; } ofn.lpstrFile = CurrentCompileFile; ofn.nMaxFile = sizeof(CurrentCompileFile); ofn.Flags = OFN_PATHMUSTEXIST | OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT; if(!GetSaveFileName(&ofn)) return; // hex output filename is stored in the .ld file ProgramChangedNotSaved = TRUE; } if(!GenerateIntermediateCode()) return; if(Prog.mcu == NULL) { Error(_("Must choose a target microcontroller before compiling.")); return; } if(UartFunctionUsed() && Prog.mcu->uartNeeds.rxPin == 0) { Error(_("UART function used but not supported for this micro.")); return; } if(PwmFunctionUsed() && Prog.mcu->pwmNeedsPin == 0) { Error(_("PWM function used but not supported for this micro.")); return; } switch(Prog.mcu->whichIsa) { case ISA_AVR: CompileAvr(CurrentCompileFile); break; case ISA_PIC16: CompilePic16(CurrentCompileFile); break; case ISA_ANSIC: CompileAnsiC(CurrentCompileFile); break; case ISA_INTERPRETED: CompileInterpreted(CurrentCompileFile); break; case ISA_ARDUINO: CompileArduino(CurrentCompileFile); break; default: oops(); } IntDumpListing("t.pl"); } //----------------------------------------------------------------------------- // If the program has been modified then give the user the option to save it // or to cancel the operation they are performing. Return TRUE if they want // to cancel. //----------------------------------------------------------------------------- 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: return TRUE; oops(); } } //----------------------------------------------------------------------------- // Load a new program from a file. If it succeeds then set our default filename // to that, else we end up with an empty file then. //----------------------------------------------------------------------------- static void OpenDialog(void) { OPENFILENAME ofn; char tempSaveFile[MAX_PATH] = ""; memset(&ofn, 0, sizeof(ofn)); ofn.lStructSize = sizeof(ofn); ofn.parentWindow = MainWindow; ofn.lpstrFilter = LDMICRO_PATTERN; ofn.lpstrDefExt = "ld"; ofn.lpstrFile = tempSaveFile; ofn.nMaxFile = sizeof(tempSaveFile); ofn.Flags = OFN_PATHMUSTEXIST | 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(); } DrawWindow->repaint(); GenerateIoListDontLoseSelection(); RefreshScrollbars(); UpdateMainWindowTitleBar(); } //----------------------------------------------------------------------------- // Housekeeping required when the program changes: mark the program as // changed so that we ask if user wants to save before exiting, and update // the I/O list. //----------------------------------------------------------------------------- void ProgramChanged(void) { ProgramChangedNotSaved = TRUE; GenerateIoListDontLoseSelection(); RefreshScrollbars(); } #define CHANGING_PROGRAM(x) { \ UndoRemember(); \ x; \ ProgramChanged();\ } //----------------------------------------------------------------------------- // Hook that we install when the user starts dragging the `splitter,' in case // they drag it out of the narrow area of the drawn splitter bar. Resize // the listview in response to mouse move, and unhook ourselves when they // release the mouse button. //----------------------------------------------------------------------------- // 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); // } //----------------------------------------------------------------------------- // Handle a selection from the menu bar of the main window. //----------------------------------------------------------------------------- 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; LDmicroApp->exit(); 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(); break; case MNU_START_SIMULATION: StartSimulation(); break; case MNU_STOP_SIMULATION: StopSimulation(); 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; } // gtk_widget_queue_draw(DrawWindow); DrawWindow->repaint(); } // //----------------------------------------------------------------------------- // // WndProc functions for MainWindow. // //----------------------------------------------------------------------------- void PaintWidget::keyPressEvent(QKeyEvent* event) { // if(event->key() == ) int wParam = event->key(); /*if(wParam == VK_TAB) { // SetFocus(IoList); gtk_window_set_focus (GTK_WINDOW(MainWindow), view); // BlinkCursor(0, 0, 0, 0); }*/ if(InSimulationMode) { switch(wParam) { case VK_DOWN: /*if(ScrollYOffset < ScrollYOffsetMax) ScrollYOffset++;*/ RefreshScrollbars(); DrawWindow->repaint(); break; case VK_UP: /*if(ScrollYOffset > 0) ScrollYOffset--;*/ RefreshScrollbars(); DrawWindow->repaint(); break; case VK_LEFT: // ScrollXOffset -= FONT_WIDTH; // if(ScrollXOffset < 0) /* ScrollXOffset = 0; RefreshScrollbars();*/ DrawWindow->repaint(); break; case VK_RIGHT: /*ScrollXOffset += FONT_WIDTH; if(ScrollXOffset >= ScrollXOffsetMax) ScrollXOffset = ScrollXOffsetMax; RefreshScrollbars();*/ DrawWindow->repaint(); break; case VK_RETURN: case VK_ESCAPE: ToggleSimulationMode(); break; } } switch(wParam) { case VK_UP: if(event->modifiers() & Qt::ShiftModifier) { CHANGING_PROGRAM(PushRungUp()); } else { MoveCursorKeyboard(wParam); } DrawWindow->repaint(); break; case VK_DOWN: if(event->modifiers() & Qt::ShiftModifier) { CHANGING_PROGRAM(PushRungDown()); } else { MoveCursorKeyboard(wParam); } DrawWindow->repaint(); break; case VK_RIGHT: case VK_LEFT: MoveCursorKeyboard(wParam); DrawWindow->repaint(); break; case VK_RETURN: CHANGING_PROGRAM(EditSelectedElement()); DrawWindow->repaint(); break; default: break; } return; } void MyWidget::closeEvent(QCloseEvent* event) { if(CheckSaveUserCancels()) event->ignore(); else event->accept(); /*GdkRectangle allocation; gtk_widget_get_allocation(GTK_WIDGET(view), &allocation); IoListHeight = allocation.height; FreezeWindowPos(MainWindow); FreezeDWORD(IoListHeight);*/ } // gboolean LD_WM_KeyDown_call(GtkWidget *widget, GdkEventKey *event, gpointer user_data) // { // /* Handles: // * WM_KEYDOWN // */ // UINT wParam = event->keyval; // if(wParam == VK_TAB) { // // SetFocus(IoList); // gtk_window_set_focus (GTK_WINDOW(MainWindow), view); // // BlinkCursor(0, 0, 0, 0); // } // if(InSimulationMode) // { // switch(wParam) // { // case VK_DOWN: // if(ScrollYOffset < ScrollYOffsetMax) // ScrollYOffset++; // RefreshScrollbars(); // gtk_widget_queue_draw(DrawWindow); // break; // case VK_UP: // if(ScrollYOffset > 0) // ScrollYOffset--; // RefreshScrollbars(); // gtk_widget_queue_draw(DrawWindow); // break; // case VK_LEFT: // ScrollXOffset -= FONT_WIDTH; // if(ScrollXOffset < 0) // ScrollXOffset = 0; // RefreshScrollbars(); // gtk_widget_queue_draw(DrawWindow); // break; // case VK_RIGHT: // ScrollXOffset += FONT_WIDTH; // if(ScrollXOffset >= ScrollXOffsetMax) // ScrollXOffset = ScrollXOffsetMax; // RefreshScrollbars(); // gtk_widget_queue_draw(DrawWindow); // break; // case VK_RETURN: // case VK_ESCAPE: // ToggleSimulationMode(); // break; // } // } // switch(wParam) // { // case VK_UP: // if(event->state & GDK_SHIFT_MASK) // { // CHANGING_PROGRAM(PushRungUp()); // } // else // { // MoveCursorKeyboard(wParam); // } // gtk_widget_queue_draw(DrawWindow); // break; // case VK_DOWN: // if(event->state & GDK_SHIFT_MASK) // { // CHANGING_PROGRAM(PushRungDown()); // } // else // { // MoveCursorKeyboard(wParam); // } // gtk_widget_queue_draw(DrawWindow); // break; // case VK_RIGHT: // case VK_LEFT: // MoveCursorKeyboard(wParam); // gtk_widget_queue_draw(DrawWindow); // break; // case VK_RETURN: // CHANGING_PROGRAM(EditSelectedElement()); // gtk_widget_queue_draw(DrawWindow); // break; // default: // break; // } // return FALSE; // } // gboolean LD_WM_Close_call(GtkWidget *widget, GdkEvent *event, gpointer user_data) // { // /* Handles: // * WM_CLOSE // */ // if(CheckSaveUserCancels()) // return TRUE; // GdkRectangle allocation; // gtk_widget_get_allocation(GTK_WIDGET(view), &allocation); // IoListHeight = allocation.height; // FreezeWindowPos(MainWindow); // FreezeDWORD(IoListHeight); // g_print("List Height close: %d\n",IoListHeight); // gtk_main_quit(); // gdk_threads_leave(); // } // gboolean LD_GTK_mouse_click_hook(GtkWidget *widget, GdkEvent *event, gpointer user_data) // { // /* Handles: // * WM_LBUTTONDBLCLK, WM_LBUTTONDOWN // */ // RECT Rect; // GetWindowRect(ScrollWindow, &Rect); // int wy; // gtk_window_get_position(GTK_WINDOW(MainWindow), NULL, &wy); // // g_print("net: %i\n", wy + 30 + Rect.bottom); // /// Identify if mouse is clicked outside drawing area // if (wy + 30 + Rect.bottom < event->button.y_root) // return FALSE; // GtkAdjustment *adjustment = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(ScrollWindow)); // switch(event->button.type) // { // case GDK_BUTTON_PRESS: // if (event->button.button == 1) /// left click // { // GLOBAL_mouse_last_clicked_x = event->button.x_root; // GLOBAL_mouse_last_clicked_y = event->button.y_root; // int x = event->button.x; // int y = event->button.y - 30 + gtk_adjustment_get_value(adjustment); // if(!InSimulationMode) MoveCursorMouseClick(x, y); // gtk_widget_queue_draw(DrawWindow); // } // break; // case GDK_2BUTTON_PRESS: // if (event->button.button == 1) /// left click // { // GLOBAL_mouse_last_clicked_x = event->button.x_root; // GLOBAL_mouse_last_clicked_y = event->button.y_root; // int x = event->button.x; // int y = event->button.y - 30 + gtk_adjustment_get_value(adjustment); // if(InSimulationMode) { // EditElementMouseDoubleclick(x, y); // } else { // CHANGING_PROGRAM(EditElementMouseDoubleclick(x, y)); // } // gtk_widget_queue_draw(DrawWindow); // } // break; // } // return FALSE; // } void PaintWidget :: mouseReleaseEvent(QMouseEvent* event) { /* Handles: * WM_LBUTTONDBLCLK, WM_LBUTTONDOWN */ QRect Rect; Rect = DrawWindow->rect(); QPoint wy = event->pos(); // printf("mouseReleaseEvent: x:%d,y:%d",wy.x(),wy.y()); if((wy.x() <= 0) || (wy.y() <= 0)) return; //No need to identify if mouse is outside the scope as the function is not called // GtkAdjustment *adjustment = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(ScrollWindow)); switch(event->button()) { case Qt::LeftButton: GLOBAL_mouse_last_clicked_x = event->x(); GLOBAL_mouse_last_clicked_y = event->y(); /*int x = event->button.x; int y = event->button.y - 30 + gtk_adjustment_get_value(adjustment);*/ if(!InSimulationMode) MoveCursorMouseClick(wy.x(), wy.y()); // gtk_widget_queue_draw(DrawWindow); DrawWindow->repaint(); break; // return FALSE; } } void PaintWidget :: mouseDoubleClickEvent(QMouseEvent* event) { QRect Rect; Rect = DrawWindow->rect(); QPoint wy = DrawWindow->mapFrom(MainWindow, event->pos()); if((wy.x() <= 0) || (wy.y() <= 0)) return; switch (event->button()) { case Qt::LeftButton: GLOBAL_mouse_last_clicked_x = event->x(); GLOBAL_mouse_last_clicked_y = event->y(); /*int x = event->button.x; int y = event->button.y - 30 + gtk_adjustment_get_value(adjustment);*/ if(InSimulationMode) { EditElementMouseDoubleclick(wy.x(), wy.y()); } else { CHANGING_PROGRAM(EditElementMouseDoubleclick(wy.x(), wy.y())); } // gtk_widget_queue_draw(DrawWindow); DrawWindow->repaint(); break; } } // gboolean LD_GTK_mouse_scroll_hook(GtkWidget *widget, GdkEvent *event, gpointer user_data) // { // /* Handles: // * WM_VSCROLL, WM_HSCROLL, WM_MOUSEWHEEL // */ // GtkAdjustment *adjustment = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(ScrollWindow)); // switch(event->scroll.direction) // { // case GDK_SCROLL_UP: // if (gtk_adjustment_get_value(adjustment) == gtk_adjustment_get_lower(adjustment)) // VscrollProc(SB_TOP); // else // VscrollProc(SB_LINEUP); // break; // case GDK_SCROLL_DOWN: // if (gtk_adjustment_get_value(adjustment) == gtk_adjustment_get_upper(adjustment) - gtk_widget_get_allocated_height (ScrollWindow)) // VscrollProc(SB_BOTTOM); // else // VscrollProc(SB_LINEDOWN); // break; // case GDK_SCROLL_LEFT: // HscrollProc(SB_LINEUP); // break; // case GDK_SCROLL_RIGHT: // HscrollProc(SB_LINEDOWN); // break; // case GDK_SCROLL_SMOOTH: // double d_x, d_y; // gdk_event_get_scroll_deltas (event, &d_x, &d_y); // if(d_y > 0) { // VscrollProc(SB_LINEUP); // } else { // VscrollProc(SB_LINEDOWN); // } // break; // } // gtk_widget_queue_draw(DrawWindow); // return FALSE; // } // gboolean LD_WM_MouseMove_call(GtkWidget *widget, GdkEvent *event, gpointer user_data) // { // /* Handles: // * 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)); // // } // // int dy = MouseY - mhs->pt.y; // // int dy = MouseY - mhs->pt.y; // // IoListHeight += dy; // // if(IoListHeight < 50) IoListHeight = 50; // // MouseY = mhs->pt.y; // // MainWindowResized(); // return FALSE; // } // gboolean LD_WM_Paint_call(HWID widget, HCRDC cr, gpointer data) // { // /* Handles: // * WM_PAINT // */ // static BOOL Paint_call_first = TRUE; // if (Paint_call_first) // { // gtk_widget_override_background_color(GTK_WIDGET(widget), // GTK_STATE_FLAG_NORMAL, (HBRUSH)GetStockObject(BLACK_BRUSH)); // gint width = gtk_widget_get_allocated_width (widget); // gint height = gtk_widget_get_allocated_height (widget); // gtk_widget_set_size_request(widget, width, height + 1); // gdk_cairo_set_source_rgba (cr, (HBRUSH)GetStockObject(BLACK_BRUSH)); // cairo_rectangle(cr, 0, 0, width, height); // cairo_stroke_preserve(cr); // cairo_fill (cr); // Paint_call_first = FALSE; // } // /// This draws the schematic. // MainWindowResized(); // PaintWindow(cr); // return FALSE; // } // gboolean LD_WM_Destroy_call(GtkWidget *widget, GdkEvent *event, gpointer user_data) // { // /* Handles: // * WM_DESTROY // */ // if(CheckSaveUserCancels()) // return TRUE; // FreezeWindowPos(MainWindow); // FreezeDWORD(IoListHeight); // gtk_main_quit(); // gdk_threads_leave(); // } // gboolean LD_WM_Size_call(GtkWidget *widget, GdkEvent *event, gpointer user_data) // { // /* Handles: // * WM_SIZE // */ // MainWindowResized(); // return FALSE; // } void ProgramSlots :: LD_WM_Command_call(int CommandCode) { ProcessMenu(CommandCode); } // gboolean LD_WM_SetFocus_call(GtkWidget *widget, GdkEvent *event, gpointer user_data) // { // /* Handles: // * WM_SETFOCUS // */ // InvalidateRect(DrawWindow, NULL, FALSE); // return FALSE; // } // void LD_WM_Notify_Row_Activate_call(GtkTreeView *tree_view, GtkTreePath *path, GtkTreeViewColumn *column, gpointer user_data) // { // /* Handles: // * WM_NOTIFY // */ // // g_print("Row activated!\n"); // int *ip = gtk_tree_path_get_indices ( path ); // NMHDR h; // h.code = LVN_ITEMACTIVATE; // h.item.iItem = ip[0]; // h.hlistFrom = IoList; // IoListProc(&h); // } // void LD_WM_Notify_Cursor_Change_call(GtkTreeView *tree_view, gpointer user_data) // { // /* Handles: // * WM_NOTIFY // */ // ITLIST iter; // // BOOL empty = !gtk_tree_model_get_iter_first (IoList, &iter); // // g_print("empty = %i\n", (empty == TRUE) ); // HLIST pTreeModel; // int *ip; // GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view)); // gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE); // if(gtk_tree_selection_get_selected (selection, &pTreeModel, &iter)) // { // GtkTreePath *path = gtk_tree_model_get_path ( pTreeModel , &iter ) ; // ip = gtk_tree_path_get_indices ( path ); // } // else // if(!gtk_tree_model_get_iter_first (IoList, &iter)) // return; // NMHDR h; // h.code = LVN_GETDISPINFO; // h.item.iItem = (ip == NULL) ? 0 : ip[0]; // h.hlistFrom = IoList; // h.hlistIter = &iter; // IoListProc(&h); // } inline void MenuHandler () { QSignalMapper* CommandMapper = new QSignalMapper (&MenuHandle); //Create mappings for each menu item CommandMapper->setMapping(NewMenu, MNU_NEW); CommandMapper->setMapping(OpenMenu, MNU_OPEN); CommandMapper->setMapping(SaveMenu, MNU_SAVE); CommandMapper->setMapping(SaveAsMenu, MNU_SAVE_AS); CommandMapper->setMapping(ExportMenu, MNU_EXPORT); CommandMapper->setMapping(ExitMenu, MNU_EXIT); CommandMapper->setMapping(InsertCommentMenu, MNU_INSERT_COMMENT); CommandMapper->setMapping(InsertContactsMenu, MNU_INSERT_CONTACTS); CommandMapper->setMapping(InsertCoilMenu, MNU_INSERT_COIL); CommandMapper->setMapping(InsertTonMenu, MNU_INSERT_TON); CommandMapper->setMapping(InsertTofMenu, MNU_INSERT_TOF); CommandMapper->setMapping(InsertRtoMenu, MNU_INSERT_RTO); CommandMapper->setMapping(InsertCtuMenu, MNU_INSERT_CTU); CommandMapper->setMapping(InsertCtdMenu, MNU_INSERT_CTD); CommandMapper->setMapping(InsertCtcMenu, MNU_INSERT_CTC); CommandMapper->setMapping(InsertResMenu, MNU_INSERT_RES); CommandMapper->setMapping(InsertOpenMenu, MNU_INSERT_OPEN); CommandMapper->setMapping(InsertShortMenu, MNU_INSERT_SHORT); CommandMapper->setMapping(InsertMasterRlyMenu, MNU_INSERT_MASTER_RLY); CommandMapper->setMapping(InsertShiftRegMenu, MNU_INSERT_SHIFT_REG); CommandMapper->setMapping(InsertLutMenu, MNU_INSERT_LUT); CommandMapper->setMapping(InsertPwlMenu, MNU_INSERT_PWL); CommandMapper->setMapping(InsertFmtdStrMenu, MNU_INSERT_FMTD_STR); CommandMapper->setMapping(InsertOsrMenu, MNU_INSERT_OSR); CommandMapper->setMapping(InsertOsfMenu, MNU_INSERT_OSF); CommandMapper->setMapping(InsertMovMenu, MNU_INSERT_MOV); CommandMapper->setMapping(InsertSetPwmMenu, MNU_INSERT_SET_PWM); CommandMapper->setMapping(InsertReadAdcMenu, MNU_INSERT_READ_ADC); CommandMapper->setMapping(InsertUartSendMenu, MNU_INSERT_UART_SEND); CommandMapper->setMapping(InsertUartRecvMenu, MNU_INSERT_UART_RECV); CommandMapper->setMapping(InsertPersistMenu, MNU_INSERT_PERSIST); CommandMapper->setMapping(InsertAddMenu, MNU_INSERT_ADD); CommandMapper->setMapping(InsertSubMenu, MNU_INSERT_SUB); CommandMapper->setMapping(InsertMulMenu, MNU_INSERT_MUL); CommandMapper->setMapping(InsertDivMenu, MNU_INSERT_DIV); CommandMapper->setMapping(InsertEquMenu, MNU_INSERT_EQU); CommandMapper->setMapping(InsertNeqMenu, MNU_INSERT_NEQ); CommandMapper->setMapping(InsertGrtMenu, MNU_INSERT_GRT); CommandMapper->setMapping(InsertGeqMenu, MNU_INSERT_GEQ); CommandMapper->setMapping(InsertLesMenu, MNU_INSERT_LES); CommandMapper->setMapping(InsertLeqMenu, MNU_INSERT_LEQ); CommandMapper->setMapping(MakeNormalMenu, MNU_MAKE_NORMAL); CommandMapper->setMapping(NegateMenu, MNU_NEGATE); CommandMapper->setMapping(MakeSetOnlyMenu, MNU_MAKE_SET_ONLY); CommandMapper->setMapping(MakeResetOnlyMenu, MNU_MAKE_RESET_ONLY); CommandMapper->setMapping(UndoMenu, MNU_UNDO); CommandMapper->setMapping(RedoMenu, MNU_REDO); CommandMapper->setMapping(InsertRungBeforeMenu, MNU_INSERT_RUNG_BEFORE); CommandMapper->setMapping(InsertRungAfterMenu, MNU_INSERT_RUNG_AFTER); CommandMapper->setMapping(DeleteRungMenu, MNU_DELETE_RUNG); CommandMapper->setMapping(PushRungUpMenu, MNU_PUSH_RUNG_UP); CommandMapper->setMapping(PushRungDownMenu, MNU_PUSH_RUNG_DOWN); CommandMapper->setMapping(DeleteElementMenu, MNU_DELETE_ELEMENT); CommandMapper->setMapping(McuSettingsMenu, MNU_MCU_SETTINGS); CommandMapper->setMapping(SimulationModeMenu, MNU_SIMULATION_MODE); CommandMapper->setMapping(StartSimulationMenu, MNU_START_SIMULATION); CommandMapper->setMapping(StopSimulationMenu, MNU_STOP_SIMULATION); CommandMapper->setMapping(SingleCycleMenu, MNU_SINGLE_CYCLE); CommandMapper->setMapping(CompileMenu, MNU_COMPILE); CommandMapper->setMapping(CompileAsMenu, MNU_COMPILE_AS); CommandMapper->setMapping(ManualMenu, MNU_MANUAL); CommandMapper->setMapping(AboutMenu, MNU_ABOUT); QObject::connect(NewMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(OpenMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(SaveMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(SaveAsMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(ExportMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(ExitMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); // QObject::connect(ExitMenu, SIGNAL(triggered()), LDmicroApp, SLOT(quit())); QObject::connect(InsertCommentMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(InsertContactsMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(InsertCoilMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(InsertTonMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(InsertTofMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(InsertRtoMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(InsertCtuMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(InsertCtdMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(InsertCtcMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(InsertResMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(InsertOpenMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(InsertShortMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(InsertMasterRlyMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(InsertShiftRegMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(InsertLutMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(InsertPwlMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(InsertFmtdStrMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(InsertOsrMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(InsertOsfMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(InsertMovMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(InsertSetPwmMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(InsertReadAdcMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(InsertUartSendMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(InsertUartRecvMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(InsertPersistMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(InsertAddMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(InsertSubMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(InsertMulMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(InsertDivMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(InsertEquMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(InsertNeqMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(InsertGrtMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(InsertGeqMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(InsertLesMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(InsertLeqMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(MakeNormalMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(NegateMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(MakeSetOnlyMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(MakeResetOnlyMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(UndoMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(RedoMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(InsertRungBeforeMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(InsertRungAfterMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(DeleteRungMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(PushRungUpMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(PushRungDownMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(DeleteElementMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(McuSettingsMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(SimulationModeMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(StartSimulationMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(StopSimulationMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(SingleCycleMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(CompileMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(CompileAsMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(ManualMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); QObject::connect(AboutMenu, SIGNAL(triggered()), CommandMapper, SLOT(map())); // Connect microcontroller signals automatically for(int i = 0; i < NUM_SUPPORTED_MCUS; i++) { CommandMapper->setMapping(ProcessorMenuItems[i], (MNU_PROCESSOR_0 + i)); QObject::connect(ProcessorMenuItems[i], SIGNAL(triggered()), CommandMapper, SLOT(map())); } //Connect map to combined function call QObject::connect (CommandMapper, SIGNAL(mapped(int)), &MenuHandle, SLOT(LD_WM_Command_call(int))) ; // QObject::connect(ExitMenu, SIGNAL(changed()), LDmicroApp, SLOT(aboutQt())); // g_signal_connect(G_OBJECT(NewMenu), "activate", // G_CALLBACK(LD_WM_Command_call), GINT_TO_POINTER(MNU_NEW)); // g_signal_connect(G_OBJECT(OpenMenu), "activate", // G_CALLBACK(LD_WM_Command_call), GINT_TO_POINTER(MNU_OPEN)); // g_signal_connect(G_OBJECT(SaveMenu), "activate", // G_CALLBACK(LD_WM_Command_call), GINT_TO_POINTER(MNU_SAVE)); // g_signal_connect(G_OBJECT(SaveAsMenu), "activate", // G_CALLBACK(LD_WM_Command_call), GINT_TO_POINTER(MNU_SAVE_AS)); // g_signal_connect(G_OBJECT(ExportMenu), "activate", // G_CALLBACK(LD_WM_Command_call), GINT_TO_POINTER(MNU_EXPORT)); // g_signal_connect(G_OBJECT(ExitMenu), "activate", // G_CALLBACK(LD_WM_Command_call), GINT_TO_POINTER(MNU_EXIT)); // // Connect microcontroller signals automatically // for(int i = 0; i < NUM_SUPPORTED_MCUS; i++) // { // g_signal_connect(G_OBJECT(ProcessorMenuItems[i]), "toggled", // G_CALLBACK(ProcessorCall), GINT_TO_POINTER((MNU_PROCESSOR_0 + i))); // } } void ActivateItem(QTreeWidgetItem* item, int column) { NMHDR h; h.code = LVN_ITEMACTIVATE; h.hlistFrom = IoList; h.item.iItem = IoList->indexOfTopLevelItem(item); QTreeWidgetItem* selection; IoListProc(&h); } //----------------------------------------------------------------------------- // Entry point into the program. //----------------------------------------------------------------------------- int main(int argc, char** argv) { /// Check if we're running in non-interactive mode; in that case we should /// load the file, compile, and exit. if(argc >= 2) { RunningInBatchMode = TRUE; char *err = "Bad command line arguments: run 'ldmicro /c src.ld dest.hex'\n"; if(argc < 4) { printf(err); exit(-1); } char *source = (char*)malloc(strlen(argv[2]) + strlen(argv[3]) + 2); sprintf(source, "%s %s", argv[2], argv[3]); while(isspace(*source)) { source++; } if(*source == '\0') { Error(err); free(source); exit(-1); } char *dest = source; while(!isspace(*dest) && *dest) { dest++; } if(*dest == '\0') { Error(err); free(source); exit(-1); } *dest = '\0'; dest++; while(isspace(*dest)) { dest++; } if(*dest == '\0') { Error(err); free(source); exit(-1); } if(!LoadProjectFromFile(source)) { Error("Couldn't open '%s', running non-interactively.\n", source); free(source); exit(-1); } strcpy(CurrentCompileFile, dest); GenerateIoList(-1); CompileProgram(FALSE); exit(0); } //Basic qt application ::QApplication app(argc, argv); LDmicroApp = &app; MainHeap = HeapCreate(0, 1024*64, 0); QSize MwSize(800,600); // Make main window MainWindow = new MyWidget(); MWIcon = new QIcon(LDMICRO_ICON); MainMenu = new QMenuBar(MainWindow); // Initialize cursor and set color CursorObject = new QGroupBox(DrawWindow); // CursorObject->setColor(); // QMenu TopMenu("Top Menu", MainWindow); // MainMenu->addMenu(&TopMenu); // MainWindow->layout()->setMenuBar(MainMenu); MainWindow->setWindowTitle("LDmicro"); MainWindow->resize(MwSize); MainWindow->move( 10, 10); // MainWindow->setStyleSheet("background-color: black;"); //Default Icon for entire app app.setWindowIcon(*MWIcon); //Icon for main window MainWindow->setWindowIcon(*MWIcon); MakeMainWindowMenus(); MakeDialogBoxClass(); InitForDrawing(); ThawWindowPos(MainWindow); IoListHeight = 100; ThawDWORD(IoListHeight); MakeMainWindowControls(); MainWindowResized(); MenuHandler(); NewProgram(); strcpy(CurrentSaveFile, ""); MainWindow->show(); /// Blink cursor CursorTimer = SetTimer(DrawWindow, TIMER_BLINK_CURSOR, 500, CursorTimer); GenerateIoListDontLoseSelection(); // RefreshScrollbars(); UpdateMainWindowTitleBar(); QObject::connect(IoList, &QTreeWidget::itemActivated, ActivateItem); // MakeDialogBoxClass(); /*ThawWindowPos(MainWindow); ThawDWORD(IoListHeight); g_print("IoListHeight start: %d\n", IoListHeight); MakeMainWindowControls(); /// takes care of MakeMainWindowMenus() MainWindowResized(); /// Keyboard and mouse hooks equivalent to MainWndProc g_signal_connect (MainWindow, "delete_event", G_CALLBACK (LD_WM_Close_call), NULL); g_signal_connect (MainWindow, "key_press_event", G_CALLBACK (LD_WM_KeyDown_call), NULL); g_signal_connect (MainWindow, "button_press_event", G_CALLBACK (LD_GTK_mouse_click_hook), NULL); g_signal_connect (MainWindow, "scroll_event", G_CALLBACK (LD_GTK_mouse_scroll_hook), NULL); g_signal_connect (MainWindow, "motion_notify_event", G_CALLBACK (LD_WM_MouseMove_call), NULL); g_signal_connect (DrawWindow, "draw", G_CALLBACK (LD_WM_Paint_call), NULL); g_signal_connect (MainWindow, "destroy_event", G_CALLBACK (LD_WM_Destroy_call), NULL); g_signal_connect (MainWindow, "configure_event", G_CALLBACK (LD_WM_Size_call), NULL); g_signal_connect (MainWindow, "focus_in_event", G_CALLBACK (LD_WM_SetFocus_call), NULL); g_signal_connect (view, "row_activated", G_CALLBACK (LD_WM_Notify_Row_Activate_call), NULL); g_signal_connect (view, "cursor_changed", G_CALLBACK (LD_WM_Notify_Cursor_Change_call), NULL); MenuHandler(); /// Keyboard and mouse hooks equivalent to MainWndProc - end 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. /// Displaying the window gtk_widget_show_all(MainWindow); /// Blink cursor SetTimer(DrawWindow, TIMER_BLINK_CURSOR, 200, BlinkCursor); // SetTimer(MainWindow, TIMER_BLINK_CURSOR, 800, BlinkCursor); */ /*if(argc >= 2) { char line[MAX_PATH]; if(*argv[1] == '"') { strcpy(line, argv[1]+1); } else { strcpy(line, argv[1]); } if(strchr(line, '"')) *strchr(line, '"') = '\0'; realpath(line, CurrentSaveFile); 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); // } /* gtk_main(); return EXIT_SUCCESS;*/ return app.exec(); delete MainWindow; delete MWIcon; }