//----------------------------------------------------------------------------- // 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 . //------ // // Common controls in the main window. The main window consists of the drawing // area, where the ladder diagram is displayed, plus various controls for // scrolling, I/O list, menus. // Jonathan Westhues, Nov 2004 //----------------------------------------------------------------------------- #include "linuxUI.h" #include //#include //#include #include #include #include "ldmicro.h" // Menu IDs HMENU NewMenu; HMENU OpenMenu; HMENU SaveMenu; HMENU SaveAsMenu; HMENU ExportMenu; HMENU ExitMenu; HMENU UndoMenu; HMENU RedoMenu; HMENU PushRungUpMenu; HMENU PushRungDownMenu; HMENU InsertRungBeforeMenu; HMENU InsertRungAfterMenu; HMENU DeleteElementMenu; HMENU DeleteRungMenu; HMENU InsertCommentMenu; HMENU InsertContactsMenu; HMENU InsertCoilMenu; HMENU InsertTonMenu; HMENU InsertTofMenu; HMENU InsertRtoMenu; HMENU InsertResMenu; HMENU InsertOsrMenu; HMENU InsertOsfMenu; HMENU InsertCtuMenu; HMENU InsertCtdMenu; HMENU InsertCtcMenu; HMENU InsertAddMenu; HMENU InsertSubMenu; HMENU InsertMulMenu; HMENU InsertDivMenu; HMENU InsertMovMenu; HMENU InsertReadAdcMenu; HMENU InsertSetPwmMenu; HMENU InsertUartSendMenu; HMENU InsertUartRecvMenu; HMENU InsertEquMenu; HMENU InsertNeqMenu; HMENU InsertGrtMenu; HMENU InsertGeqMenu; HMENU InsertLesMenu; HMENU InsertLeqMenu; HMENU InsertOpenMenu; HMENU InsertShortMenu; HMENU InsertMasterRlyMenu; HMENU InsertShiftRegMenu; HMENU InsertLutMenu; HMENU InsertFmtdStrMenu; HMENU InsertPersistMenu; HMENU MakeNormalMenu; HMENU NegateMenu; HMENU MakeSetOnlyMenu; HMENU MakeResetOnlyMenu; HMENU InsertPwlMenu; HMENU McuSettingsMenu; HMENU ProcessorMenuItems[NUM_SUPPORTED_MCUS+1]; HMENU MicroControllerMenu; // Item for Microcontroller HMENU SimulationModeMenu; HMENU StartSimulationMenu; HMENU StopSimulationMenu; HMENU SingleCycleMenu; HMENU CompileMenu; HMENU CompileAsMenu; HMENU ManualMenu; HMENU AboutMenu; // scrollbars for the ladder logic area // static HWND HorizScrollBar; // static HWND VertScrollBar; int ScrollWidth; int ScrollHeight; BOOL NeedHoriz; // status bar at the bottom of the screen, to display settings static HMENU StatusBar[3]; // have to get back to the menus to gray/ungray, check/uncheck things static HMENU FileMenu; static HMENU EditMenu; static HMENU InstructionMenu; static HMENU ProcessorMenu; static HMENU SimulateMenu; static HMENU TopMenu; // Menu Bar static HMENU Settings; static HMENU Compile; static HMENU Help; HMENU ScrollWindow; // listview used to maintain the list of I/O pins with symbolic names, plus // the internal relay too HLIST IoList; static int IoListSelectionPoint; static BOOL IoListOutOfSync; int IoListHeight; int IoListTop; // whether the simulation is running in real time static BOOL RealTimeSimulationRunning; void CheckMenuItem(HMENU MenuName, HMENU MenuItem, UINT Check) { g_signal_handlers_block_matched(MenuItem, G_SIGNAL_MATCH_FUNC,NULL,NULL,NULL, (void*)LD_WM_Command_call, (void*)NULL); switch (Check){ case MF_CHECKED : gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM(MenuItem), true); break; case MF_UNCHECKED : gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM(MenuItem), false); break; } g_signal_handlers_unblock_matched(G_OBJECT(MenuItem), G_SIGNAL_MATCH_FUNC,NULL,NULL,NULL, (void*)LD_WM_Command_call, GINT_TO_POINTER(MNU_SIMULATION_MODE)); } // Displaying keyboard shortcuts for each menu item void AddMenuAccelerators (void){ // Declaring the accelerator group for keyboard shortcuts AccelGroup = gtk_accel_group_new (); // Creating keyboard shortcuts for File menu gtk_widget_add_accelerator (NewMenu, "activate", AccelGroup, GDK_KEY_N, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (OpenMenu, "activate", AccelGroup, GDK_KEY_O, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (SaveMenu, "activate", AccelGroup, GDK_KEY_S, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (ExportMenu, "activate", AccelGroup, GDK_KEY_E, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); // Creating keyboard shortcuts for Edit menu gtk_widget_add_accelerator (UndoMenu, "activate", AccelGroup, GDK_KEY_Z, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (RedoMenu, "activate", AccelGroup, GDK_KEY_Y, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (InsertRungBeforeMenu, "activate", AccelGroup, GDK_KEY_F6, GDK_SHIFT_MASK, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (InsertRungAfterMenu, "activate", AccelGroup, GDK_KEY_V, GDK_SHIFT_MASK, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (PushRungUpMenu, "activate", AccelGroup, GDK_KEY_uparrow, GDK_SHIFT_MASK, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (PushRungDownMenu, "activate", AccelGroup, GDK_KEY_downarrow, GDK_SHIFT_MASK, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (DeleteElementMenu, "activate", AccelGroup, GDK_KEY_Delete, (GdkModifierType)0, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (DeleteRungMenu, "activate", AccelGroup, GDK_KEY_Delete, GDK_SHIFT_MASK, GTK_ACCEL_VISIBLE); // Creating keyboard shortcuts for Instructions menu gtk_widget_add_accelerator (InsertCommentMenu, "activate", AccelGroup, GDK_KEY_semicolon, (GdkModifierType)0, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (InsertContactsMenu, "activate", AccelGroup, GDK_KEY_C, (GdkModifierType)0, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (InsertOsrMenu, "activate", AccelGroup, GDK_KEY_backslash, (GdkModifierType)0, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (InsertOsfMenu, "activate", AccelGroup, GDK_KEY_slash, (GdkModifierType)0, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (InsertTonMenu, "activate", AccelGroup, GDK_KEY_O, (GdkModifierType)0, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (InsertTofMenu, "activate", AccelGroup, GDK_KEY_F, (GdkModifierType)0, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (InsertRtoMenu, "activate", AccelGroup, GDK_KEY_T, (GdkModifierType)0, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (InsertCtuMenu, "activate", AccelGroup, GDK_KEY_U, (GdkModifierType)0, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (InsertCtdMenu, "activate", AccelGroup, GDK_KEY_I, (GdkModifierType)0, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (InsertCtcMenu, "activate", AccelGroup, GDK_KEY_J, (GdkModifierType)0, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (InsertEquMenu, "activate", AccelGroup, GDK_KEY_equal, (GdkModifierType)0, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (InsertGrtMenu, "activate", AccelGroup, GDK_KEY_greater, (GdkModifierType)0, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (InsertGeqMenu, "activate", AccelGroup, GDK_KEY_Stop, (GdkModifierType)0, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (InsertLesMenu, "activate", AccelGroup, GDK_KEY_less, (GdkModifierType)0, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (InsertLeqMenu, "activate", AccelGroup, GDK_KEY_comma, (GdkModifierType)0, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (InsertCoilMenu, "activate", AccelGroup, GDK_KEY_L, (GdkModifierType)0, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (InsertResMenu, "activate", AccelGroup, GDK_KEY_E, (GdkModifierType)0, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (InsertMovMenu, "activate", AccelGroup, GDK_KEY_M, (GdkModifierType)0, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (InsertAddMenu, "activate", AccelGroup, GDK_KEY_plus, (GdkModifierType)0, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (InsertSubMenu, "activate", AccelGroup, GDK_KEY_minus, (GdkModifierType)0, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (InsertMulMenu, "activate", AccelGroup, GDK_KEY_multiply, (GdkModifierType)0, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (InsertDivMenu, "activate", AccelGroup, GDK_KEY_D, (GdkModifierType)0, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (InsertReadAdcMenu, "activate", AccelGroup, GDK_KEY_P, (GdkModifierType)0, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (MakeNormalMenu, "activate", AccelGroup, GDK_KEY_A, (GdkModifierType)0, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (NegateMenu, "activate", AccelGroup, GDK_KEY_N, (GdkModifierType)0, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (MakeSetOnlyMenu, "activate", AccelGroup, GDK_KEY_S, (GdkModifierType)0, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (MakeResetOnlyMenu, "activate", AccelGroup, GDK_KEY_R, (GdkModifierType)0, GTK_ACCEL_VISIBLE); // Creating keyboard shortcuts for Simulation menu gtk_widget_add_accelerator (SimulationModeMenu, "activate", AccelGroup, GDK_KEY_M, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (StartSimulationMenu, "activate", AccelGroup, GDK_KEY_R, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (StopSimulationMenu, "activate", AccelGroup, GDK_KEY_H, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (SingleCycleMenu, "activate", AccelGroup, GDK_KEY_space, (GdkModifierType)0, GTK_ACCEL_VISIBLE); // Creating keyboard shortcuts for Compile menu gtk_widget_add_accelerator (CompileMenu, "activate", AccelGroup, GDK_KEY_F5, (GdkModifierType)0, GTK_ACCEL_VISIBLE); // Creating keyboard shortcuts for Help menu gtk_widget_add_accelerator (ManualMenu, "activate", AccelGroup, GDK_KEY_F1, (GdkModifierType)0, GTK_ACCEL_VISIBLE); gtk_window_add_accel_group (GTK_WINDOW (MainWindow), AccelGroup); } //----------------------------------------------------------------------------- // Create the top-level menu bar for the main window. Mostly static, but we // create the "select processor" menu from the list in mcutable.h dynamically. //----------------------------------------------------------------------------- HMENU MakeMainWindowMenus(void) { HMENU MenuBox; // Box for packing and alignment // HMENU TopMenu; // Menu Bar HWID FileLabel; // File menu label HWID EditLabel; // Edit menu label HWID InstructionLabel; // Instruction menu label HWID SettingsLabel; // Settings menu label HWID CompileLabel; // Compile menu label HWID HelpLabel; // Help menu label HWID SimulateLabel; // Simulate menu label HMENU FileMenuSeparator; // File menu separator HMENU EditMenuSeparator; // Edit menu separator HMENU InstructionMenuSeparator; // Instruction menu separator HMENU SimulateMenuSeparator; // Simulate menu separator int i; // Creating a box for desired orientation MenuBox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); // Create new menu bar to hold menu and add it to window TopMenu = gtk_menu_bar_new(); // Creating various menus FileMenu = gtk_menu_new(); EditMenu = gtk_menu_new(); Settings = gtk_menu_new(); ProcessorMenu = gtk_menu_new(); InstructionMenu = gtk_menu_new(); SimulateMenu = gtk_menu_new(); Compile = gtk_menu_new(); Help = gtk_menu_new(); // Creating labels for each menu FileLabel = gtk_menu_item_new_with_mnemonic("_File"); EditLabel = gtk_menu_item_new_with_mnemonic("_Edit"); SettingsLabel = gtk_menu_item_new_with_mnemonic("_Settings"); InstructionLabel = gtk_menu_item_new_with_mnemonic("_Instructions"); SimulateLabel = gtk_menu_item_new_with_mnemonic("_Simulate"); CompileLabel = gtk_menu_item_new_with_mnemonic("_Compile"); HelpLabel = gtk_menu_item_new_with_mnemonic("_Help"); // Creating labels for File Menu NewMenu = gtk_menu_item_new_with_mnemonic("_New"); OpenMenu = gtk_menu_item_new_with_mnemonic("_Open"); SaveMenu = gtk_menu_item_new_with_mnemonic("_Save"); SaveAsMenu = gtk_menu_item_new_with_mnemonic("_Save As"); ExportMenu = gtk_menu_item_new_with_mnemonic("_Export As Text"); ExitMenu = gtk_menu_item_new_with_mnemonic("_Exit"); // Appending menu items (labels) to File menu and adding separators gtk_menu_shell_append(GTK_MENU_SHELL (FileMenu), NewMenu); // Appending menu items gtk_menu_shell_append(GTK_MENU_SHELL (FileMenu), OpenMenu); gtk_menu_shell_append(GTK_MENU_SHELL (FileMenu), SaveMenu); gtk_menu_shell_append(GTK_MENU_SHELL (FileMenu), SaveAsMenu); FileMenuSeparator = gtk_separator_menu_item_new(); gtk_menu_shell_append(GTK_MENU_SHELL (FileMenu), FileMenuSeparator); gtk_menu_shell_append(GTK_MENU_SHELL (FileMenu), ExportMenu); FileMenuSeparator = gtk_separator_menu_item_new(); gtk_menu_shell_append(GTK_MENU_SHELL (FileMenu), FileMenuSeparator); gtk_menu_shell_append(GTK_MENU_SHELL (FileMenu), ExitMenu); // Creating labels for Edit Menu UndoMenu = gtk_menu_item_new_with_mnemonic("_Undo"); RedoMenu = gtk_menu_item_new_with_mnemonic("_Redo"); InsertRungBeforeMenu = gtk_menu_item_new_with_mnemonic("_Insert rung Before"); InsertRungAfterMenu = gtk_menu_item_new_with_mnemonic("_Insert Rung After"); PushRungUpMenu = gtk_menu_item_new_with_mnemonic("_Move Selected Rung Up"); PushRungDownMenu = gtk_menu_item_new_with_mnemonic("_Move Selected Rung Down"); DeleteElementMenu = gtk_menu_item_new_with_mnemonic("_Delete Selected Element"); DeleteRungMenu = gtk_menu_item_new_with_mnemonic("_Delete Rung"); // Appending menu items to Edit menu and adding separators gtk_menu_shell_append(GTK_MENU_SHELL (EditMenu), UndoMenu); gtk_menu_shell_append(GTK_MENU_SHELL (EditMenu), RedoMenu); EditMenuSeparator = gtk_separator_menu_item_new(); gtk_menu_shell_append(GTK_MENU_SHELL(EditMenu), EditMenuSeparator); gtk_menu_shell_append(GTK_MENU_SHELL (EditMenu), InsertRungBeforeMenu); gtk_menu_shell_append(GTK_MENU_SHELL (EditMenu), InsertRungAfterMenu); gtk_menu_shell_append(GTK_MENU_SHELL (EditMenu), PushRungUpMenu); gtk_menu_shell_append(GTK_MENU_SHELL (EditMenu), PushRungDownMenu); EditMenuSeparator = gtk_separator_menu_item_new(); gtk_menu_shell_append(GTK_MENU_SHELL(EditMenu), EditMenuSeparator); gtk_menu_shell_append(GTK_MENU_SHELL (EditMenu), DeleteElementMenu); gtk_menu_shell_append(GTK_MENU_SHELL (EditMenu), DeleteRungMenu); // Creating labels for Settings Menu McuSettingsMenu = gtk_menu_item_new_with_mnemonic ("_MCU Parameters..."); MicroControllerMenu = gtk_menu_item_new_with_mnemonic ("_Microcontroller"); // Appending menu items to Settings menu gtk_menu_shell_append (GTK_MENU_SHELL (Settings), McuSettingsMenu); gtk_menu_shell_append (GTK_MENU_SHELL (Settings), MicroControllerMenu); // Appending the microcontroller names to "Microcontroller" item GSList* mcuList = NULL; for (i = 0; i < NUM_SUPPORTED_MCUS; i++){ ProcessorMenuItems[i] = gtk_radio_menu_item_new_with_label (mcuList, SupportedMcus[i].mcuName); mcuList = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (ProcessorMenuItems[i])); gtk_menu_shell_append (GTK_MENU_SHELL (ProcessorMenu), ProcessorMenuItems[i]); } ProcessorMenuItems[NUM_SUPPORTED_MCUS] = gtk_radio_menu_item_new_with_label (mcuList, "(no microcontroller)"); mcuList = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (ProcessorMenuItems[NUM_SUPPORTED_MCUS])); gtk_menu_shell_append (GTK_MENU_SHELL (ProcessorMenu), ProcessorMenuItems[NUM_SUPPORTED_MCUS]); gtk_menu_item_set_submenu(GTK_MENU_ITEM(MicroControllerMenu), ProcessorMenu); // Creating labels for Instruction Menu and adding separators InsertCommentMenu = gtk_menu_item_new_with_mnemonic("_Insert Comment"); InsertContactsMenu = gtk_menu_item_new_with_mnemonic("_Insert Contacts"); InsertOsrMenu = gtk_menu_item_new_with_mnemonic("_Insert OSR (One Shot Rising)"); InsertOsfMenu = gtk_menu_item_new_with_mnemonic("_Insert OSF (One Shot Falling)"); InsertTonMenu = gtk_menu_item_new_with_mnemonic("_Insert TON (Delayed Turn On)"); InsertTofMenu = gtk_menu_item_new_with_mnemonic("_Insert TOF (Delayed Turn Off)"); InsertRtoMenu = gtk_menu_item_new_with_mnemonic("_Insert RTO (Retentive Delayed Turn On)"); InsertCtuMenu = gtk_menu_item_new_with_mnemonic("_Insert CTU (Count Up)"); InsertCtdMenu = gtk_menu_item_new_with_mnemonic("_Insert CTD (Count Down)"); InsertCtcMenu = gtk_menu_item_new_with_mnemonic("_Insert CTC (Count Circular)"); InsertEquMenu = gtk_menu_item_new_with_mnemonic("_Insert EQU (Compare for Equals)"); InsertNeqMenu = gtk_menu_item_new_with_mnemonic("_Insert NEQ (Compare for Not Equals)"); InsertGrtMenu = gtk_menu_item_new_with_mnemonic("_Insert GRT (Compare for Greater Than)"); InsertGeqMenu = gtk_menu_item_new_with_mnemonic("_Insert GEQ (Compare for Greater Than or Equal)"); InsertLesMenu = gtk_menu_item_new_with_mnemonic("_Insert LES (Compare for Less Than)"); InsertLeqMenu = gtk_menu_item_new_with_mnemonic("_Insert LEQ (Compare for Less Than or Equal)"); InsertOpenMenu = gtk_menu_item_new_with_mnemonic("_Insert Open Circuit"); InsertShortMenu = gtk_menu_item_new_with_mnemonic("_Insert Short Circuit"); InsertMasterRlyMenu = gtk_menu_item_new_with_mnemonic("_Insert Master Control Relay"); InsertCoilMenu = gtk_menu_item_new_with_mnemonic("_Insert Coil"); InsertResMenu = gtk_menu_item_new_with_mnemonic("_Insert RES (Counter/RTO Reset)"); InsertMovMenu = gtk_menu_item_new_with_mnemonic("_Insert MOV (Move)"); InsertAddMenu = gtk_menu_item_new_with_mnemonic("_Insert ADD (16-bit Integer Ad)"); InsertSubMenu = gtk_menu_item_new_with_mnemonic("_Insert SUB (16-bit Integer Subtract)"); InsertMulMenu = gtk_menu_item_new_with_mnemonic("_Insert MUL (16-bit Integer Multiply)"); InsertDivMenu = gtk_menu_item_new_with_mnemonic("_Insert DIV (16-bit Integer Division)"); InsertShiftRegMenu = gtk_menu_item_new_with_mnemonic("_Insert Shift Register"); InsertLutMenu = gtk_menu_item_new_with_mnemonic("_Insert Look-Up Table"); InsertPwlMenu = gtk_menu_item_new_with_mnemonic("_Insert Piecewise Linear"); InsertFmtdStrMenu = gtk_menu_item_new_with_mnemonic("_Insert Formatted String Over UART"); InsertUartSendMenu = gtk_menu_item_new_with_mnemonic("_Insert UART Send"); InsertUartRecvMenu = gtk_menu_item_new_with_mnemonic("_Insert UART Receive"); InsertSetPwmMenu = gtk_menu_item_new_with_mnemonic("_Insert Set PWM Output"); InsertReadAdcMenu = gtk_menu_item_new_with_mnemonic("_Insert A/D Converter Read"); InsertPersistMenu = gtk_menu_item_new_with_mnemonic("_Insert Make Persistent"); MakeNormalMenu = gtk_menu_item_new_with_mnemonic("_Make Normal"); NegateMenu = gtk_menu_item_new_with_mnemonic("_Make Negated"); MakeSetOnlyMenu = gtk_menu_item_new_with_mnemonic("_Make Set-Only"); MakeResetOnlyMenu = gtk_menu_item_new_with_mnemonic("_Make Reset-Only"); // Appending menu items to Instruction menu and adding separators gtk_menu_shell_append (GTK_MENU_SHELL (InstructionMenu), InsertCommentMenu); InstructionMenuSeparator = gtk_separator_menu_item_new(); gtk_menu_shell_append (GTK_MENU_SHELL(InstructionMenu), InstructionMenuSeparator); gtk_menu_shell_append (GTK_MENU_SHELL (InstructionMenu), InsertContactsMenu); InstructionMenuSeparator = gtk_separator_menu_item_new(); gtk_menu_shell_append (GTK_MENU_SHELL(InstructionMenu), InstructionMenuSeparator); gtk_menu_shell_append (GTK_MENU_SHELL (InstructionMenu), InsertOsrMenu); InstructionMenuSeparator = gtk_separator_menu_item_new(); gtk_menu_shell_append (GTK_MENU_SHELL(InstructionMenu), InstructionMenuSeparator); gtk_menu_shell_append (GTK_MENU_SHELL (InstructionMenu), InsertOsfMenu); gtk_menu_shell_append (GTK_MENU_SHELL (InstructionMenu), InsertTonMenu); gtk_menu_shell_append (GTK_MENU_SHELL (InstructionMenu), InsertTofMenu); gtk_menu_shell_append (GTK_MENU_SHELL (InstructionMenu), InsertRtoMenu); InstructionMenuSeparator = gtk_separator_menu_item_new(); gtk_menu_shell_append (GTK_MENU_SHELL(InstructionMenu), InstructionMenuSeparator); gtk_menu_shell_append (GTK_MENU_SHELL (InstructionMenu), InsertCtuMenu); gtk_menu_shell_append (GTK_MENU_SHELL (InstructionMenu), InsertCtdMenu); gtk_menu_shell_append (GTK_MENU_SHELL (InstructionMenu), InsertCtcMenu); InstructionMenuSeparator = gtk_separator_menu_item_new(); gtk_menu_shell_append (GTK_MENU_SHELL(InstructionMenu), InstructionMenuSeparator); gtk_menu_shell_append (GTK_MENU_SHELL (InstructionMenu), InsertEquMenu); gtk_menu_shell_append (GTK_MENU_SHELL (InstructionMenu), InsertNeqMenu); gtk_menu_shell_append (GTK_MENU_SHELL (InstructionMenu), InsertGrtMenu); gtk_menu_shell_append (GTK_MENU_SHELL (InstructionMenu), InsertGeqMenu); gtk_menu_shell_append (GTK_MENU_SHELL (InstructionMenu), InsertLesMenu); gtk_menu_shell_append (GTK_MENU_SHELL (InstructionMenu), InsertLeqMenu); InstructionMenuSeparator = gtk_separator_menu_item_new(); gtk_menu_shell_append (GTK_MENU_SHELL(InstructionMenu), InstructionMenuSeparator); gtk_menu_shell_append (GTK_MENU_SHELL (InstructionMenu), InsertOpenMenu); gtk_menu_shell_append (GTK_MENU_SHELL (InstructionMenu), InsertShortMenu); gtk_menu_shell_append (GTK_MENU_SHELL (InstructionMenu), InsertMasterRlyMenu); InstructionMenuSeparator = gtk_separator_menu_item_new(); gtk_menu_shell_append (GTK_MENU_SHELL(InstructionMenu), InstructionMenuSeparator); gtk_menu_shell_append (GTK_MENU_SHELL (InstructionMenu), InsertCoilMenu); gtk_menu_shell_append (GTK_MENU_SHELL (InstructionMenu), InsertResMenu); InstructionMenuSeparator = gtk_separator_menu_item_new(); gtk_menu_shell_append (GTK_MENU_SHELL(InstructionMenu), InstructionMenuSeparator); gtk_menu_shell_append (GTK_MENU_SHELL (InstructionMenu), InsertMovMenu); gtk_menu_shell_append (GTK_MENU_SHELL (InstructionMenu), InsertAddMenu); gtk_menu_shell_append (GTK_MENU_SHELL (InstructionMenu), InsertSubMenu); gtk_menu_shell_append (GTK_MENU_SHELL (InstructionMenu), InsertMulMenu); gtk_menu_shell_append (GTK_MENU_SHELL (InstructionMenu), InsertDivMenu); InstructionMenuSeparator = gtk_separator_menu_item_new(); gtk_menu_shell_append (GTK_MENU_SHELL(InstructionMenu), InstructionMenuSeparator); gtk_menu_shell_append (GTK_MENU_SHELL (InstructionMenu), InsertShiftRegMenu); gtk_menu_shell_append (GTK_MENU_SHELL (InstructionMenu), InsertLutMenu); gtk_menu_shell_append (GTK_MENU_SHELL (InstructionMenu), InsertPwlMenu); gtk_menu_shell_append (GTK_MENU_SHELL (InstructionMenu), InsertFmtdStrMenu); InstructionMenuSeparator = gtk_separator_menu_item_new(); gtk_menu_shell_append (GTK_MENU_SHELL (InstructionMenu), InstructionMenuSeparator); gtk_menu_shell_append (GTK_MENU_SHELL (InstructionMenu), InsertUartSendMenu); gtk_menu_shell_append (GTK_MENU_SHELL (InstructionMenu), InsertUartRecvMenu); gtk_menu_shell_append (GTK_MENU_SHELL (InstructionMenu), InsertSetPwmMenu); gtk_menu_shell_append (GTK_MENU_SHELL (InstructionMenu), InsertReadAdcMenu); gtk_menu_shell_append (GTK_MENU_SHELL (InstructionMenu), InsertPersistMenu); InstructionMenuSeparator = gtk_separator_menu_item_new(); gtk_menu_shell_append (GTK_MENU_SHELL (InstructionMenu), InstructionMenuSeparator); gtk_menu_shell_append (GTK_MENU_SHELL (InstructionMenu), MakeNormalMenu); gtk_menu_shell_append (GTK_MENU_SHELL (InstructionMenu), NegateMenu); gtk_menu_shell_append (GTK_MENU_SHELL (InstructionMenu), MakeSetOnlyMenu); gtk_menu_shell_append (GTK_MENU_SHELL (InstructionMenu), MakeResetOnlyMenu); // Creating labels for Compile Menu CompileMenu = gtk_menu_item_new_with_mnemonic("_Compile"); CompileAsMenu = gtk_menu_item_new_with_mnemonic("_Compile As..."); // Appending menu items to Compile menu gtk_menu_shell_append(GTK_MENU_SHELL (Compile), CompileMenu); gtk_menu_shell_append(GTK_MENU_SHELL (Compile), CompileAsMenu); // Creating labels for Help Menu ManualMenu = gtk_menu_item_new_with_mnemonic("_Manual..."); AboutMenu = gtk_menu_item_new_with_mnemonic("_About..."); // Appending menu items to Help menu gtk_menu_shell_append(GTK_MENU_SHELL (Help), ManualMenu); gtk_menu_shell_append(GTK_MENU_SHELL (Help), AboutMenu); // Creating labels for Simulation Menu SimulationModeMenu = gtk_check_menu_item_new_with_mnemonic("_Simulation Mode"); StartSimulationMenu = gtk_menu_item_new_with_mnemonic("_Start Real-Time Simulation"); StopSimulationMenu = gtk_menu_item_new_with_mnemonic("_Halt Simulation"); SingleCycleMenu = gtk_menu_item_new_with_mnemonic("_Single Cycle"); // Appending menu items to Simulate menu and adding separators gtk_menu_shell_append(GTK_MENU_SHELL (SimulateMenu), SimulationModeMenu); gtk_menu_shell_append(GTK_MENU_SHELL (SimulateMenu), StartSimulationMenu); gtk_menu_shell_append(GTK_MENU_SHELL (SimulateMenu), StopSimulationMenu); gtk_menu_shell_append(GTK_MENU_SHELL (SimulateMenu), SingleCycleMenu); SimulateMenuSeparator = gtk_separator_menu_item_new(); gtk_menu_shell_append(GTK_MENU_SHELL(SimulateMenu), SimulateMenuSeparator); // Creating submenus for each menu gtk_menu_item_set_submenu(GTK_MENU_ITEM(FileLabel), FileMenu); gtk_menu_item_set_submenu(GTK_MENU_ITEM(EditLabel), EditMenu); gtk_menu_item_set_submenu(GTK_MENU_ITEM(SettingsLabel), Settings); gtk_menu_item_set_submenu(GTK_MENU_ITEM(InstructionLabel), InstructionMenu); gtk_menu_item_set_submenu(GTK_MENU_ITEM(SimulateLabel), SimulateMenu); gtk_menu_item_set_submenu(GTK_MENU_ITEM(CompileLabel), Compile); gtk_menu_item_set_submenu(GTK_MENU_ITEM(HelpLabel), Help); // Appending the menu item to the menu bar gtk_menu_shell_append(GTK_MENU_SHELL(TopMenu), FileLabel); gtk_menu_shell_append(GTK_MENU_SHELL(TopMenu), EditLabel); gtk_menu_shell_append(GTK_MENU_SHELL(TopMenu), SettingsLabel); gtk_menu_shell_append(GTK_MENU_SHELL(TopMenu), InstructionLabel); gtk_menu_shell_append(GTK_MENU_SHELL(TopMenu), SimulateLabel); gtk_menu_shell_append(GTK_MENU_SHELL(TopMenu), CompileLabel); gtk_menu_shell_append(GTK_MENU_SHELL(TopMenu), HelpLabel); // Packing the menu bar into the box for alignment gtk_box_pack_start(GTK_BOX(MenuBox), TopMenu, FALSE, FALSE, 0); AddMenuAccelerators (); return MenuBox; } //----------------------------------------------------------------------------- // Create the standard Windows controls used in the main window: a Listview // for the I/O list, and a status bar for settings. //----------------------------------------------------------------------------- void MakeMainWindowControls(void) { HWID PackBoxMenu = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); HWID grid = gtk_grid_new(); /// Pane to separate Scrolled Window and other widgets HWID pane = gtk_paned_new (GTK_ORIENTATION_VERTICAL); IoList = (GtkTreeModel*)gtk_list_store_new (5, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); int typeWidth = 85; int pinWidth = 100; int portWidth = 90; /// Creating a list view = gtk_tree_view_new_with_model (GTK_TREE_MODEL(IoList)); gtk_tree_view_set_model (GTK_TREE_VIEW (view), GTK_TREE_MODEL (IoList)); gtk_tree_view_set_enable_search (GTK_TREE_VIEW (view), FALSE); column = gtk_tree_view_column_new_with_attributes("Name", gtk_cell_renderer_text_new(), "text", LV_IO_NAME, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(view), column); gtk_tree_view_column_set_min_width (column, 250); column = gtk_tree_view_column_new_with_attributes("Type", gtk_cell_renderer_spin_new(), "text", LV_IO_TYPE, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(view), column); gtk_tree_view_column_set_min_width (column, typeWidth); column = gtk_tree_view_column_new_with_attributes("State", gtk_cell_renderer_text_new(), "text", LV_IO_STATE, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(view), column); gtk_tree_view_column_set_min_width (column, 100); column = gtk_tree_view_column_new_with_attributes("Pin on Processor", gtk_cell_renderer_text_new(), "text", LV_IO_PIN, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(view), column); gtk_tree_view_column_set_min_width (column, pinWidth); column = gtk_tree_view_column_new_with_attributes("MCU Port", gtk_cell_renderer_text_new(), "text", LV_IO_PORT, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(view), column); gtk_tree_view_column_set_min_width (column, portWidth); /// Appending Menus to grid gtk_grid_attach (GTK_GRID (grid), MakeMainWindowMenus(), 0, 0, 1, 1); /// Creating Scrolled Window ScrollWindow = gtk_scrolled_window_new (NULL, NULL); HWID ViewPortMenu = gtk_viewport_new (NULL,NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (ScrollWindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_widget_set_hexpand(GTK_WIDGET(ScrollWindow), TRUE); gtk_widget_set_vexpand(GTK_WIDGET(ScrollWindow), TRUE); /// Adding DrawWindow to pane gtk_container_add (GTK_CONTAINER(ViewPortMenu), DrawWindow); gtk_container_add (GTK_CONTAINER(ScrollWindow), ViewPortMenu); gtk_paned_pack1 (GTK_PANED (pane), ScrollWindow, TRUE, TRUE); gtk_paned_set_position (GTK_PANED (pane), 0); /// Appending tree view to scrolled window HWID ViewScroll = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (ViewScroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_widget_set_hexpand(GTK_WIDGET(ViewScroll), TRUE); gtk_widget_set_vexpand(GTK_WIDGET(ViewScroll), TRUE); gtk_container_add (GTK_CONTAINER(ViewScroll), view); /// Appending tree view to pane and pane to grid gtk_paned_pack2 (GTK_PANED(pane), ViewScroll, FALSE, FALSE); gtk_paned_set_position (GTK_PANED (pane), 400); gtk_grid_attach (GTK_GRID (grid), pane, 0, 0, 1, 1); gtk_box_pack_start(GTK_BOX(PackBoxMenu), grid, FALSE, TRUE, 0); /// Grid for status bars HWID StatusGrid = gtk_grid_new(); gtk_widget_override_background_color(GTK_WIDGET(ViewPortMenu), GTK_STATE_FLAG_NORMAL, ((HBRUSH)GetStockObject(BLACK_BRUSH))); /*gtk_widget_override_background_color(GTK_WIDGET(StatusGrid), GTK_STATE_FLAG_NORMAL, ((HBRUSH)GetStockObject(DKGRAY_BRUSH))); gtk_widget_override_background_color(GTK_WIDGET(view), GTK_STATE_FLAG_NORMAL, ((HBRUSH)GetStockObject(WHITE_BRUSH)));*/ /// Creating Status Bar 1 and attaching to grid StatusBar[0] = gtk_statusbar_new(); gtk_statusbar_push (GTK_STATUSBAR (StatusBar[0]), gtk_statusbar_get_context_id (GTK_STATUSBAR (StatusBar[0]), "Introduction"), "LDMicro Started"); /// Appneding Status Bar 1 to the status grid gtk_grid_attach (GTK_GRID (StatusGrid), StatusBar[0], 0, 0, 1, 1); /// Creating Status Bar 2 and attaching to grid StatusBar[1] = gtk_statusbar_new(); gtk_statusbar_push (GTK_STATUSBAR (StatusBar[1]), gtk_statusbar_get_context_id (GTK_STATUSBAR (StatusBar[1]), "Introduction"), "LDMicro Started"); /// Appneding Status Bar 2 to the status box gtk_grid_attach (GTK_GRID (StatusGrid), StatusBar[1], 1, 0, 1, 1); /// Creating Status Bar 3 and attaching to grid StatusBar[2] = gtk_statusbar_new(); gtk_statusbar_push (GTK_STATUSBAR (StatusBar[2]), gtk_statusbar_get_context_id (GTK_STATUSBAR (StatusBar[2]), "Introduction"), "LDMicro Started"); /// Appneding Status Bar 3 to the status box gtk_grid_attach (GTK_GRID (StatusGrid), StatusBar[2], 2, 0, 1, 1); /// Attach status grid to box gtk_box_pack_start(GTK_BOX(PackBoxMenu), StatusGrid, FALSE, FALSE, 0); /// Adding box to Main Window gtk_container_add(GTK_CONTAINER(MainWindow), PackBoxMenu); } //----------------------------------------------------------------------------- // Adjust the size and visibility of the scrollbars as necessary, either due // to a change in the size of the program or a change in the size of the // window. //----------------------------------------------------------------------------- void RefreshScrollbars(void) { SCROLLINFO vert, horiz; SetUpScrollbars(&NeedHoriz, &horiz, &vert); // SetScrollInfo(HorizScrollBar, SB_CTL, &horiz, TRUE); // SetScrollInfo(VertScrollBar, SB_CTL, &vert, TRUE); // RECT main; // GetClientRect(MainWindow, &main); // if(NeedHoriz) { // MoveWindow(HorizScrollBar, 0, IoListTop - ScrollHeight - 2, // main.right - ScrollWidth - 2, ScrollHeight, TRUE); // ShowWindow(HorizScrollBar, SW_SHOW); // EnableWindow(HorizScrollBar, TRUE); // } else { // ShowWindow(HorizScrollBar, SW_HIDE); // } // MoveWindow(VertScrollBar, main.right - ScrollWidth - 2, 1, ScrollWidth, // NeedHoriz ? (IoListTop - ScrollHeight - 4) : (IoListTop - 3), TRUE); // MoveWindow(VertScrollBar, main.right - ScrollWidth - 2, 1, ScrollWidth, // NeedHoriz ? (IoListTop - ScrollHeight - 4) : (IoListTop - 3), TRUE); InvalidateRect(DrawWindow, NULL, FALSE); } //----------------------------------------------------------------------------- // Respond to a WM_VSCROLL sent to the main window, presumably by the one and // only vertical scrollbar that it has as a child. //----------------------------------------------------------------------------- void VscrollProc(int wParam) { int prevY = ScrollYOffset; switch(wParam) { case SB_LINEUP: case SB_PAGEUP: if(ScrollYOffset > 0) { ScrollYOffset--; } break; case SB_LINEDOWN: case SB_PAGEDOWN: if(ScrollYOffset < ScrollYOffsetMax) { ScrollYOffset++; } break; case SB_TOP: ScrollYOffset = 0; break; case SB_BOTTOM: ScrollYOffset = ScrollYOffsetMax; break; // case SB_THUMBTRACK: // case SB_THUMBPOSITION: // ScrollYOffset = HIWORD(wParam); // break; } // if(prevY != ScrollYOffset) { // SCROLLINFO si; // si.cbSize = sizeof(si); // si.fMask = SIF_POS; // si.nPos = ScrollYOffset; // SetScrollInfo(VertScrollBar, SB_CTL, &si, TRUE); // InvalidateRect(MainWindow, NULL, FALSE); // } } //----------------------------------------------------------------------------- // Respond to a WM_HSCROLL sent to the main window, presumably by the one and // only horizontal scrollbar that it has as a child. //----------------------------------------------------------------------------- void HscrollProc(int wParam) { int prevX = ScrollXOffset; switch(wParam) { case SB_LINEUP: ScrollXOffset -= FONT_WIDTH; break; case SB_PAGEUP: ScrollXOffset -= POS_WIDTH*FONT_WIDTH; break; case SB_LINEDOWN: ScrollXOffset += FONT_WIDTH; break; case SB_PAGEDOWN: ScrollXOffset += POS_WIDTH*FONT_WIDTH; break; case SB_TOP: ScrollXOffset = 0; break; case SB_BOTTOM: ScrollXOffset = ScrollXOffsetMax; break; // case SB_THUMBTRACK: // case SB_THUMBPOSITION: // ScrollXOffset = HIWORD(wParam); // break; } if(ScrollXOffset > ScrollXOffsetMax) ScrollXOffset = ScrollXOffsetMax; if(ScrollXOffset < 0) ScrollXOffset = 0; // if(prevX != ScrollXOffset) { // SCROLLINFO si; // si.cbSize = sizeof(si); // si.fMask = SIF_POS; // si.nPos = ScrollXOffset; // SetScrollInfo(HorizScrollBar, SB_CTL, &si, TRUE); // InvalidateRect(MainWindow, NULL, FALSE); // } } //----------------------------------------------------------------------------- // Set up the title bar text for the main window; indicate whether we are in // simulation or editing mode, and indicate the filename. //----------------------------------------------------------------------------- void UpdateMainWindowTitleBar(void) { char line[PATH_MAX+100]; if(InSimulationMode) { if(RealTimeSimulationRunning) { strcpy(line, "LDmicro - Simulation (Running)"); } else { strcpy(line, "LDmicro - Simulation (Stopped)"); } } else { strcpy(line, "LDmicro - Program Editor"); } if(strlen(CurrentSaveFile) > 0) { sprintf(line+strlen(line), " - %s", CurrentSaveFile); } else { strcat(line, " - (not yet saved)"); } gtk_window_set_title (GTK_WINDOW (MainWindow), line); } //----------------------------------------------------------------------------- // Set the enabled state of the logic menu items to reflect where we are on // the schematic (e.g. can't insert two coils in series). //----------------------------------------------------------------------------- void SetMenusEnabled(BOOL canNegate, BOOL canNormal, BOOL canResetOnly, BOOL canSetOnly, BOOL canDelete, BOOL canInsertEnd, BOOL canInsertOther, BOOL canPushDown, BOOL canPushUp, BOOL canInsertComment) { EnableMenuItem(EditMenu, PushRungUpMenu, canPushUp ? MF_ENABLED : MF_GRAYED); EnableMenuItem(EditMenu, PushRungDownMenu, canPushDown ? MF_ENABLED : MF_GRAYED); EnableMenuItem(EditMenu, DeleteRungMenu, (Prog.numRungs > 1) ? MF_ENABLED : MF_GRAYED); EnableMenuItem(InstructionMenu, NegateMenu, canNegate ? MF_ENABLED : MF_GRAYED); EnableMenuItem(InstructionMenu, MakeNormalMenu, canNormal ? MF_ENABLED : MF_GRAYED); EnableMenuItem(InstructionMenu, MakeResetOnlyMenu, canResetOnly ? MF_ENABLED : MF_GRAYED); EnableMenuItem(InstructionMenu, MakeSetOnlyMenu, canSetOnly ? MF_ENABLED : MF_GRAYED); EnableMenuItem(InstructionMenu, InsertCommentMenu, canInsertComment ? MF_ENABLED : MF_GRAYED); EnableMenuItem(EditMenu, DeleteElementMenu, canDelete ? MF_ENABLED : MF_GRAYED); int t; t = canInsertEnd ? MF_ENABLED : MF_GRAYED; EnableMenuItem(InstructionMenu, InsertCoilMenu, t); EnableMenuItem(InstructionMenu, InsertResMenu, t); EnableMenuItem(InstructionMenu, InsertMovMenu, t); EnableMenuItem(InstructionMenu, InsertAddMenu, t); EnableMenuItem(InstructionMenu, InsertSubMenu, t); EnableMenuItem(InstructionMenu, InsertMulMenu, t); EnableMenuItem(InstructionMenu, InsertDivMenu, t); EnableMenuItem(InstructionMenu, InsertCtcMenu, t); EnableMenuItem(InstructionMenu, InsertPersistMenu, t); EnableMenuItem(InstructionMenu, InsertReadAdcMenu, t); EnableMenuItem(InstructionMenu, InsertSetPwmMenu, t); EnableMenuItem(InstructionMenu, InsertMasterRlyMenu, t); EnableMenuItem(InstructionMenu, InsertShiftRegMenu, t); EnableMenuItem(InstructionMenu, InsertLutMenu, t); EnableMenuItem(InstructionMenu, InsertPwlMenu, t); t = canInsertOther ? MF_ENABLED : MF_GRAYED; EnableMenuItem(InstructionMenu, InsertTonMenu, t); EnableMenuItem(InstructionMenu, InsertTofMenu, t); EnableMenuItem(InstructionMenu, InsertOsrMenu, t); EnableMenuItem(InstructionMenu, InsertOsfMenu, t); EnableMenuItem(InstructionMenu, InsertRtoMenu, t); EnableMenuItem(InstructionMenu, InsertContactsMenu, t); EnableMenuItem(InstructionMenu, InsertCtuMenu, t); EnableMenuItem(InstructionMenu, InsertCtdMenu, t); EnableMenuItem(InstructionMenu, InsertEquMenu, t); EnableMenuItem(InstructionMenu, InsertNeqMenu, t); EnableMenuItem(InstructionMenu, InsertGrtMenu, t); EnableMenuItem(InstructionMenu, InsertGeqMenu, t); EnableMenuItem(InstructionMenu, InsertLesMenu, t); EnableMenuItem(InstructionMenu, InsertLeqMenu, t); EnableMenuItem(InstructionMenu, InsertShortMenu, t); EnableMenuItem(InstructionMenu, InsertOpenMenu, t); EnableMenuItem(InstructionMenu, InsertUartSendMenu, t); EnableMenuItem(InstructionMenu, InsertUartRecvMenu, t); EnableMenuItem(InstructionMenu, InsertFmtdStrMenu, t); } //----------------------------------------------------------------------------- // Set the enabled state of the undo/redo menus. //----------------------------------------------------------------------------- void SetUndoEnabled(BOOL undoEnabled, BOOL redoEnabled) { EnableMenuItem(EditMenu, UndoMenu, undoEnabled ? MF_ENABLED : MF_GRAYED); EnableMenuItem(EditMenu, RedoMenu, redoEnabled ? MF_ENABLED : MF_GRAYED); } //----------------------------------------------------------------------------- // Toggle whether we are in simulation mode. A lot of options are only // available in one mode or the other. //----------------------------------------------------------------------------- void ToggleSimulationMode(void) { InSimulationMode = !InSimulationMode; if(InSimulationMode) { EnableMenuItem(SimulateMenu, StartSimulationMenu, MF_ENABLED); EnableMenuItem(SimulateMenu, SingleCycleMenu, MF_ENABLED); EnableMenuItem(FileMenu, OpenMenu, MF_GRAYED); EnableMenuItem(FileMenu, SaveMenu, MF_GRAYED); EnableMenuItem(FileMenu, SaveAsMenu, MF_GRAYED); EnableMenuItem(FileMenu, NewMenu, MF_GRAYED); EnableMenuItem(FileMenu, ExportMenu, MF_GRAYED); EnableMenuItem(TopMenu, EditMenu, MF_GRAYED); EnableMenuItem(TopMenu, Settings, MF_GRAYED); EnableMenuItem(TopMenu, InstructionMenu, MF_GRAYED); EnableMenuItem(TopMenu, Compile, MF_GRAYED); CheckMenuItem(SimulateMenu, SimulationModeMenu, MF_CHECKED); ClearSimulationData(); // simulation.cpp, ldmicro.h // Recheck InSimulationMode, because there could have been a Compile // error, which would have kicked us out of simulation mode. if(UartFunctionUsed() && InSimulationMode) { ShowUartSimulationWindow(); // simulate.cpp } } else { RealTimeSimulationRunning = FALSE; KillTimer(MainWindow, TIMER_SIMULATE); EnableMenuItem(SimulateMenu, StartSimulationMenu, MF_GRAYED); EnableMenuItem(SimulateMenu, StopSimulationMenu, MF_GRAYED); EnableMenuItem(SimulateMenu, SingleCycleMenu, MF_GRAYED); EnableMenuItem(FileMenu, OpenMenu, MF_ENABLED); EnableMenuItem(FileMenu, SaveMenu, MF_ENABLED); EnableMenuItem(FileMenu, SaveAsMenu, MF_ENABLED); EnableMenuItem(FileMenu, NewMenu, MF_ENABLED); EnableMenuItem(FileMenu, ExportMenu, MF_ENABLED); EnableMenuItem(TopMenu, EditMenu, MF_ENABLED); EnableMenuItem(TopMenu, Settings, MF_ENABLED); EnableMenuItem(TopMenu, InstructionMenu, MF_ENABLED); EnableMenuItem(TopMenu, Compile, MF_ENABLED); CheckMenuItem(SimulateMenu, SimulationModeMenu, MF_UNCHECKED); if(UartFunctionUsed()) { DestroyUartSimulationWindow(); } } UpdateMainWindowTitleBar(); RefreshControlsToSettings(); } //----------------------------------------------------------------------------- // Cause the status bar and the list view to be in sync with the actual data // structures describing the settings and the I/O configuration. Listview // does callbacks to get the strings it displays, so it just needs to know // how many elements to populate. //----------------------------------------------------------------------------- void RefreshControlsToSettings(void) { GtkTreeIter iter; BOOL path_not_empty = gtk_tree_model_get_iter_first (GTK_TREE_MODEL(IoList), &iter); // g_print("path e = %i\n", path_not_empty); int * ip; int i = 0; if(!IoListOutOfSync) { IoListSelectionPoint = -1; GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE); GtkTreeModel *IoModelPtr; if(gtk_tree_selection_get_selected (selection, &IoModelPtr, &iter)) { GtkTreePath *path = gtk_tree_model_get_path ( IoModelPtr, &iter ) ; ip = gtk_tree_path_get_indices ( path ) ; i = ip[0]; IoListSelectionPoint = i; } } gtk_list_store_clear (GTK_LIST_STORE(IoList)); /// Fill IO List NMHDR h; h.code = LVN_GETDISPINFO; h.hlistFrom = IoList; gtk_tree_model_get_iter_first (GTK_TREE_MODEL(IoList), &iter); for(i = 0; i < Prog.io.count; i++) { gtk_list_store_append (GTK_LIST_STORE(IoList), &iter); h.item.iItem = i; h.hlistIter = &iter; IoListProc(&h); } if(IoListSelectionPoint >= 0) { GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE); gtk_tree_selection_unselect_all (selection); GtkTreePath *path = gtk_tree_path_new_from_indices ( IoListSelectionPoint, -1); gtk_tree_selection_select_path (selection, path); // ListView_EnsureVisible(IoList, IoListSelectionPoint, FALSE); } IoListOutOfSync = FALSE; if(Prog.mcu) { gtk_statusbar_push (GTK_STATUSBAR (StatusBar[0]), gtk_statusbar_get_context_id (GTK_STATUSBAR (StatusBar[0]), "MCU Name"), (gchar*)Prog.mcu->mcuName); } else { gtk_statusbar_push (GTK_STATUSBAR (StatusBar[0]), gtk_statusbar_get_context_id (GTK_STATUSBAR (StatusBar[0]), "MCU Name"), "no MCU selected"); } char buf[256]; sprintf(buf, _("cycle time %.2f ms"), (double)Prog.cycleTime/1000.0); gtk_statusbar_push (GTK_STATUSBAR (StatusBar[1]), gtk_statusbar_get_context_id (GTK_STATUSBAR (StatusBar[1]), "Cycle time"), buf); if(Prog.mcu && (Prog.mcu->whichIsa == ISA_ANSIC || Prog.mcu->whichIsa == ISA_INTERPRETED)) { strcpy(buf, ""); } else { sprintf(buf, _("processor clock %.4f MHz"), (double)Prog.mcuClock/1000000.0); } gtk_statusbar_push (GTK_STATUSBAR (StatusBar[2]), gtk_statusbar_get_context_id (GTK_STATUSBAR (StatusBar[2]), "Processor time"), buf); for(i = 0; i < NUM_SUPPORTED_MCUS; i++) { if(&SupportedMcus[i] == Prog.mcu) { CheckMenuItem(ProcessorMenu, ProcessorMenuItems[i], MF_CHECKED); } else { CheckMenuItem(ProcessorMenu, ProcessorMenuItems[i], MF_UNCHECKED); } } // `(no microcontroller)' setting if (!Prog.mcu){ CheckMenuItem(ProcessorMenu, ProcessorMenuItems[NUM_SUPPORTED_MCUS], MF_CHECKED); } else { CheckMenuItem(ProcessorMenu, ProcessorMenuItems[NUM_SUPPORTED_MCUS], MF_UNCHECKED); } } //----------------------------------------------------------------------------- // Regenerate the I/O list, keeping the selection in the same place if // possible. //----------------------------------------------------------------------------- void GenerateIoListDontLoseSelection(void) { GtkTreeIter iter; BOOL path_not_empty = gtk_tree_model_get_iter_first (GTK_TREE_MODEL(IoList), &iter); // g_print("path e = %i\n", path_not_empty); int * i ; IoListSelectionPoint = -1; // GtkTreeSelection * tsel = gtk_tree_view_get_selection (tv); // GtkTreeModel * tm ; GtkTreePath * path ; GtkTreeModel *IoModelPtr; 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, &IoModelPtr, &iter)) { path = gtk_tree_model_get_path ( IoModelPtr , &iter ) ; i = gtk_tree_path_get_indices ( path ) ; IoListSelectionPoint = i[0]; } // gtk_tree_model_iter_next (GTK_TREE_MODEL(IoList), iter); // BOOL iter_v = gtk_list_store_iter_is_valid(GTK_LIST_STORE(IoList), iter); // g_print("iter = %i\n", iter_v); // if ( gtk_tree_selection_get_selected ( tsel , &tm , &iter ) ) // { // return i [ 0 ] ; // } IoListSelectionPoint = GenerateIoList(IoListSelectionPoint); // can't just update the listview index; if I/O has been added then the // new selection point might be out of range till we refill it IoListOutOfSync = TRUE; RefreshControlsToSettings(); } //----------------------------------------------------------------------------- // Called when the main window has been resized. Adjust the size of the // status bar and the listview to reflect the new window size. //----------------------------------------------------------------------------- void MainWindowResized(void) { RECT main; GetClientRect(DrawWindow, &main); RECT status; // GetWindowRect(StatusBar, &status); // int statusHeight = status.bottom - status.top; // MoveWindow(StatusBar, 0, main.bottom - statusHeight, main.right, // statusHeight, TRUE); // Make sure that the I/O list can't disappear entirely. if(IoListHeight < 30) { IoListHeight = 30; } IoListTop = main.bottom ;//- IoListHeight - statusHeight; // Make sure that we can't drag the top of the I/O list above the // bottom of the menu bar, because it then becomes inaccessible. if(IoListTop < 5) { IoListHeight = main.bottom - 5;//- statusHeight - 5; IoListTop = main.bottom - IoListHeight;// - statusHeight; } // MoveWindow(IoList, 0, IoListTop, main.right, IoListHeight, TRUE); RefreshScrollbars(); InvalidateRect(DrawWindow, NULL, FALSE); } //----------------------------------------------------------------------------- // Start real-time simulation. Have to update the controls grayed status // to reflect this. //----------------------------------------------------------------------------- void StartSimulation(void) { RealTimeSimulationRunning = TRUE; EnableMenuItem(SimulateMenu, StartSimulationMenu, MF_GRAYED); EnableMenuItem(SimulateMenu, StopSimulationMenu, MF_ENABLED); StartSimulationTimer(); UpdateMainWindowTitleBar(); } //----------------------------------------------------------------------------- // Stop real-time simulation. Have to update the controls grayed status // to reflect this. //----------------------------------------------------------------------------- void StopSimulation(void) { RealTimeSimulationRunning = FALSE; EnableMenuItem(SimulateMenu, StartSimulationMenu, MF_ENABLED); EnableMenuItem(SimulateMenu, StopSimulationMenu, MF_GRAYED); KillTimer(MainWindow, TIMER_SIMULATE); UpdateMainWindowTitleBar(); }