Example #1
0
        public BuildOptions(BuildTarget target, BuildCallback callback)
        {
            this.callback              = callback;
            this.projectTarget         = target;
            this.TargetForDependencies = target;

            this.BuildDependentProjects = true;
            this.ParallelProjectCount   = DefaultParallelProjectCount;
        }
Example #2
0
        void OnProjectItemAdded(object sender, ProjectItemEventArgs e)
        {
            if (e.Project != project)
            {
                return;
            }

            ReferenceProjectItem reference = e.ProjectItem as ReferenceProjectItem;

            if (reference != null)
            {
                if (reference.ItemType == ItemType.COMReference)
                {
                    System.Windows.Forms.MethodInvoker action = delegate {
                        // Compile project to ensure interop library is generated
                        project.Save();                         // project is not yet saved when ItemAdded fires, so save it here
                        TaskService.BuildMessageViewCategory.AppendText("\n${res:MainWindow.CompilerMessages.CreatingCOMInteropAssembly}\n");
                        BuildCallback afterBuildCallback = delegate {
                            lock (callAfterAddComReference) {
                                if (callAfterAddComReference.Count > 0)
                                {
                                    // run next enqueued action
                                    callAfterAddComReference.Dequeue()();
                                }
                                else
                                {
                                    buildingComReference = false;
                                    ParserService.Reparse(project, true, false);
                                }
                            }
                        };
                        BuildEngine.BuildInGui(project, new BuildOptions(BuildTarget.ResolveComReferences, afterBuildCallback));
                    };

                    // enqueue actions when adding multiple COM references so that multiple builds of the same project
                    // are not started parallely
                    lock (callAfterAddComReference) {
                        if (buildingComReference)
                        {
                            callAfterAddComReference.Enqueue(action);
                        }
                        else
                        {
                            buildingComReference = true;
                            action();
                        }
                    }
                }
                else
                {
                    ParserService.Reparse(project, true, false);
                }
            }
            if (e.ProjectItem.ItemType == ItemType.Import)
            {
                UpdateDefaultImports(project.Items);
            }
            else if (e.ProjectItem.ItemType == ItemType.Compile)
            {
                if (System.IO.File.Exists(e.ProjectItem.FileName))
                {
                    ParserService.EnqueueForParsing(e.ProjectItem.FileName);
                }
            }
        }
		public BuildOptions(BuildTarget target, BuildCallback callback)
		{
			this.callback = callback;
			this.projectTarget = target;
			this.TargetForDependencies = target;
			
			this.BuildDependentProjects = true;
			this.ParallelProjectCount = DefaultParallelProjectCount;
		}
Example #4
0
		public BuildOptions(BuildTarget target, BuildCallback callback)
		{
			this.callback = callback;
			this.target = target;
		}
Example #5
0
		public BuildOptions(BuildTarget target, BuildCallback callback, IDictionary<string, string> additionalProperties)
		{
			this.callback = callback;
			this.target = target;
			this.additionalProperties = additionalProperties;
		}
