void saveRingtoneTask_Completed(object sender, TaskEventArgs e)
 {
     //string chooserResult = "";
     if (e.Error != null)
         chooserResult.Text = e.Error.Message;
     else if (e.TaskResult == TaskResult.Cancel)
         chooserResult.Text = "user canceled";
     else if (e.TaskResult == TaskResult.None)
         chooserResult.Text = "no result";
     else if (e.TaskResult == TaskResult.OK)
         chooserResult.Text = "ok";
     System.Diagnostics.Debug.WriteLine(chooserResult.Text);
 }
Example #2
0
 void taskTree_OpenTaskConfigFileEvent(object sender, TaskEventArgs e)
 {
     try
     {
         //get the top form
         MainForm mainform = this.TopLevelControl as MainForm;
         if (mainform != null)
             mainform.OpenTaskConfigFile(e.Task);
     }
     catch (Exception ex)
     {
         Program.ShowMessageBox("FrmTaskManager", ex);
     }
 }
Example #3
0
 private void TaskStoppedHandler(object sender,
                                  TaskEventArgs<HttpFileDownloadTask> e)
 {
     lock (SyncRoot) {
         if (e.Task.IsCompleted) {
             tasks.Remove (e.Task);
         }
     }
 }
Example #4
0
 private void OnTaskEdited(object sender, TaskEventArgs e)
 {
     lock (tasksLock)
     for (int i = 0; i != scheduledTasks.Count; ++i)
      for (int j = 0; j < scheduledTasks.Values[i].Count; )
      {
       Task currentTask = scheduledTasks.Values[i][j];
       if (currentTask == e.Task)
        scheduledTasks.Values[i].RemoveAt(j);
       else
        j++;
      }
        if (e.Task.Schedule is RecurringSchedule)
     ScheduleTask(e.Task);
 }
Example #5
0
 // However, if you pick a task in the colonist manager screen, this
 // shuts down the whole building UI. You can't place two tasks in a building
 // anyway so this is probably what the player would want.
 void OnTaskStarted(object sender, TaskEventArgs args)
 {
     CloseBuildingUI();
 }
Example #6
0
		public static void FireTaskToggleEvent (object sender, TaskEventArgs e)
		{
			var handler = TaskToggled;
			if (handler != null)
				handler (sender, e);
		}
Example #7
0
		void TaskAdded (object sender, TaskEventArgs e)
		{
			AddTasks (e.Tasks);
		}
Example #8
0
		protected virtual void OnTaskToggled (TaskEventArgs e)
		{
			EventHandler<TaskEventArgs> handler = this.TaskToggled;
			if (handler != null)
				handler (this, e);
		}
Example #9
0
 protected virtual void OnTaskCompleted(TaskEventArgs args)
 {
     //TODO: (jmd 2015-09-30) Consider wrapping in try catch. They can force the thread to close the app.
     TaskCompleted?.Invoke(this, args);
 }
Example #10
0
 public void cancelPrintInfo(TaskEventArgs e)
 {
     print("取消任务" + e.taskID);
 }
Example #11
0
 public void Handler(TaskEventArgs arg)
 {
     Console.WriteLine("Task \"" + arg.desc + "\" is due (" + arg.toDueTime + ")");
 }
Example #12
0
 public void GetPrintInfo(TaskEventArgs e)
 {
     print("接受任务" + e.taskID);
 }
Example #13
0
 public void rewardPrintInfo(TaskEventArgs e)
 {
     print("奖励物品" + e.id + "数量" + e.amount);
 }
Example #14
0
 public void AddWarnListener(TaskEventArgs listener)
 {
     warnEventListeners += listener;
 }
