public void ProcessPacket(CreatePrebuildsRequest packet, NebulaConnection conn)
 {
     using (FactoryManager.EventFromServer.On())
     {
         BuildToolManager.CreatePrebuildsRequest(packet);
     }
 }
 public override void ProcessPacket(CreatePrebuildsRequest packet, NebulaConnection conn)
 {
     using (FactoryManager.IsIncomingRequest.On())
     {
         BuildToolManager.CreatePrebuildsRequest(packet);
     }
 }
Beispiel #3
0
 public IBuildTool(string name, BuildToolManager manager)
 {
     this.state   = State.STANDARD;
     this.manager = manager;
     this.name    = name;
     activeTile   = null;
     groundPlane  = new Plane(Vector3.up, Vector3.zero);
     topPlane     = new Plane(Vector3.up, Vector3.up);
 }
Beispiel #4
0
        private void ActivatePlugin()
        {
            /*
             * Define the document handling.
             */

            _documentType = new DocumentType(Constants.DOCUMENT_TYPE_VB);

            DocumentManager.GetInstance().RegisterDocumentLanguage(
                _documentType, Constants.SCINTILLA_LANGUAGE_VB);

            ApplicationManager applicationManager =
                ApplicationManager.GetInstance();

            OpenDocumentHandler openHandler =
                applicationManager.GetOpenDocumentHandler(
                    QuickSharp.TextEditor.Constants.DOCUMENT_TYPE_TXT);

            if (openHandler != null)
            {
                applicationManager.RegisterOpenDocumentHandler(
                    _documentType, openHandler);
            }

            /*
             * Define the build tools.
             */

            _buildToolManager = BuildToolManager.GetInstance();

            _buildToolManager.RegisterBuildCommand(
                _documentType,
                QuickSharp.BuildTools.Constants.ACTION_COMPILE,
                CompileBuildCommand);

            _buildToolManager.RegisterBuildCommand(
                _documentType,
                QuickSharp.BuildTools.Constants.ACTION_RUN,
                RunBuildCommand);

            _buildToolManager.RegisterLineParser(
                Resources.MicrosoftVBLineParser,
                _documentType,
                QuickSharp.BuildTools.Constants.ACTION_COMPILE,
                new VBNetOutputLineParser());

            if (_buildToolManager.BuildTools.GetToolCount(
                    _documentType) == 0)
            {
                CreateDefaultTools();
            }

            _buildToolManager.UpdateTools(_documentType);
            _buildToolManager.BuildTools.SortTools();
        }
Beispiel #5
0
        private void ActivatePlugin()
        {
            _buildToolManager = BuildToolManager.GetInstance();
            _settingsManager  = SettingsManager.GetInstance();

            ApplicationManager _applicationManager =
                ApplicationManager.GetInstance();

            _applicationManager.RegisterOpenDocumentHandler(
                Constants.DOCUMENT_TYPE_EXE, OpenIldasmFile);

            _applicationManager.RegisterOpenDocumentHandler(
                Constants.DOCUMENT_TYPE_DLL, OpenIldasmFile);

            _applicationManager.RegisterOptionsPageFactory(
                delegate { return(new SDKToolsOptionsPage()); });

            _mainForm.ClientWindow.ActiveDocumentChanged +=
                new EventHandler(ClientWindow_ActiveDocumentChanged);

            #region Menu Items

            ToolStripMenuItem toolMenu = _mainForm.GetMenuItemByName(
                QuickSharp.Core.Constants.UI_TOOLS_MENU);

            int index = toolMenu.DropDownItems.IndexOfKey(
                QuickSharp.Core.Constants.UI_TOOLS_MENU_OPTIONS);

            /*
             * If the options menu isn't found insert at the top.
             */

            if (index == -1)
            {
                index = 0;
            }

            _toolMenuIldasm = MenuTools.CreateMenuItem(
                Constants.UI_TOOLS_MENU_ILDASM,
                Resources.MainToolsMenuIldasm,
                null, Keys.None, null, UI_TOOLS_MENU_ILDASM_Click);

            _toolMenuClrDbg = MenuTools.CreateMenuItem(
                Constants.UI_TOOLS_MENU_CLRDBG,
                Resources.MainToolsMenuClrDbg,
                Resources.Debug, Keys.Control | Keys.F11,
                null, UI_TOOLS_MENU_CLRDBG_Click,
                true);

            toolMenu.DropDownItems.Insert(index, _toolMenuClrDbg);
            toolMenu.DropDownItems.Insert(index, _toolMenuIldasm);
            toolMenu.DropDownOpening +=
                new EventHandler(toolMenu_DropDownOpening);

            ToolStripMenuItem helpMenu = _mainForm.GetMenuItemByName(
                QuickSharp.Core.Constants.UI_HELP_MENU);

            _helpMenuHelpContents = MenuTools.CreateMenuItem(
                Constants.UI_HELP_MENU_HELP_CONTENTS,
                Resources.MainHelpMenuHelpContents,
                Resources.Help,
                Keys.Control | Keys.F1,
                null, UI_HELP_MENU_HELP_CONTENTS_Click);

            _helpMenuContextHelp = MenuTools.CreateMenuItem(
                Constants.UI_HELP_MENU_CONTEXT_HELP,
                Resources.MainHelpMenuContextHelp,
                null, Keys.F1,
                null, UI_HELP_MENU_CONTEXT_HELP_Click, true);

            helpMenu.DropDownItems.Insert(0, _helpMenuContextHelp);
            helpMenu.DropDownItems.Insert(0, _helpMenuHelpContents);
            helpMenu.DropDownOpening +=
                new EventHandler(helpMenu_DropDownOpening);

            #endregion

            UpdateToolMenuStatus();
            UpdateHelpMenuStatus();
        }
