/// @brief Remove a plugin from the pin changed notify list.
 /// @details Only if the plugin exists on the list, this method removes from it.
 /// @param[in] plugin Compiled plugin reference to remove.
 public void RemoveOnPins(PluginCommon plugin)
 {
     if (PinHandlers.Contains(plugin))
     {
         PinHandlers.Remove(plugin);
     }
 }
 /// @brief Remove a plugin from the clock notify list.
 /// @details Only if the plugin exists on the list, this method removes from it.
 /// @param[in] plugin Compiled plugin reference to remove.
 public void RemoveOnClock(PluginCommon plugin)
 {
     if (TickHandlers.Contains(plugin))
     {
         TickHandlers.Remove(plugin);
     }
 }
 /// @brief Add a plugin to be notified on pin changes.
 /// @details It see if the plugin exist already to insert or not.
 /// @param[in] plugin Compiled plugin reference to include.
 public void NotifyOnPins(PluginCommon plugin)
 {
     if (!(PinHandlers.Contains(plugin)))
     {
         PinHandlers.Add(plugin);
     }
 }
Exemple #4
0
 /// @todo Document Gear.GUI.Emulator.documentsTab_KeyPress()
 ///
 private void documentsTab_KeyPress(object sender, KeyPressEventArgs e)
 {
     if (ActiveControl is PluginCommon)
     {
         PluginCommon b = ActiveControl as PluginCommon;
         if (b.AllowHotKeys != true)
         {
             return;
         }
     }
     if ((e.KeyChar == 's') | (e.KeyChar == 'S'))
     {
         if (runTimer.Enabled)
         {
             runTimer.Stop();
         }
         else
         {
             stepInstruction_Click(sender, e);
         }
     }
     if ((e.KeyChar == 'r') | (e.KeyChar == 'R'))
     {
         if (!runTimer.Enabled)
         {
             runTimer.Start();
         }
     }
 }
 /// @brief Add a plugin to be notified on clock ticks.
 /// @details It see if the plugin exist already to insert or not.
 /// @param[in] plugin Compiled plugin reference to include.
 public void NotifyOnClock(PluginCommon plugin)
 {
     if (!(TickHandlers.Contains(plugin)))
     {
         TickHandlers.Add(plugin);
     }
 }
Exemple #6
0
        /// @brief Include a plugin to a propeller chip instance.
        /// @details Attach a plugin, linking the propeller instance to the plugin, opening a new
        /// tab window and enabling the close button by plugin's isClosable property.
        /// @param[in] plugin Instance of a Gear.PluginSupport.PluginCommon class to be attached.
        private void AttachPlugin(PluginCommon plugin)
        {
            if (plugin != null)
            {
                Chip.IncludePlugin(plugin); //include into plugin lists of a PropellerCPU instance
#pragma warning disable 618
                if (((PluginBaseV0_0.numInstances != 0) && (plugin is PluginBaseV0_0)))
                {
                    ((PluginBaseV0_0)plugin).PresentChip(Chip);//invoke plugin old style way
                }
#pragma warning restore 618
                else
                {
                    ((PluginBase)plugin).PresentChip();   //invoke plugin in modern way
                }
                TabPage t = new TabPage(plugin.Title);
                t.Parent                 = documentsTab;
                plugin.Dock              = DockStyle.Fill;
                plugin.Parent            = t;
                documentsTab.SelectedTab = t;
                //Maintain the close button availability
                if (plugin.IsClosable)
                {
                    closeButton.Enabled = true;
                }
                else
                {
                    closeButton.Enabled = false;
                }
            }
        }
Exemple #7
0
 /// @brief Delete a plugin from a propeller chip instance.
 /// @details Delete a plugin from the actives plugins of the propeller instance,
 /// effectively stopping the plugin. Remove also from pins and clock watch list.
 /// @param[in] plugin Instance of a Gear.PluginSupport.PluginCommon class to be detached.
 /// @since V15.03.26 - Added.
 //Added method to detach a plugin from the active plugin list of the propeller instance.
 private void DetachPlugin(PluginCommon plugin)
 {
     if (plugin.IsClosable)          //check if the plugin is able to close, then remove...
     {
         Chip.RemoveOnPins(plugin);  //from pins watch list
         Chip.RemoveOnClock(plugin); //from clock watch list
         Chip.RemovePlugin(plugin);  //from the plugins registered to the propeller emulator
     }
     ;
 }
 /// @brief Remove a plugin from the active plugin list of propeller instance
 /// @details Only if the plugin exists on the list, this method removes from it.
 /// Before detach, the `OnClose()` method of plugin is invoked, to do
 /// housekeeping, for example to clear pins managed by the plugin.
 /// @param[in] plugin Compiled plugin reference to remove
 public void RemovePlugin(PluginCommon plugin)
 {
     if (PlugIns.Contains(plugin))
     {
         if (plugin is PluginBase)
         {
             //call the event before remove, but only for modern plugins
             ((PluginBase)plugin).OnClose();
         }
         PlugIns.Remove(plugin);
     }
 }