Example #15
0
 private void TaskAssociatedHandler(object sender,
                                    TaskEventArgs <HttpFileDownloadTask> e)
 {
     dg.Execute();
 }
    /// <summary>
    /// Start the task routine and observe the result of the previous task routine
    /// </summary>
    /// <param name="routine"></param>
    /// <param name="token"></param>
    /// <param name="cancelPrevious"></param>
    /// <param name="throwImmediately"></param>
    public Task <T> StartAsync(
        Func <CancellationToken, Task <T> > routine,
        CancellationToken token,
        bool cancelPrevious   = true,
        bool throwImmediately = true)
    {
        Task <T> previousTask = null;                                          // pending instance
        CancellationTokenSource  previousCts = null;                           // pending instance CTS
        CancellationTokenSource  thisCts     = CancellationTokenSource.CreateLinkedTokenSource(token);
        TaskCompletionSource <T> thisTcs     = new TaskCompletionSource <T>(); // this task
        CancellationToken        thisToken;                                    // this task's cancellation Token
        Task <T> routineTask = null;                                           // as returned by routine

        lock (_lock)
        {
            // remember the _currentTask as previousTask
            previousTask = _currentTask;
            previousCts  = _currentCts;
            thisToken    = thisCts.Token;
            // set the new _currentTask
            _currentTask = thisTcs.Task;
            _currentCts  = thisCts;
        }
        Action startAsync = async() =>
        {
            // because startAsync is "async void" method,
            // any exception not handled inside it
            // will be immediately thrown on the current synchronization context,
            // more details: http://stackoverflow.com/a/22395161/1768303
            // run and await this task
            try
            {
                // await the previous task instance
                if (previousTask != null)
                {
                    if (cancelPrevious)
                    {
                        previousCts.Cancel();
                    }
                    try
                    {
                        await previousTask;
                    }
                    catch (OperationCanceledException)
                    {
                        // ignore previous cancellations
                    }
                }
                thisToken.ThrowIfCancellationRequested();

                routineTask = routine(thisToken);
                await routineTask;
            }
            catch (Exception ex)
            {
                // ignore cancellation
                if (ex is OperationCanceledException)
                {
                    System.Diagnostics.Debug.Print("Task cancelled, id={0}", thisTcs.Task.Id);
                    thisTcs.SetCanceled();
                    return;
                }
                // fire TaskFailing
                System.Diagnostics.Debug.Print("Task failing, id={0}", thisTcs.Task.Id);
                if (this.TaskFailing != null)
                {
                    var args = new TaskEventArgs(thisTcs.Task, ex);
                    this.TaskFailing(this, args);
                    if (args.Handled)
                    {
                        // exception handled
                        // make thisTcs cancelled rather than faulted
                        thisTcs.SetCanceled();
                        return;
                    }
                }
                // exception unhandled
                thisTcs.SetException(ex);
                if (throwImmediately)
                {
                    throw;     // rethrow on the current synchronization context
                }
                // exception should be observed via CurrentTask.Exception
                return;
            }
            // success, fire TaskSucceeded
            System.Diagnostics.Debug.Print("Task succeded, id={0}", thisTcs.Task.Id);
            thisTcs.SetResult(routineTask.Result);
            if (this.TaskSucceeded != null)
            {
                this.TaskSucceeded(this, new TaskEventArgs(thisTcs.Task));
            }
        };

        startAsync();
        return(thisTcs.Task);
    }
Example #17
0
 private void TaskAdded(object sender, TaskEventArgs e)
 {
     if (InvokeRequired)
        {
     Invoke((EventHandler<TaskEventArgs>)TaskAdded, sender, e);
     return;
        }
        MainForm parent = (MainForm)FindForm();
        if (parent != null && (parent.WindowState == FormWindowState.Minimized || !parent.Visible))
        {
     parent.ShowNotificationBalloon(S._("New task added"), S._("{0} " +
      "has just been added to the list of tasks.", e.Task.UIText),
      ToolTipIcon.Info);
        }
        DisplayTask(e.Task);
 }
 private void ValidateScriptAdded(object sender, TaskEventArgs <TaskScript> e)
 {
     Assert.Equal(SqlTaskStatus.Succeeded, e.TaskData.Status);
     Assert.Equal(SampleScript, e.TaskData.Script);
 }
Example #19
0
 private void saveEmailTask_Completed(object sender, TaskEventArgs e)
 {
     if (e.TaskResult == TaskResult.OK)
     {
         saveEmailButton.Visibility = Visibility.Collapsed;
     }
 }
        /// <summary>
        /// Method used to handle the event.
        /// </summary>
        /// <param name="sender">The sender of the event.</param>
        /// <param name="e">The task information.</param>
        private void OnDownloadCompleted(object sender, TaskEventArgs e)
        {
            if (e.Task == null)
            {
                return;
            }

            string fileLocation  = Path.Combine(e.Task.DownloadFilesBase, e.Task.DownloadItem.File.LocalName);
            string finalLocation = Path.Combine(e.Task.DownloadItem.TargetFolder, e.Task.DownloadItem.File.LocalName);

            _log.InfoFormat("Finished downloading enclosure '{0}' from item '{1}' in feed '{2}' to {3}",
                            e.Task.DownloadItem.Enclosure.Url, e.Task.DownloadItem.OwnerItemId,
                            e.Task.DownloadItem.OwnerFeedId, finalLocation);


            // We have a UI for managing enclosures we'll need to keep the task around !
            //DownloadRegistryManager.Current.UnRegisterTask(e.Task);

            try
            {
                /*
                 * Add Zone.Identifier to File to indicate that the file was downloaded from the Web
                 * See http://geekswithblogs.net/ssimakov/archive/2004/08/17/9805.aspx for more details
                 */
                try
                {
                    var FS = new FileStreams(fileLocation);

                    //Remove Zone.Identifier if it already exists since we can't trust it
                    //Not sure if this can happen.
                    int i = FS.IndexOf("Zone.Identifier");
                    if (i != -1)
                    {
                        FS.Remove("Zone.Identifier");
                    }

                    FS.Add("Zone.Identifier");
                    using (FileStream fs = FS["Zone.Identifier"].Open(FileMode.OpenOrCreate, FileAccess.Write))
                    {
                        var writer = new StreamWriter(fs);
                        writer.WriteLine("[ZoneTransfer]");
                        writer.WriteLine("ZoneId=3");
                        writer.Flush();
                    }
                }
                catch (Exception ex)
                {
                    _log.ErrorFormat("Failed to assign Internet (Download) Zone to {0}: {1}", fileLocation, ex.Message);
                }

                if (!Directory.Exists(e.Task.DownloadItem.TargetFolder))
                {
                    Directory.CreateDirectory(e.Task.DownloadItem.TargetFolder);
                }

                /* Move file to TargetFolder from temporary download location*/
                FileHelper.MoveFile(fileLocation, finalLocation, MoveFileFlag.CopyAllowed | MoveFileFlag.ReplaceExisting);

                e.Task.FileName = finalLocation;
                /* Initiate callback to waiting callers */
                if (DownloadCompleted != null)
                {
                    DownloadCompleted(this, new DownloadItemEventArgs(e.Task.DownloadItem));
                }

                var downloader = sender as IDownloader;
                if (downloader != null)
                {
                    Release(downloader);
                }
            }
            catch (Exception error)
            {
                OnDownloadError(this, new DownloadTaskErrorEventArgs(e.Task, error));
                return;
            }

            e.Task.State = DownloadTaskState.Downloaded;
            DownloadRegistryManager.Current.UpdateTask(e.Task);
        }