Beispiel #6
0
 public DigTool(BuildToolManager manager) : base("Dig", manager)
 {
 }
Beispiel #7
0
 public HoleTool(BuildToolManager manager) : base("Hole", manager)
 {
 }
Beispiel #8
0
        private bool CreateDefaultTools()
        {
            /*
             * Define the document type.
             */

            _documentType = new DocumentType(Constants.DOCUMENT_TYPE_CS);

            /*
             * Get the build tool locations.
             */

            string monoRootKey = Registry.LocalMachine +
                                 "\\Software\\Novell\\Mono";

            string monoVersion = Registry.GetValue(
                monoRootKey, "DefaultCLR", null) as string;

            if (monoVersion == null)
            {
                return(false);
            }

            string monoPathKey = String.Format("{0}\\{1}",
                                               monoRootKey, monoVersion);

            string monoSDKRootPath = Registry.GetValue(
                monoPathKey, "SdkInstallRoot", null) as string;

            if (String.IsNullOrEmpty(monoSDKRootPath))
            {
                return(false);
            }

            string monoSDKBinPath = Path.Combine(monoSDKRootPath, "bin");

            if (!Directory.Exists(monoSDKBinPath))
            {
                return(false);
            }

            /*
             * Create the default build tool instances for the Mono compilers.
             */

            BuildTool mcscompiler = CreateMonoCompiler(
                Resources.MonoMCSCompiler, monoSDKBinPath, "mcs.bat");

            BuildTool gmcscompiler = CreateMonoCompiler(
                Resources.MonoGMCSCompiler, monoSDKBinPath, "gmcs.bat");

            BuildTool dmcscompiler = CreateMonoCompiler(
                Resources.MonoDMCSCompiler, monoSDKBinPath, "dmcs.bat");

            BuildTool monoexe = new BuildTool(Guid.NewGuid().ToString(),
                                              _documentType, Resources.MonoRuntime);

            monoexe.Action         = QuickSharp.BuildTools.Constants.ACTION_RUN;
            monoexe.Path           = Path.Combine(monoSDKBinPath, "mono.exe");
            monoexe.Args           = "\"${OUT_PATH}\" ${RUNTIME_OPT}";
            monoexe.UserArgs       = String.Empty;
            monoexe.LineParserName = String.Empty;

            BuildToolManager buildToolManager =
                BuildToolManager.GetInstance();

            buildToolManager.BuildTools.AddTool(mcscompiler);
            buildToolManager.BuildTools.AddTool(gmcscompiler);
            buildToolManager.BuildTools.AddTool(dmcscompiler);
            buildToolManager.BuildTools.AddTool(monoexe);

            /*
             * Update the tools collection.
             */

            buildToolManager.UpdateTools(_documentType);
            buildToolManager.BuildTools.SortTools();

            return(true);
        }
Beispiel #9
0
 public SlopeTool(BuildToolManager manager) : base("Dig", manager)
 {
 }