C# Core.PropertyChangedEventArgs类代码示例

		void PropertyChanged (object sender, PropertyChangedEventArgs prop)
		{
			var name = (string)prop.NewValue ?? styleSource.Style.FontDescription.ToString ();
			Update (name);
			if (resizer != null)
				resizer ();
		}

		void PropertyServiceChanged (object sender, PropertyChangedEventArgs e)
		{
			switch (e.Key) {
			case "ColorScheme": {
				string val = (string) e.NewValue;
				if (string.IsNullOrEmpty (val))
					val = "Default";
				base.ColorScheme = val;
				break;
			}
			}
		}

 		static void HandlePropertiesPropertyChanged (object sender, PropertyChangedEventArgs e)
 		{
			if (e.Key == ShowSchemaAnnotationPropertyName) {
				showSchemaAnnotation = (bool)e.NewValue;
			} else if (e.Key == AutoCompleteElementsPropertyName) {
				autoCompleteElements = (bool)e.NewValue;
			} else if (e.Key == AutoInsertFragmentsPropertyName) {
				autoInsertFragments = (bool)e.NewValue;
			} else if (XmlFileAssociationChanged != null && e.Key.StartsWith (AssociationPrefix, StringComparison.Ordinal)) {
				var ext = e.Key.Substring (AssociationPrefix.Length);
				var assoc = e.NewValue as XmlFileAssociation;
				XmlFileAssociationChanged (null, new XmlFileAssociationChangedEventArgs (ext, assoc));
			}
 		}

		void HandleIdeAppPreferencesDefaultHideMessageBubblesChanged (object sender, PropertyChangedEventArgs e)
		{
			currentErrorMarkers.ForEach (marker => marker.IsVisible =  !IdeApp.Preferences.DefaultHideMessageBubbles);
			this.TextEditor.QueueDraw ();
		}

		// Need to be picky about only updating individual properties when they change.
		// The old approach called LoadAllPrefs on any prefs event, which sometimes caused 
		// massive change event storms.
		void UpdatePreferences (object sender, PropertyChangedEventArgs args)
		{
			try {
				switch (args.Key) {
				case "TabIsReindent": 
					this.TabIsReindent = (bool)args.NewValue;
					break;
				case "EnableSemanticHighlighting":
					this.EnableSemanticHighlighting = (bool)args.NewValue;
					break;
				case "AutoInsertMatchingBracket":
					this.AutoInsertMatchingBracket = (bool)args.NewValue;
					break;
				case "UnderlineErrors":
					this.UnderlineErrors = (bool)args.NewValue;
					break;
				case "IndentStyle":
					if (args.NewValue == null) {
						LoggingService.LogWarning ("tried to set indent style == null");
					} else if (!(args.NewValue is IndentStyle)) {
						LoggingService.LogWarning ("tried to set indent style to " + args.NewValue + " which isn't from type IndentStyle instead it is from:" + args.NewValue.GetType ());
						this.IndentStyle = (IndentStyle)Enum.Parse (typeof(IndentStyle), args.NewValue.ToString ());
					} else 
						this.IndentStyle = (IndentStyle)args.NewValue;
					break;
				case "ShowLineNumberMargin":
					base.ShowLineNumberMargin = (bool)args.NewValue;
					break;
				case "ShowFoldMargin":
					base.ShowFoldMargin = (bool)args.NewValue;
					break;
				case "HighlightCaretLine":
					base.HighlightCaretLine = (bool)args.NewValue;
					break;
				case "EnableSyntaxHighlighting":
					base.EnableSyntaxHighlighting = (bool)args.NewValue;
					break;
				case "HighlightMatchingBracket":
					base.HighlightMatchingBracket = (bool)args.NewValue;
					break;
				case "ShowRuler":
					base.ShowRuler = (bool)args.NewValue;
					break;
				case "FontName":
					base.FontName = (string)args.NewValue;
					break;
				case "GutterFontName":
					base.GutterFontName = (string)args.NewValue;
					break;
				case "ColorScheme":
					base.ColorScheme = (string)args.NewValue;
					break;
				case "DefaultRegionsFolding":
					this.DefaultRegionsFolding = (bool)args.NewValue;
					break;
				case "DefaultCommentFolding":
					this.DefaultCommentFolding = (bool)args.NewValue;
					break;
				case "UseViModes":
					this.UseViModes = (bool)args.NewValue;
					break;
				case "OnTheFlyFormatting":
					this.OnTheFlyFormatting = (bool)args.NewValue;
					break;
				case "ControlLeftRightMode":
					this.ControlLeftRightMode = (ControlLeftRightMode)args.NewValue;
					break;
				case "EnableAnimations":
					base.EnableAnimations = (bool)args.NewValue;
					break;
				case "UseAntiAliasing":
					base.UseAntiAliasing = (bool)args.NewValue;
					break;
				case "DrawIndentationMarkers":
					base.DrawIndentationMarkers = (bool)args.NewValue;
					break;
				case "EnableQuickDiff":
					base.EnableQuickDiff = (bool)args.NewValue;
					break;
				}
			} catch (Exception ex) {
				LoggingService.LogError ("SourceEditorOptions error with property value for '" + (args.Key ?? "") + "'", ex);
			}
		}

		void OnPropertyUpdated (object sender, PropertyChangedEventArgs e)
		{
			bool change = false;
			if (e.Key == "Monodevelop.UserTasksHighPrioColor" && e.NewValue != e.OldValue)
			{
				highPrioColor = StringToColor ((string)e.NewValue);
				change = true;
			}
			if (e.Key == "Monodevelop.UserTasksNormalPrioColor" && e.NewValue != e.OldValue)
			{
				normalPrioColor = StringToColor ((string)e.NewValue);
				change = true;
			}
			if (e.Key == "Monodevelop.UserTasksLowPrioColor" && e.NewValue != e.OldValue)
			{
				lowPrioColor = StringToColor ((string)e.NewValue);
				change = true;
			}
			
			if (change)
			{
				TreeIter iter;
				if (store.GetIterFirst (out iter))
				{
					do
					{
						Task task = (Task) store.GetValue (iter, (int)Columns.Task);
						store.SetValue (iter, (int)Columns.Foreground, GetColorByPriority (task.Priority));
					} while (store.IterNext (ref iter));
				}
			}
		}

		void OnPropertyUpdated (object sender, PropertyChangedEventArgs e)
		{
			if (e.Key == "EnableCodeCompletion" && e.NewValue != e.OldValue)
				enableCodeCompletion = (bool)e.NewValue;
			if (e.Key == "EnableParameterInsight" && e.NewValue != e.OldValue)
				enableParameterInsight = (bool)e.NewValue;
		}	

		void HandleCustomFontChanged (object sender, PropertyChangedEventArgs e)
		{
			UpdateCustomFont ((string)e.NewValue);
		}

		void ScrollBarModeChanged (object sender, PropertyChangedEventArgs args)
		{
			var newMode =  (ScrollBarMode)args.NewValue;
			this.ScrollBarMode = newMode;
		}

		void XmlEditorPropertyChanged(object o, PropertyChangedEventArgs e)
 		{
			switch (e.Key) {
				case "AutoCompleteElements":
					view.AutoCompleteElements = XmlEditorAddInOptions.AutoCompleteElements;
					break;
				case "ShowSchemaAnnotation":
					view.ShowSchemaAnnotation = XmlEditorAddInOptions.ShowSchemaAnnotation;
					break;
				default:
					string extension = Path.GetExtension(fileName).ToLower();
					if (e.Key == extension) {
						SetDefaultSchema(extension);
					} else {
						Console.WriteLine("XmlEditor: Unhandled property change: " + e.Key);
					}
					break;
			}
		}

		static void HandlePropertiesChanged (object sender, PropertyChangedEventArgs e)
		{
			LoadProperties ();
			changed (null, EventArgs.Empty);
		}

 void HandlePropertyChanged(object sender, PropertyChangedEventArgs e)
 {
     switch (e.Key)
     {
         case DiffbasedHighlighting.DiffBasedHighlightingProp:
             if (DiffbasedHighlighting.Enabled)
             {
                 TryInjectDiffbasedMarker();
                 SemanticHighlightingEnabled = false;
                 RemoveOldTypeMarkers(true);
             }
             else
             {
                 TryRemoveDiffbasedMarker();
                 if (SemanticHighlightingEnabled = PropertyService.Get("EnableSemanticHighlighting", true))
                     HandleDocumentParsed(sender, e);
             }
             break;
         case "EnableSemanticHighlighting":
             SemanticHighlightingEnabled = PropertyService.Get("EnableSemanticHighlighting", true);
             if (!SemanticHighlightingEnabled)
                 RemoveOldTypeMarkers();
             break;
     }
 }

		void OnPropertyChanged (object sender, PropertyChangedEventArgs e) {
			if (e.Key != "EnableAutoCorrection")
				return;
			if (!(e.NewValue is bool) || !(e.OldValue is bool))
				return;
			
			bool newValue = (bool)e.NewValue;
			bool oldValue = (bool)e.OldValue;
			
			if (newValue && !oldValue) {
				db.ParseInformationChanged += OnParseInformationChanged;
			} else if (!newValue && oldValue) {
				ResetUnderlineChangement ();
				db.ParseInformationChanged -= OnParseInformationChanged;
			}
		}

 public void UpdatePreferences( object sender, PropertyChangedEventArgs args )
 {
     isEnabled = PropertyService.Get("UseViModes", false);
     SetupMode ();
 }

		void SourceEditorPropertyChanged(object o, PropertyChangedEventArgs e)
		{
			switch (e.Key) {
				case "DefaultFont":
					view.ModifyFont(TextEditorProperties.Font);
					break;
				case "ShowLineNumbers":
					view.ShowLineNumbers = TextEditorProperties.ShowLineNumbers;
					break;
				case "ConvertTabsToSpaces":
					view.InsertSpacesInsteadOfTabs = TextEditorProperties.ConvertTabsToSpaces;
					break;
				case "ShowBracketHighlight":
					((SourceBuffer)view.Buffer).HighlightMatchingBrackets = TextEditorProperties.ShowMatchingBracket;
					break;
				case "ShowVRuler":
					view.ShowRightMargin = TextEditorProperties.ShowVerticalRuler;
					break;
				case "VRulerRow":
					if (TextEditorProperties.VerticalRulerRow > -1)
						view.RightMarginPosition = (uint) TextEditorProperties.VerticalRulerRow;
					else
						view.RightMarginPosition = 80;
					break;
				case "TabIndent":
					if (TextEditorProperties.TabIndent > -1)
						view.TabWidth = (uint) TextEditorProperties.TabIndent;
					else
						view.TabWidth = (uint) 4;
					break;
				case "IndentStyle":
					view.AutoIndent = (TextEditorProperties.IndentStyle == IndentStyle.Auto);
					break;
				case "HighlightCurrentLine":
					view.HighlightCurrentLine = TextEditorProperties.HighlightCurrentLine;
					break;
				case "GtkSourceViewStyleScheme":
					UpdateStyleScheme ();
					break;
				default:
					MonoDevelop.Core.LoggingService.LogWarning ("XmlEditor: Unhandled source editor property change: " + e.Key);
					break;
			}
		}