Example #21
0
		void TaskServiceAdded(object sender, TaskEventArgs e)
		{
			if (e.Task.TaskType == TaskType.Comment) {
				AddItem(e.Task);
			}
		}
Example #22
0
 public void scriptHandler_taskEventHandler(object sender, TaskEventArgs e)
 {
     onScriptUpdate(e);
 }
Example #23
0
        private void saveRingtoneChooser_Completed(object sender, TaskEventArgs e)
        {
            switch (e.TaskResult)
            {
                //Logic for when the ringtone was saved successfully
                case TaskResult.OK:
                    // MessageBox.Show("Ringtone saved.");
                    break;

                //Logic for when the task was cancelled by the user
                case TaskResult.Cancel:
                    // MessageBox.Show("Save cancelled.");
                    break;

                //Logic for when the ringtone could not be saved
                case TaskResult.None:
                    MessageBox.Show("Ringtone could not be saved.");
                    break;
            }
        }
Example #24
0
 public void FinishTask(TaskEventArgs e)
 {
     finishEvent(this, e);
 }
		void GeneratedTaskRemoved (object sender, TaskEventArgs e)
		{
			foreach (Task t in e.Tasks)
				RemoveGeneratedTask (t);
		}
Example #26
0
        private SimpleMarkerSymbol GetPointSymbol(XmlNode data)
        {
            XmlDocument xd = new XmlDocument();

            xd.LoadXml(data.OuterXml);
            SimpleMarkerSymbol sms = new SimpleMarkerSymbol();

            try
            {
                Color c = ColorTranslator.FromHtml(TaskEventArgs.GetString(xd, "//LColor"));
                sms.Color   = System.Windows.Media.Color.FromArgb(255, 255, 255, 255);
                sms.Size    = 5;
                sms.Outline = new SimpleLineSymbol {
                    Color   = System.Windows.Media.Color.FromArgb((byte)(double.Parse(TaskEventArgs.GetString(xd, "//Transpatecy")) * 255), c.R, c.G, c.B)
                    , Style = SimpleLineStyle.Solid, Width = sms.Size
                };
            }
            catch (Exception ee)
            {
                LogUtil.Error(GetType(), ee);
            }
            return(sms);
        }
Example #27
0
 private void OnTaskAdded(object sender, TaskEventArgs e)
 {
     e.Task.TaskEdited += OnTaskEdited;
 }
Example #28
0
        private Graphic GetGraphic(XmlNode data)
        {
            var xd = new XmlDocument();
            var g  = new Graphic();

            try
            {
                xd.LoadXml(data.OuterXml);
                g.Geometry             = new MapPoint(TaskEventArgs.GetDouble(xd, "//LON"), TaskEventArgs.GetDouble(xd, "//LAT"));
                g.Attributes["ID"]     = TaskEventArgs.GetGuid(xd, "//Guid");
                g.Attributes["Lon"]    = TaskEventArgs.GetDouble(xd, "//LON");
                g.Attributes["Lat"]    = TaskEventArgs.GetDouble(xd, "//LAT");
                g.Attributes["Label"]  = TaskEventArgs.GetString(xd, "//Label");
                g.Attributes["Time"]   = TaskEventArgs.GetTime(xd, "//Time").ToString();
                g.Attributes["Speed"]  = TaskEventArgs.GetDouble(xd, "//Speed");
                g.Attributes["Status"] = TaskEventArgs.GetString(xd, "//Status");
                g.Attributes["Icon"]   = TaskEventArgs.GetString(xd, "//Icon");
                g.Attributes["Remark"] = TaskEventArgs.GetString(xd, "//Remark");
                g.Attributes["Angle"]  = TaskEventArgs.GetString(xd, "//Angle");
            }
            catch (Exception ee)
            {
                LogUtil.Error(GetType(), ee);
                g = null;
            }
            return(g);
        }
Example #29
0
		void HandleErrorListPadTaskToggled (object sender, TaskEventArgs e)
		{
			this.TextEditor.QueueDraw ();
		}
Example #30
0
        private void GetIcon(XmlNode data)
        {
            XmlDocument xd = new XmlDocument();

            xd.LoadXml(data.OuterXml);
            _startIcon = Image.FromFile(AppDomain.CurrentDomain.BaseDirectory + "Asset\\Icon\\" + TaskEventArgs.GetString(xd, "//StartIcon") + ".png");
            _icon      = Image.FromFile(AppDomain.CurrentDomain.BaseDirectory + "Asset\\Icon\\" + TaskEventArgs.GetString(xd, "//Icon") + ".png");
        }
Example #31
0
 public void finishPrintInfo(System.Object sender, TaskEventArgs e)
 {
     Debug.Log("完成任务" + e.teskID);
 }