Exemple #9
0
        /// @brief Determine availability of close plugin button when tab is changed.
        /// @details Enable close plugin button based on if active tab is subclass of
        /// Gear.PluginSupport.PluginCommon and if that class permit close the window. Typically
        /// the user plugins enabled it; but the cog window, main memory, logic probe, etc,
        /// don't allow to close.
        /// @param[in] sender Reference to object where event was raised.
        /// @param[in] e Event data arguments.
        /// @since V14.07.03 - Added.
        private void documentsTab_Click(object sender, EventArgs e)
        {
            TabPage tp = documentsTab.SelectedTab;

            if (tp.Controls[0] is PluginCommon)
            {
                PluginCommon b = (tp.Controls[0]) as PluginCommon;
                if (b.IsClosable)
                {
                    closeButton.Enabled = true;
                }
                else
                {
                    closeButton.Enabled = false;
                }
            }
            else
            {
                closeButton.Enabled = false;
            }
        }
        /// @brief Include a plugin in active plugin list of propeller instance.
        /// @details It see if the plugin exist already to insert or not.
        /// @param[in] plugin Compiled plugin reference to include.
        public void IncludePlugin(PluginCommon plugin)
        {
            bool found = false;

            foreach (PluginCommon p in PlugIns)
            {
                if (p.Equals(plugin))
                {
                    found = true;
                    break;
                }
            }
            // (!found | (found && !plugin.SingleInstanceAllowed)) is equivalent
            // to (!found | !plugin.SingleInstanceAllowed)
            if (!found | !plugin.SingleInstanceAllowed)
            {
                PlugIns.Add(plugin);
            }
            //if (!(PlugIns.Contains(plugin)))
            //{
            //    PlugIns.Add(plugin);   //add to the list of plugins
            //}
        }
Exemple #11
0
        /// @brief Close the plugin window and terminate the plugin instance.
        /// @details Not only close the tab window, also detach the plugin from the PropellerCPU
        /// what uses it.
        /// @param[in] sender Reference to object where event was raised.
        /// @param[in] e Event data arguments.
        private void closeActiveTab_Click(object sender, EventArgs e)
        {
            TabPage      tp = documentsTab.SelectedTab;
            PluginCommon p  = (PluginCommon)tp.Controls[0];

            if (p != null)          //test if cast to PluginCommon works...
            {
                if (p.IsClosable)   //... so, test if we can close the tab
                {
                    if (documentsTab.SelectedIndex > 0)
                    {
                        //select the previous tab
                        documentsTab.SelectedIndex = documentsTab.SelectedIndex - 1;
                        //tab changing housekeeping for plugin close button
                        documentsTab_Click(this, e);
                        //detach the plugin from the emulator
                        this.DetachPlugin(p);
                        p.Dispose();
                    }
                    tp.Parent = null;   //delete the reference to plugin
                }
                ;
            }
        }
