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);
 }

 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);
     }
 }

		void HandleErrorListPadTaskToggled (object sender, TaskEventArgs e)
		{
			this.TextEditor.QueueDraw ();
		}

 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);
 }

 private void OnTaskAdded(object sender, TaskEventArgs e)
 {
     e.Task.TaskEdited += OnTaskEdited;
 }

		void TaskAdded (object sender, TaskEventArgs e)
		{
			AddTasks (e.Tasks);
		}

		void GeneratedTaskRemoved (object sender, TaskEventArgs e)
		{
			foreach (Task t in e.Tasks)
				RemoveGeneratedTask (t);
		}

		public static void FireTaskToggleEvent (object sender, TaskEventArgs e)
		{
			var handler = TaskToggled;
			if (handler != null)
				handler (sender, e);
		}

		protected virtual void OnTaskToggled (TaskEventArgs e)
		{
			EventHandler<TaskEventArgs> handler = this.TaskToggled;
			if (handler != null)
				handler (this, e);
		}

 void value_OnStatusChange(object sender, TaskEventArgs e)
 {
     UpdatedTask.Raise(sender, e);
 }

 private void saveEmailTask_Completed(object sender, TaskEventArgs e)
 {
     if (e.TaskResult == TaskResult.OK)
     {
         saveEmailButton.Visibility = Visibility.Collapsed;
     }
 }

 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();
 }

 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);
 }

		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 ();
		}

 private void TaskStoppedHandler(object sender,
                                  TaskEventArgs<HttpFileDownloadTask> e)
 {
     lock (SyncRoot) {
         if (e.Task.IsCompleted) {
             tasks.Remove (e.Task);
         }
     }
 }

        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;
            }
        }

		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;
				});
			});
		}

		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 ();
		}

		void GeneratedTaskAdded (object sender, TaskEventArgs e)
		{
			foreach (Task t in e.Tasks)
				AddGeneratedTask (t);
		}

		void TaskServiceAdded(object sender, TaskEventArgs e)
		{
			if (e.Task.TaskType == TaskType.Comment) {
				AddItem(e.Task);
			}
		}