Example #32
0
        private SimpleLineSymbol GetTrackSymbol(XmlNode data)
        {
            XmlDocument xd = new XmlDocument();

            xd.LoadXml(data.OuterXml);

            var sls = new SimpleLineSymbol();

            try
            {
                Color c;
                switch (TaskEventArgs.GetString(xd, "//LStyle"))
                {
                case "solid":
                    sls       = new SimpleLineSymbol();
                    c         = ColorTranslator.FromHtml(TaskEventArgs.GetString(xd, "//LColor"));
                    sls.Color = System.Windows.Media.Color.FromArgb((byte)(double.Parse(TaskEventArgs.GetString(xd, "//Transpatecy")) * 255), c.R, c.G, c.B);
                    sls.Width = double.Parse(TaskEventArgs.GetString(xd, "//LWight"));
                    break;

                case "dash":
                    sls = new SimpleLineSymbol {
                        Style = SimpleLineStyle.Dash
                    };
                    c         = ColorTranslator.FromHtml(TaskEventArgs.GetString(xd, "//LColor"));
                    sls.Color = System.Windows.Media.Color.FromArgb((byte)(double.Parse(TaskEventArgs.GetString(xd, "//Transpatecy")) * 255), c.R, c.G, c.B);
                    sls.Width = double.Parse(TaskEventArgs.GetString(xd, "//LWight"));
                    break;

                default:
                    sls       = new SimpleLineSymbol();
                    c         = ColorTranslator.FromHtml(TaskEventArgs.GetString(xd, "//LColor"));
                    sls.Color = System.Windows.Media.Color.FromArgb((byte)(double.Parse(TaskEventArgs.GetString(xd, "//Transpatecy")) * 255), c.R, c.G, c.B);
                    sls.Width = double.Parse(TaskEventArgs.GetString(xd, "//LWight"));
                    break;
                }
            }
            catch (Exception ee)
            {
                LogUtil.Error(GetType(), ee);
            }

            return(sls);
        }
Example #33
0
		void UserTasksChanged (object sender, TaskEventArgs e)
		{
			if (updating)
				return;

			if (view.IsRealized)
				view.ScrollToPoint (0, 0);

			store.Clear ();
			foreach (TaskListEntry task in TaskService.UserTasks) {
				store.AppendValues (GettextCatalog.GetString (Enum.GetName (typeof (TaskPriority), task.Priority)), task.Completed, task.Description, task, GetColorByPriority (task.Priority), task.Completed ? (int)Pango.Weight.Light : (int)Pango.Weight.Bold);
			}
			ValidateButtons ();
		}
Example #34
0
    void OnGUI()
    {
        if (GUILayout.Button("接受任务Task1"))
        {
            TaskManager.Instance.GetTask("Task1");
        }

        if (GUILayout.Button("接受任务Task2"))
        {
            TaskManager.Instance.GetTask("Task2");
        }

        if (GUILayout.Button("接受任务Task3"))
        {
            TaskManager.Instance.GetTask("Task3");
        }

        if (GUILayout.Button("打怪Enemy1"))
        {
            TaskEventArgs e = new TaskEventArgs();
            e.id     = "Enemy1";
            e.amount = 1;
            MesManager.Instance.Check(e);
        }

        if (GUILayout.Button("打怪Enemy2"))
        {
            TaskEventArgs e = new TaskEventArgs();
            e.id     = "Enemy2";
            e.amount = 1;
            MesManager.Instance.Check(e);
        }

        if (GUILayout.Button("获取物体Item1"))
        {
            TaskEventArgs e = new TaskEventArgs();
            e.id     = "Item1";
            e.amount = 1;
            MesManager.Instance.Check(e);
        }

        if (GUILayout.Button("获取物体Item2"))
        {
            TaskEventArgs e = new TaskEventArgs();
            e.id     = "Item2";
            e.amount = 1;
            MesManager.Instance.Check(e);
        }

        if (GUILayout.Button("丢弃物体Item1"))
        {
            TaskEventArgs e = new TaskEventArgs();
            e.id     = "Item1";
            e.amount = -1;
            MesManager.Instance.Check(e);
        }

        if (GUILayout.Button("丢弃物体Item2"))
        {
            TaskEventArgs e = new TaskEventArgs();
            e.id     = "Item2";
            e.amount = -1;
            MesManager.Instance.Check(e);
        }

        if (GUILayout.Button("打开任务面板"))
        {
            taskPanel.SetActive(true);
        }

        if (GUILayout.Button("关闭任务面板"))
        {
            taskPanel.SetActive(false);
        }
    }
Example #35
0
 private void TaskDeleted(object sender, TaskEventArgs e)
 {
     if (InvokeRequired)
        {
     Invoke((EventHandler<TaskEventArgs>)TaskDeleted, sender, e);
     return;
        }
        foreach (ListViewItem item in scheduler.Items)
     if (((Task)item.Tag) == e.Task)
     {
      scheduler.Items.Remove(item);
      break;
     }
        PositionProgressBar();
 }
Example #36
0
 //检查事件
 public void Check(TaskEventArgs e)
 {
     checkEvent(this, e);
 }
 void value_OnStatusChange(object sender, TaskEventArgs e)
 {
     UpdatedTask.Raise(sender, e);
 }