Exemple #12
0
        /// @brief Load a plugin from file.
        /// @details Try to open the XML definition for the plugin from the file name given as
        /// parameter. Then extract information from the XML (class name, auxiliary references
        /// and source code to compile), trying to compile the C# source code (based on
        /// Gear.PluginSupport.PluginCommon class) and returning the new class instance. If the
        /// compilation fails, then it opens the plugin editor to show errors and source code.
        /// @param[in] FileName Name and path to the XML plugin file to open
        /// @returns Reference to the new plugin instance (on success) or NULL (on fail).
        /// @throws Exception
        // TODO Modify the method to receive a PluginData, and delete the validation
        public void LoadPlugin(string FileName)
        {
            object objInst = null;
            //create the structure to fill data from file
            PluginData pluginCandidate = new PluginData();

            //Determine if the XML is valid, and for which DTD version
            if (!pluginCandidate.ValidatePluginFile(FileName))
            {
                string allMessages = string.Empty;
                //case not valid file, so show the errors.
                foreach (string strText in pluginCandidate.ValidationErrors)
                {
                    allMessages += (strText.Trim() + "\r\n");
                }
                /// @todo Add a custom dialog to show every error message in a grid.
                //show messages
                MessageBox.Show(allMessages,
                                "Emulator - OpenPlugin.",
                                MessageBoxButtons.OK,
                                MessageBoxIcon.Error);
            }
            else  //...XML plugin file is valid & system version is determined
            {
                //determine time to use to build the plugin
                DateTime TimeOfBuild = AssemblyUtils.GetFileDateTime(FileName);
                for (int i = 0; i < pluginCandidate.UseExtFiles.Length; i++)
                {
                    if (pluginCandidate.UseExtFiles[i] == true)
                    {
                        TimeOfBuild = DateTime.FromBinary(Math.Max(
                                                              TimeOfBuild.ToBinary(),
                                                              AssemblyUtils.GetFileDateTime(pluginCandidate.ExtFiles[i]).ToBinary()));
                    }
                }
                //generate the full name of the assembly corresponding to the plugin candidate
                string candidateAssemblyFullName =
                    pluginCandidate.PluginAssemblyFullName(TimeOfBuild).FullName;

                //determine the version to look for the correct method to load it
                switch (pluginCandidate.PluginSystemVersion)
                {
                case "0.0":
                    if (PluginPersistence.GetDataFromXML_v0_0(FileName, ref pluginCandidate))
                    {
                        //Search and replace plugin class declarations for V0.0 plugin
                        // system compatibility.
                        pluginCandidate.Codes[0] =
                            PluginSystem.ReplacePropellerClassV0_0(
                                PluginSystem.ReplaceBaseClassV0_0(pluginCandidate.Codes[0]));
                    }
                    break;

                case "1.0":
                    PluginPersistence.GetDataFromXML_v1_0(FileName, ref pluginCandidate);
                    objInst = this.Chip;
                    break;

                default:
                    MessageBox.Show(string.Format("Plugin system version '{0}' not recognized " +
                                                  "on file \"{1}\".", pluginCandidate.PluginSystemVersion, FileName),
                                    "Emulator - Open File.",
                                    MessageBoxButtons.OK,
                                    MessageBoxIcon.Error);
                    return;
                }
                //add information into plugin's code to generate with assembly attributes
                pluginCandidate.Codes[0] = PluginSystem.InsertAssemblyDetails(
                    pluginCandidate.Codes[0],
                    TimeOfBuild,
                    pluginCandidate.InstanceName,
                    pluginCandidate.Description,
                    pluginCandidate.PluginVersion);
                try
                {
                    //Dynamic load and compile the plugin module as a class, giving the chip
                    // instance as a parameter, and casting to appropriate class
                    PluginCommon plugin = ModuleCompiler.LoadModule(
                        pluginCandidate.Codes,                  //string[] codeTexts
                        pluginCandidate.ExtFiles,               //string[] sourceFiles
                        pluginCandidate.InstanceName,           //string module
                        pluginCandidate.References,             //string[] references
                        objInst,                                //object objInstance
                        pluginCandidate.PluginSystemVersion);   //string pluginSystemVersion,
                    if (plugin == null)
                    {
                        throw new Exception("Emulator - OpenPlugin: plugin object not generated!" +
                                            " (null response from memory loading).");
                    }
                    else //if success compiling & instantiate the new instance...
                    {
                        //...add to the corresponding plugin list of the emulator instance
                        AttachPlugin(plugin);
                        //update location of last plugin
                        Properties.Settings.Default.LastPlugin = FileName;
                        Properties.Settings.Default.Save();
                    }
                }
                catch (Exception)
                {
                    //open plugin editor in other window
                    PluginEditor errorPlugin = new PluginEditor(false);
                    if (errorPlugin.OpenFile(FileName, true))
                    {
                        //remember plugin successfully loaded
                        errorPlugin.UpdateLastPluginOpened();
                        //show plugin editor loaded with the faultly one
                        errorPlugin.MdiParent = this.MdiParent;
                        //the compilation errors are displayed in the error grid
                        ModuleCompiler.EnumerateErrors(errorPlugin.EnumErrors);
                        //show the error list
                        errorPlugin.ShowErrorGrid(true);
                        errorPlugin.Show();
                    }
                }
            }
        }