Example #6
0
        public bool Build(BuildCallback cb)
        {
            int cur = cb.Origins.IndexOf(cb.Value);

            EU.VPadding(() => {
                if (null != cb.AddAction && GUILayout.Button(cb.AddAction.Label))
                {
                    T item = new T();
                    cb.Origins.Add(item);
                    if (null != cb.AddAction.OnAdd)
                    {
                        cb.AddAction.OnAdd.Invoke(cb.Origins.Count);
                    }
                }

                EditorGUILayout.LabelField(cb.Label, EditorStyles.boldLabel);

                if (m_alignment == Align.V)
                {
                    GUILayout.BeginVertical();
                }
                else
                {
                    GUILayout.BeginHorizontal();
                }

                cb.Origins.Loop((t, idx) => {
                    EU.HGroup(() => {
                        bool isSelected        = idx == cur;
                        var style              = new GUIStyle(GUI.skin.button);
                        style.normal.textColor = isSelected ? Color.cyan : Color.white;

                        if (null != cb.Prefix)
                        {
                            cb.Prefix(t);
                        }

                        if (GUILayout.Button(cb.Mapper(t), style))
                        {
                            cb.OnSelected.Invoke(new SelectState <T>(idx, cb.Origins[idx]));
                            cur = idx;
                        }

                        if (null != cb.Suffix)
                        {
                            cb.Suffix(t);
                        }

                        if (null != cb.MoveAction && cb.Origins.Count > idx + 1)
                        {
                            EU.BtnWithAlert("V", () => {
                                if (cb.MoveAction.Move != null)
                                {
                                    cb.MoveAction.Move(idx);
                                }
                                else
                                {
                                    cb.Origins.Swap(idx, idx + 1);
                                }
                                cb.MoveAction.OnMoved.Invoke();
                            }, GUILayout.Width(20f));
                        }

                        if (null != cb.DelAction)
                        {
                            EU.BtnWithAlert(cb.DelAction.Label, () => {
                                if (null != cb.DelAction.OnDelete)
                                {
                                    cb.DelAction.OnDelete(new SelectState <T>(idx, cb.Origins[idx]));
                                }
                                else
                                {
                                    cb.Origins.RemoveAt(idx);
                                }
                                if (null != cb.DelAction.OnDeleted)
                                {
                                    cb.DelAction.OnDeleted.Invoke(idx);
                                }
                            }, GUILayout.Width(20f));
                        }
                    });
                });

                if (m_alignment == Align.V)
                {
                    GUILayout.EndVertical();
                }
                else
                {
                    GUILayout.EndHorizontal();
                }
            });

            return(cur > -1);
        }
        void OnProjectItemAdded(object sender, ProjectItemEventArgs e)
        {
            if (e.Project != project)
            {
                return;
            }

            ReferenceProjectItem reference = e.ProjectItem as ReferenceProjectItem;

            if (reference != null)
            {
                if (reference.ItemType == ItemType.COMReference)
                {
                    System.Windows.Forms.MethodInvoker action = delegate {
                        // Compile project to ensure interop library is generated
                        project.Save();                         // project is not yet saved when ItemAdded fires, so save it here
                        TaskService.BuildMessageViewCategory.AppendText("\n${res:MainWindow.CompilerMessages.CreatingCOMInteropAssembly}\n");
                        BuildCallback callback = delegate {
                            System.Threading.ThreadPool.QueueUserWorkItem(AddReference, reference);
                            lock (callAfterAddComReference) {
                                if (callAfterAddComReference.Count > 0)
                                {
                                    callAfterAddComReference.Dequeue()();
                                }
                                else
                                {
                                    buildingComReference = false;
                                }
                            }
                        };
                        project.StartBuild(new BuildOptions(BuildTarget.ResolveComReferences, callback));
                    };
                    lock (callAfterAddComReference) {
                        if (buildingComReference)
                        {
                            callAfterAddComReference.Enqueue(action);
                        }
                        else
                        {
                            buildingComReference = true;
                            action();
                        }
                    }
                }
                else
                {
                    System.Threading.ThreadPool.QueueUserWorkItem(AddReference, reference);
                }
            }
            if (e.ProjectItem.ItemType == ItemType.Import)
            {
                UpdateDefaultImports(project.Items);
            }
            else if (e.ProjectItem.ItemType == ItemType.Compile)
            {
                if (System.IO.File.Exists(e.ProjectItem.FileName))
                {
                    ParserService.EnqueueForParsing(e.ProjectItem.FileName);
                }
            }
        }
Example #8
0
 public BuildOptions(BuildTarget target, BuildCallback callback, IDictionary <string, string> additionalProperties)
 {
     this.callback             = callback;
     this.target               = target;
     this.additionalProperties = additionalProperties;
 }
Example #9
0
 public BuildOptions(BuildTarget target, BuildCallback callback)
 {
     this.callback = callback;
     this.target   = target;
 }
Example #10
0
        /// <summary>
        /// プロジェクトに追加したすべてのコンテンツ ファイルを非同期呼び出しでビルドします。
        /// </summary>
        /// <param name="callback"></param>
        /// <returns></returns>
        public BuildSubmission BuildAsync(BuildCallback callback)
        {
            BuildManager.DefaultBuildManager.BeginBuild(buildParameters);

            var submission = CreateBuildSubmission();

            // 非同期呼び出しでビルドします。
            CreateBuildSubmission().ExecuteAsync(
                (BuildSubmissionCompleteCallback) delegate(BuildSubmission s)
                {
                    BuildManager.DefaultBuildManager.EndBuild();
                    if (callback != null)
                    {
                        callback(s);
                    }
                }, null);

            return submission;
        }