Example #38
0
        private void MakeRingtone(object sender, TaskEventArgs e)
        {
            MP3File Test = new MP3File();
            Test.Initialize("RINGIFY_RINGTONE.mp3");

            if (e.TaskResult == TaskResult.OK)
            {
                MessageBox.Show("Your Ringtone was created!\n\nThe Ringtone is now listed in\n[Settings] -> [Ringtones + Sounds]\n under the Rintones selector.");
                Debugger.Trace("Save Completed");
            }
            else if (e.TaskResult == TaskResult.Cancel)
            {
                Debugger.Trace("Save Cancelled");
                if (e.Error != null)
                {
                    MessageBox.Show(e.Error.Message);
                    //TextBlock_Error.Text = e.Error.Message;

                    Debugger.Trace(e.Error);
                    Debugger.Trace("FILE_SIZE [" + Test.Size + "]");
                }
            }
            else if (e.TaskResult == TaskResult.None)
            {
                TextBlock_Error.Text = "None!";
                Debugger.Trace("None");
                if (e.Error != null)
                {
                    TextBlock_Error.Text = e.Error.Message;
                    Debugger.Trace(e.Error);
                }
            }

            TextBlock_Error.Text += "FILE_SIZE [" + Test.Size + "]";
        }
		void UpdateTasks (object sender, TaskEventArgs e)
		{
			Task[] tasks = TaskService.Errors.GetFileTasks (ContentName);
			if (tasks == null)
				return;
			DisposeErrorMarkers ();
			if (IdeApp.Preferences.ShowMessageBubbles == ShowMessageBubbles.Never)
				return;
			widget.Document.BeginAtomicUndo ();
			
			foreach (Task task in tasks) {
				if (task.Severity == TaskSeverity.Error || task.Severity == TaskSeverity.Warning) {
					if (IdeApp.Preferences.ShowMessageBubbles == ShowMessageBubbles.ForErrors && task.Severity == TaskSeverity.Warning)
						continue;
					LineSegment lineSegment = widget.Document.GetLine (task.Line - 1);
					if (lineSegment == null)
						continue;
					var marker = currentErrorMarkers.FirstOrDefault (m => m.LineSegment == lineSegment);
					if (marker != null) {
						marker.AddError (task.Severity == TaskSeverity.Error, task.Description);
						continue;
					}
					MessageBubbleTextMarker errorTextMarker = new MessageBubbleTextMarker (widget.TextEditor, task, lineSegment, task.Severity == TaskSeverity.Error, task.Description);
					currentErrorMarkers.Add (errorTextMarker);
					
					errorTextMarker.IsExpanded = !IdeApp.Preferences.DefaultHideMessageBubbles;
					widget.Document.AddMarker (lineSegment, errorTextMarker, false);
				}
			}
			widget.Document.EndAtomicUndo ();
			widget.TextEditor.QueueDraw ();
		}
Example #40
0
 void TaskServiceAdded(object sender, TaskEventArgs e)
 {
     if (TaskService.InUpdate)
         return;
     AddTask(e.Task);
     MenuService.UpdateText(toolBar.Items);
 }
Example #41
0
		void TaskServiceRemoved(object sender, TaskEventArgs e)
		{
			if (e.Task.TaskType == TaskType.Comment) {
				tasks.Remove(e.Task);
			}
		}
Example #42
0
 /// <summary>
 /// 初始化任务池事件
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="e"></param>
 void TaskPoolBuilder_OnInitTaskPoolEvent(object sender, TaskEventArgs e)
 {
     OnInit(e.msg, e.ex);
 }
Example #43
0
 void OnTaskDeleted(object sender, TaskEventArgs e)
 {
     e.Task.TaskStarted -= OnTaskProcessing;
        e.Task.TaskFinished -= OnTaskProcessed;
 }
        void mt_TaskCompleted(object sender, TaskEventArgs e)
        {
            StringBuilder sb = new StringBuilder();

            if (e is MensurationPointEventArgs)
            {
                MensurationPointResult result = (e as MensurationPointEventArgs).Result;

                if (result != null && result.Point != null)
                {
                    sb.Append(result.Point);
                    sb.Append("\n");
                }
            }
            else if (e is MensurationHeightEventArgs)
            {
                MensurationHeightResult result = (e as MensurationHeightEventArgs).Result;

                if (result != null)
                {
                    if (result.Height != null)
                    {
                        sb.Append("Height\n");
                        sb.AppendFormat("Value:\t\t{0}\n", result.Height.Value);
                        sb.AppendFormat("Display Value:\t{0}\n", result.Height.DisplayValue);
                        sb.AppendFormat("Uncertainty:\t{0}\n", result.Height.Uncertainty);
                        sb.AppendFormat("Unit:\t\t{0}\n", result.Height.LinearUnit);
                        sb.Append("\n");
                    }
                }
            }
            else if (e is MensurationLengthEventArgs)
            {
                MensurationLengthResult result = (e as MensurationLengthEventArgs).Result;

                if (result != null)
                {
                    if (result.Distance != null)
                    {
                        sb.Append("Distance\n");
                        sb.AppendFormat("Value:\t\t{0}\n", result.Distance.Value);
                        sb.AppendFormat("Display Value:\t{0}\n", result.Distance.DisplayValue);
                        sb.AppendFormat("Uncertainty:\t{0}\n", result.Distance.Uncertainty);
                        sb.AppendFormat("Unit:\t\t{0}\n", result.Distance.LinearUnit);
                        sb.Append("\n");
                    }
                    if (result.AzimuthAngle != null)
                    {
                        sb.Append("Azimuth Angle\n");
                        sb.AppendFormat("Value:\t\t{0}\n", result.AzimuthAngle.Value);
                        sb.AppendFormat("Display Value:\t{0}\n", result.AzimuthAngle.DisplayValue);
                        sb.AppendFormat("Uncertainty:\t{0}\n", result.AzimuthAngle.Uncertainty);
                        sb.AppendFormat("Unit:\t\t{0}\n", result.AzimuthAngle.AngularUnit);
                        sb.Append("\n");
                    }
                    if (result.ElevationAngle != null)
                    {
                        sb.Append("Elevation Angle\n");
                        sb.AppendFormat("Value:\t\t{0}\n", result.ElevationAngle.Value);
                        sb.AppendFormat("Display Value:\t{0}\n", result.ElevationAngle.DisplayValue);
                        sb.AppendFormat("Uncertainty:\t{0}\n", result.ElevationAngle.Uncertainty);
                        sb.AppendFormat("Unit:\t\t{0}\n", result.ElevationAngle.AngularUnit);
                        sb.Append("\n");
                    }
                }
            }
            else if (e is MensurationAreaEventArgs)
            {
                MensurationAreaResult result = (e as MensurationAreaEventArgs).Result;

                if (result != null)
                {
                    if (result.Area != null)
                    {
                        sb.Append("Area\n");
                        sb.AppendFormat("Value:\t\t{0}\n", result.Area.Value);
                        sb.AppendFormat("Display Value:\t{0}\n", result.Area.DisplayValue);
                        sb.AppendFormat("Uncertainty:\t{0}\n", result.Area.Uncertainty);
                        sb.AppendFormat("Unit:\t\t{0}\n", result.Area.AreaUnit);
                        sb.Append("\n");
                    }
                    if (result.Perimeter != null)
                    {
                        sb.Append("Perimeter\n");
                        sb.AppendFormat("Value:\t\t{0}\n", result.Perimeter.Value);
                        sb.AppendFormat("Display Value:\t{0}\n", result.Perimeter.DisplayValue);
                        sb.AppendFormat("Uncertainty:\t{0}\n", result.Perimeter.Uncertainty);
                        sb.AppendFormat("Unit:\t\t{0}\n", result.Perimeter.LinearUnit);
                        sb.Append("\n");
                    }
                }
            }

            MessageBox.Show(sb.ToString());
        }
Example #45
0
 void TaskServiceRemoved(object sender, TaskEventArgs e)
 {
     if (TaskService.InUpdate)
         return;
     errors.Remove(e.Task);
     MenuService.UpdateText(toolBar.Items);
 }
Example #46
0
 private void Task_Completed(BackgroundTaskRunner <IBackgroundTask> sender, TaskEventArgs <IBackgroundTask> e)
 {
     _logger.Info <ScheduledLoggerComponent>("Scheduled Logger run finished");
 }
		void UpdateTasks (object sender, TaskEventArgs e)
		{
			TaskListEntry [] tasks = TaskService.Errors.GetFileTasks (ContentName);
			if (tasks == null)
				return;
			DisposeErrorMarkers (); // disposes messageBubbleCache as well.
			if (IdeApp.Preferences.ShowMessageBubbles == ShowMessageBubbles.Never)
				return;
			messageBubbleCache = new MessageBubbleCache (widget.TextEditor);
			CancelMessageBubbleUpdate ();
			var token = messageBubbleUpdateSource;

			Task.Run (delegate {
				var errorMarkers = new List<MessageBubbleTextMarker> ();
				foreach (TaskListEntry task in tasks) {
					if (token.IsCancellationRequested)
						return null;
					if (task.Severity == TaskSeverity.Error || task.Severity == TaskSeverity.Warning) {
						if (IdeApp.Preferences.ShowMessageBubbles == ShowMessageBubbles.ForErrors && task.Severity == TaskSeverity.Warning)
							continue;
						var errorTextMarker = new MessageBubbleTextMarker (messageBubbleCache, task, task.Severity == TaskSeverity.Error, task.Description);
						errorMarkers.Add (errorTextMarker);

						errorTextMarker.IsVisible = !IdeApp.Preferences.DefaultHideMessageBubbles;
					}
				}
				return errorMarkers;
			}).ContinueWith (t => {
				if (token.IsCancellationRequested)
					return;
				Application.Invoke (delegate {
					if (token.IsCancellationRequested)
						return;
					var newErrorMarkers = new List<MessageBubbleTextMarker> ();
					foreach (var marker in t.Result) {
						if (token.IsCancellationRequested)
							return;
						var lineSegment = widget.Document.GetLine (marker.Task.Line);
						if (lineSegment == null)
							continue;
						var oldMarker = lineSegment.Markers.OfType<MessageBubbleTextMarker> ().FirstOrDefault ();
						if (oldMarker != null) {
							oldMarker.AddError (marker.Task, marker.Task.Severity == TaskSeverity.Error, marker.Task.Description);
						} else {
							marker.LineSegment = lineSegment;
							widget.Document.AddMarker (lineSegment, marker, false);
							newErrorMarkers.Add (marker);
						}
					}
					this.currentErrorMarkers = newErrorMarkers;
				});
			});
		}
Example #48
0
 private void OnReceiveEvent(object sender, TaskEventArgs args)
 {
     _eventArgs = args;
 }
		void GeneratedTaskAdded (object sender, TaskEventArgs e)
		{
			foreach (Task t in e.Tasks)
				AddGeneratedTask (t);
		}
Example #50
0
 void OnAdded(object sender, TaskEventArgs e)
 {
     AddTask(e.Task, true);
 }
Example #51
0
		void TaskChanged (object sender, TaskEventArgs e)
		{
			this.view.QueueDraw ();
		}
 /// <summary>
 /// 接受消息后的回调函数
 /// </summary>
 void OnTaskStep(int eventTypeId, TaskEventArgs e)
 {
 }
Example #53
0
 private void EraseFilesystemObject(Task task, FileSystemObjectTarget target)
 {
     long dataTotal = 0;
        List<string> paths = target.GetPaths(out dataTotal);
        ErasureMethod method = target.Method;
        TaskEventArgs eventArgs = new TaskEventArgs(task);
        SteppedProgressManager progress = new SteppedProgressManager();
        target.Progress = progress;
        task.Progress.Steps.Add(new SteppedProgressManager.Step(progress, 1.0f / task.Targets.Count));
        for (int i = 0; i < paths.Count; ++i)
        {
     ProgressManager step = new ProgressManager();
     progress.Steps.Add(new SteppedProgressManager.Step(step,
      1.0f / paths.Count, S._("Erasing files...")));
     task.OnProgressChanged(target,
      new ProgressChangedEventArgs(step,
       new TaskProgressChangedEventArgs(paths[i], 0, method.Passes)));
     StreamInfo info = new StreamInfo(paths[i]);
     FileSystem fsManager = FileSystemManager.Get(
      VolumeInfo.FromMountpoint(info.DirectoryName));
     if (!info.Exists)
     {
      task.Log.LastSessionEntries.Add(new LogEntry(S._("The file {0} was not erased " +
       "as the file does not exist.", paths[i]), LogLevel.Notice));
      continue;
     }
     bool isReadOnly = false;
     try
     {
      if (isReadOnly = info.IsReadOnly)
       info.IsReadOnly = false;
      if ((info.Attributes & FileAttributes.Compressed) != 0 ||
       (info.Attributes & FileAttributes.Encrypted) != 0 ||
       (info.Attributes & FileAttributes.SparseFile) != 0)
      {
       task.Log.LastSessionEntries.Add(new LogEntry(S._("The file {0} could " +
        "not be erased because the file was either compressed, encrypted or " +
        "a sparse file.", info.FullName), LogLevel.Error));
      }
      fsManager.EraseFileSystemObject(info, method,
       delegate(long lastWritten, long totalData, int currentPass)
       {
        if (currentTask.Canceled)
     throw new OperationCanceledException(S._("The task was cancelled."));
        step.Completed += lastWritten;
        step.Total = totalData;
        task.OnProgressChanged(target,
     new ProgressChangedEventArgs(step,
      new TaskProgressChangedEventArgs(info.FullName, currentPass, method.Passes)));
       });
      FileInfo fileInfo = info.File;
      if (fileInfo != null)
       fsManager.DeleteFile(fileInfo);
      step.Completed = step.Total = 1;
     }
     catch (UnauthorizedAccessException)
     {
      task.Log.LastSessionEntries.Add(new LogEntry(S._("The file {0} could not " +
       "be erased because the file's permissions prevent access to the file.",
       info.FullName), LogLevel.Error));
     }
     catch (FileLoadException)
     {
      if (!ManagerLibrary.Settings.ForceUnlockLockedFiles)
       throw;
      List<System.Diagnostics.Process> processes = new List<System.Diagnostics.Process>();
      foreach (OpenHandle handle in OpenHandle.Items)
       if (handle.Path == paths[i])
        processes.Add(System.Diagnostics.Process.GetProcessById(handle.ProcessId));
      StringBuilder processStr = new StringBuilder();
      foreach (System.Diagnostics.Process process in processes)
       processStr.AppendFormat(System.Globalization.CultureInfo.InvariantCulture,
        "{0}, ", process.MainModule.FileName);
      task.Log.LastSessionEntries.Add(new LogEntry(S._(
       "Could not force closure of file \"{0}\" (locked by {1})",
       paths[i], processStr.ToString().Remove(processStr.Length - 2)), LogLevel.Error));
     }
     finally
     {
      if (isReadOnly && info.Exists && !info.IsReadOnly)
       info.IsReadOnly = isReadOnly;
     }
        }
        if (target is FolderTarget)
        {
     ProgressManager step = new ProgressManager();
     progress.Steps.Add(new SteppedProgressManager.Step(step,
      0.0f, S._("Removing folders...")));
     FolderTarget fldr = (FolderTarget)target;
     FileSystem fsManager = FileSystemManager.Get(VolumeInfo.FromMountpoint(fldr.Path));
     Action<DirectoryInfo> eraseEmptySubFolders = null;
     eraseEmptySubFolders = delegate(DirectoryInfo info)
     {
       foreach (DirectoryInfo subDir in info.GetDirectories())
        eraseEmptySubFolders(subDir);
       task.OnProgressChanged(target,
        new ProgressChangedEventArgs(step,
     new TaskProgressChangedEventArgs(info.FullName, 0, 0)));
       FileSystemInfo[] files = info.GetFileSystemInfos();
       if (files.Length == 0)
        fsManager.DeleteFolder(info);
     };
     eraseEmptySubFolders(new DirectoryInfo(fldr.Path));
     if (fldr.DeleteIfEmpty)
     {
      DirectoryInfo info = new DirectoryInfo(fldr.Path);
      task.OnProgressChanged(target,
       new ProgressChangedEventArgs(step,
        new TaskProgressChangedEventArgs(info.FullName, 0, 0)));
      bool isVolumeRoot = info.Parent == null;
      foreach (VolumeInfo volume in VolumeInfo.Volumes)
       foreach (string mountPoint in volume.MountPoints)
        if (info.FullName == mountPoint)
     isVolumeRoot = true;
      if (!isVolumeRoot && info.Exists && info.GetFiles("*", SearchOption.AllDirectories).Length == 0)
       fsManager.DeleteFolder(info);
     }
        }
        if (target is RecycleBinTarget)
        {
     ProgressManager step = new ProgressManager();
     progress.Steps.Add(new SteppedProgressManager.Step(step,
      0.0f, S._("Emptying recycle bin...")));
     task.OnProgressChanged(target,
      new ProgressChangedEventArgs(step,
       new TaskProgressChangedEventArgs(string.Empty, 0, 0)));
     ShellApi.EmptyRecycleBin(EmptyRecycleBinOptions.NoConfirmation |
      EmptyRecycleBinOptions.NoProgressUI | EmptyRecycleBinOptions.NoSound);
        }
        target.Progress = null;
 }
Example #54
0
 void TaskChanged(object sender, TaskEventArgs e)
 {
     this.view.QueueDraw();
 }
Example #55
0
 private void OnTaskDeleted(object sender, TaskEventArgs e)
 {
     e.Task.TaskEdited -= OnTaskEdited;
 }
Example #56
0
 void TaskAdded(object sender, TaskEventArgs e)
 {
     AddTasks(e.Tasks);
 }
Example #57
0
		void HandleTaskServiceJumpedToTask (object sender, TaskEventArgs e)
		{
			var task = e.Tasks != null ? e.Tasks.FirstOrDefault () : null;
			var doc = Document;
			if (task == null || doc == null || task.FileName != doc.FileName || this.TextEditor == null)
				return;
			var lineSegment = doc.GetLine (task.Line);
			if (lineSegment == null)
				return;
			var marker = (MessageBubbleTextMarker)lineSegment.Markers.FirstOrDefault (m => m is MessageBubbleTextMarker);
			if (marker == null)
				return;
			
			marker.SetPrimaryError (task.Description);
			
			if (TextEditor != null && TextEditor.IsComposited) {
				if (messageBubbleHighlightPopupWindow != null)
					messageBubbleHighlightPopupWindow.Destroy ();
				messageBubbleHighlightPopupWindow = new MessageBubbleHighlightPopupWindow (this, marker);
				messageBubbleHighlightPopupWindow.Destroyed += delegate {
					messageBubbleHighlightPopupWindow = null;
				};
				messageBubbleHighlightPopupWindow.Popup ();
			}
		}
Example #58
0
 public void getPrintInfo(System.Object sender, TaskEventArgs e)
 {
     Debug.Log("接受任务" + e.teskID);
 }
Example #59
0
		void UpdateTasks (object sender, TaskEventArgs e)
		{
			Task[] tasks = TaskService.Errors.GetFileTasks (ContentName);
			if (tasks == null)
				return;
			DisposeErrorMarkers (); // disposes messageBubbleCache as well.
			if (IdeApp.Preferences.ShowMessageBubbles == ShowMessageBubbles.Never)
				return;
			using (var undo = Document.OpenUndoGroup ()) {
				if (messageBubbleCache != null)
					messageBubbleCache.Dispose ();
				messageBubbleCache = new MessageBubbleCache (widget.TextEditor);
				
				foreach (Task task in tasks) {
					if (task.Severity == TaskSeverity.Error || task.Severity == TaskSeverity.Warning) {
						if (IdeApp.Preferences.ShowMessageBubbles == ShowMessageBubbles.ForErrors && task.Severity == TaskSeverity.Warning)
							continue;
						DocumentLine lineSegment = widget.Document.GetLine (task.Line);
						if (lineSegment == null)
							continue;
						var marker = currentErrorMarkers.FirstOrDefault (m => m.LineSegment == lineSegment);
						if (marker != null) {
							marker.AddError (task.Severity == TaskSeverity.Error, task.Description);
							continue;
						}
						MessageBubbleTextMarker errorTextMarker = new MessageBubbleTextMarker (messageBubbleCache, task, lineSegment, task.Severity == TaskSeverity.Error, task.Description);
						currentErrorMarkers.Add (errorTextMarker);
						
						errorTextMarker.IsVisible =  !IdeApp.Preferences.DefaultHideMessageBubbles;
						widget.Document.AddMarker (lineSegment, errorTextMarker, false);
					}
				}
			}
			widget.TextEditor.QueueDraw ();
		}
Example #60
0
 //<snippet208>
 protected override void OnInvoked(EventArgs e)
 {
     EventArgs = e as TaskEventArgs;
 }