public DesignItem RegisterComponentForDesigner(object component)
{
if (component == null)
{
component = new NullExtension();
}
else if (component is Type)
{
component = new TypeExtension((Type)component);
}
XamlDesignItem item = new XamlDesignItem(_context.Document.CreateObject(component), _context);
_context.Services.ExtensionManager.ApplyDesignItemInitializers(item);
if (!(component is string))
{
_sites.Add(component, item);
}
if (ComponentRegistered != null)
{
ComponentRegistered(this, new DesignItemEventArgs(item));
}
return(item);
}
public SetNameAction(XamlDesignItem designItem, string newName)
{
this.designItem = designItem;
this.newName = newName;
oldName = designItem.Name;
}
void InsertInternal(int index, XamlDesignItem item)
{
property.CollectionElements.Insert(index, item.XamlObject);
if (CollectionChanged != null)
{
CollectionChanged(this,
new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, item, index));
}
AddToNamescopeRecursive(item);
}
public bool Contains(DesignItem item)
{
XamlDesignItem xitem = CheckItemNoException(item);
if (xitem != null)
{
return(property.CollectionElements.Contains(xitem.XamlObject));
}
else
{
return(false);
}
}
void RemoveInternal(int index, XamlDesignItem item)
{
RemoveFromNamescopeRecursive(item);
Debug.Assert(property.CollectionElements[index] == item.XamlObject);
property.CollectionElements.RemoveAt(index);
if (CollectionChanged != null)
{
CollectionChanged(this,
new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, item, index));
}
}
public int IndexOf(DesignItem item)
{
XamlDesignItem xitem = CheckItemNoException(item);
if (xitem != null)
{
return(property.CollectionElements.IndexOf(xitem.XamlObject));
}
else
{
return(-1);
}
}
public override DesignItem Clone()
{
DesignItem item = null;
var xaml = XamlStaticTools.GetXaml(this.XamlObject);
XamlDesignItem rootItem = Context.RootItem as XamlDesignItem;
var obj = XamlParser.ParseSnippet(rootItem.XamlObject, xaml, ((XamlDesignContext)Context).ParserSettings);
if (obj != null)
{
item = ((XamlDesignContext)Context)._componentService.RegisterXamlComponentRecursive(obj);
}
return(item);
}
XamlDesignItem CheckItem(DesignItem item)
{
if (item == null)
{
throw new ArgumentNullException("item");
}
if (item.Context != modelProperty.DesignItem.Context)
{
throw new ArgumentException("The item must belong to the same context as this collection", "item");
}
XamlDesignItem xitem = item as XamlDesignItem;
Debug.Assert(xitem != null);
return(xitem);
}
public override void SetValue(object value)
{
XamlPropertyValue newValue;
if (value == null)
{
newValue = _property.ParentObject.OwnerDocument.CreateNullValue();
}
else
{
XamlComponentService componentService = _designItem.ComponentService;
XamlDesignItem designItem = value as XamlDesignItem;
if (designItem == null)
{
designItem = (XamlDesignItem)componentService.GetDesignItem(value);
}
if (designItem != null)
{
if (designItem.Parent != null)
{
throw new DesignerException("Cannot set value to design item that already has a parent");
}
newValue = designItem.XamlObject;
}
else
{
XamlPropertyValue val = _property.ParentObject.OwnerDocument.CreatePropertyValue(value, _property);
designItem = componentService.RegisterXamlComponentRecursive(val as XamlObject);
newValue = val;
}
}
UndoService undoService = _designItem.Services.GetService <UndoService>();
if (undoService != null)
{
undoService.Execute(new PropertyChangeAction(this, newValue, true));
}
else
{
SetValueInternal(newValue);
}
}
private static void AddToNamescopeRecursive(XamlDesignItem designItem)
{
NameScopeHelper.NameChanged(designItem.XamlObject, null, designItem.Name);
foreach (var p in designItem.Properties)
{
if (p.Value != null)
{
AddToNamescopeRecursive((XamlDesignItem)p.Value);
}
else if (p.IsCollection && p.CollectionElements != null)
{
foreach (var c in p.CollectionElements)
{
AddToNamescopeRecursive((XamlDesignItem)c);
}
}
}
}
/// <summary>
/// Copy <paramref name="designItems"/> from the designer to clipboard.
/// </summary>
public void Copy(ICollection <DesignItem> designItems)
{
Clipboard.Clear();
string copiedXaml = "";
var changeGroup = _context.OpenGroup("Copy " + designItems.Count + " elements", designItems);
foreach (var item in designItems)
{
if (item != null)
{
XamlDesignItem xamlItem = item as XamlDesignItem;
if (xamlItem != null)
{
copiedXaml += XamlStaticTools.GetXaml(xamlItem.XamlObject);
copiedXaml += _delimeter;
}
}
}
Clipboard.SetText(copiedXaml, TextDataFormat.Xaml);
changeGroup.Commit();
}
/// <summary>
/// Copy <paramref name="designItems"/> from the designer to clipboard.
/// </summary>
public void Cut(ICollection <DesignItem> designItems)
{
Clipboard.Clear();
string cutXaml = "";
var changeGroup = _context.OpenGroup("Cut " + designItems.Count + " elements", designItems);
foreach (var item in designItems)
{
if (item != null && item != _context.RootItem)
{
XamlDesignItem xamlItem = item as XamlDesignItem;
if (xamlItem != null)
{
cutXaml += XamlStaticTools.GetXaml(xamlItem.XamlObject);
cutXaml += _delimeter;
}
}
}
ModelTools.DeleteComponents(designItems);
Clipboard.SetText(cutXaml, TextDataFormat.Xaml);
changeGroup.Commit();
}
public XamlModelProperty(XamlDesignItem designItem, XamlProperty property)
{
Debug.Assert(designItem != null);
Debug.Assert(property != null);
this._designItem = designItem;
this._property = property;
if (property.IsCollection)
{
_collectionElements = new XamlModelCollectionElementsCollection(this, property);
}
ValueChanged += (x, y) =>
{
OnPropertyChanged("Value");
OnPropertyChanged("ValueOnInstanceOrView");
};
ValueOnInstanceChanged += (x, y) =>
{
OnPropertyChanged("ValueOnInstance");
OnPropertyChanged("ValueOnInstanceOrView");
};
}
/// <summary>
/// Creates a new XamlDesignContext instance.
/// </summary>
public XamlDesignContext(XmlReader xamlReader, XamlLoadSettings loadSettings)
{
if (xamlReader == null)
{
throw new ArgumentNullException("xamlReader");
}
if (loadSettings == null)
{
throw new ArgumentNullException("loadSettings");
}
this.Services.AddService(typeof(ISelectionService), new DefaultSelectionService());
this.Services.AddService(typeof(IComponentPropertyService), new ComponentPropertyService());
this.Services.AddService(typeof(IToolService), new DefaultToolService(this));
this.Services.AddService(typeof(UndoService), new UndoService());
this.Services.AddService(typeof(IErrorService), new DefaultErrorService(this));
this.Services.AddService(typeof(IOutlineNodeNameService), new OutlineNodeNameService());
this.Services.AddService(typeof(ViewService), new DefaultViewService(this));
this.Services.AddService(typeof(OptionService), new OptionService());
var xamlErrorService = new XamlErrorService();
this.Services.AddService(typeof(XamlErrorService), xamlErrorService);
this.Services.AddService(typeof(IXamlErrorSink), xamlErrorService);
_componentService = new XamlComponentService(this);
this.Services.AddService(typeof(IComponentService), _componentService);
foreach (Action <XamlDesignContext> action in loadSettings.CustomServiceRegisterFunctions)
{
action(this);
}
// register default versions of overridable services:
if (this.Services.GetService(typeof(ITopLevelWindowService)) == null)
{
this.Services.AddService(typeof(ITopLevelWindowService), new WpfTopLevelWindowService());
}
EditorManager.SetDefaultTextBoxEditorType(typeof(TextBoxEditor));
EditorManager.SetDefaultComboBoxEditorType(typeof(ComboBoxEditor));
// register extensions from the designer assemblies:
foreach (Assembly designerAssembly in loadSettings.DesignerAssemblies)
{
this.Services.ExtensionManager.RegisterAssembly(designerAssembly);
EditorManager.RegisterAssembly(designerAssembly);
}
_parserSettings = new XamlParserSettings();
_parserSettings.TypeFinder = loadSettings.TypeFinder;
_parserSettings.CurrentProjectAssemblyName = loadSettings.CurrentProjectAssemblyName;
_parserSettings.CreateInstanceCallback = this.Services.ExtensionManager
.CreateInstanceWithCustomInstanceFactory;
_parserSettings.ServiceProvider = this.Services;
_doc = XamlParser.Parse(xamlReader, _parserSettings);
loadSettings.ReportErrors(xamlErrorService);
if (_doc == null)
{
string message;
if (xamlErrorService != null && xamlErrorService.Errors.Count > 0)
{
message = xamlErrorService.Errors[0].Message;
}
else
{
message = "Could not load document.";
}
throw new XamlLoadException(message);
}
_rootItem = _componentService.RegisterXamlComponentRecursive(_doc.RootElement);
if (_rootItem != null)
{
var rootBehavior = new RootItemBehavior();
rootBehavior.Intialize(this);
}
_xamlEditOperations = new XamlEditOperations(this, _parserSettings);
}
/// <summary>
/// registers components from an existing XAML tree
/// </summary>
internal XamlDesignItem RegisterXamlComponentRecursive(XamlObject obj)
{
if (obj == null)
{
return(null);
}
foreach (XamlProperty prop in obj.Properties)
{
RegisterXamlComponentRecursive(prop.PropertyValue as XamlObject);
foreach (XamlPropertyValue val in prop.CollectionElements)
{
RegisterXamlComponentRecursive(val as XamlObject);
}
}
XamlDesignItem site = new XamlDesignItem(obj, _context);
_context.Services.ExtensionManager.ApplyDesignItemInitializers(site);
_sites.Add(site.Component, site);
if (ComponentRegistered != null)
{
ComponentRegistered(this, new DesignItemEventArgs(site));
}
if (_context.RootItem != null && !string.IsNullOrEmpty(site.Name))
{
var nameScope = NameScopeHelper.GetNameScopeFromObject(((XamlDesignItem)_context.RootItem).XamlObject);
if (nameScope != null)
{
// The object will be a part of the RootItem namescope, remove local namescope if set
NameScopeHelper.ClearNameScopeProperty(obj.Instance);
string newName = site.Name;
if (nameScope.FindName(newName) != null)
{
int copyIndex = newName.LastIndexOf("_Copy", StringComparison.Ordinal);
if (copyIndex < 0)
{
newName += "_Copy";
}
else if (!newName.EndsWith("_Copy", StringComparison.Ordinal))
{
string copyEnd = newName.Substring(copyIndex + "_Copy".Length);
int copyEndValue;
if (Int32.TryParse(copyEnd, out copyEndValue))
{
newName = newName.Remove(copyIndex + "_Copy".Length);
}
else
{
newName += "_Copy";
}
}
int i = 1;
string newNameTemplate = newName;
while (nameScope.FindName(newName) != null)
{
newName = newNameTemplate + i++;
}
site.Name = newName;
}
nameScope.RegisterName(newName, obj.Instance);
}
}
return(site);
}
public XamlModelPropertyCollection(XamlDesignItem item)
{
this._item = item;
}
/// <summary>
/// Paste items from clipboard into the designer.
/// </summary>
public void Paste()
{
bool pasted = false;
string combinedXaml = Clipboard.GetText(TextDataFormat.Xaml);
IEnumerable <string> xamls = combinedXaml.Split(_delimeter);
xamls = xamls.Where(xaml => xaml != "");
DesignItem parent = _context.Services.Selection.PrimarySelection;
DesignItem child = _context.Services.Selection.PrimarySelection;
XamlDesignItem rootItem = _context.RootItem as XamlDesignItem;
var pastedItems = new Collection <DesignItem>();
foreach (var xaml in xamls)
{
var obj = XamlParser.ParseSnippet(rootItem.XamlObject, xaml, _settings);
if (obj != null)
{
DesignItem item = _context._componentService.RegisterXamlComponentRecursive(obj);
if (item != null)
{
pastedItems.Add(item);
}
}
}
if (pastedItems.Count != 0)
{
var changeGroup = _context.OpenGroup("Paste " + pastedItems.Count + " elements", pastedItems);
while (parent != null && pasted == false)
{
if (parent.ContentProperty != null)
{
if (parent.ContentProperty.IsCollection)
{
if (CollectionSupport.CanCollectionAdd(parent.ContentProperty.ReturnType,
pastedItems.Select(item => item.Component)) &&
parent.GetBehavior <IPlacementBehavior>() != null)
{
AddInParent(parent, pastedItems);
pasted = true;
}
}
else if (pastedItems.Count == 1 && parent.ContentProperty.Value == null &&
parent.ContentProperty.ValueOnInstance == null && parent.View is ContentControl)
{
AddInParent(parent, pastedItems);
pasted = true;
}
if (!pasted)
{
parent = parent.Parent;
}
}
else
{
parent = parent.Parent;
}
}
while (pasted == false)
{
if (child.ContentProperty != null)
{
if (child.ContentProperty.IsCollection)
{
foreach (var col in child.ContentProperty.CollectionElements)
{
if (col.ContentProperty != null && col.ContentProperty.IsCollection)
{
if (CollectionSupport.CanCollectionAdd(col.ContentProperty.ReturnType,
pastedItems.Select(item => item.Component)))
{
pasted = true;
}
}
}
break;
}
else if (child.ContentProperty.Value != null)
{
child = child.ContentProperty.Value;
}
else if (pastedItems.Count == 1)
{
child.ContentProperty.SetValue(pastedItems.First().Component);
pasted = true;
break;
}
else
{
break;
}
}
else
{
break;
}
}
foreach (var pastedItem in pastedItems)
{
_context._componentService.RaiseComponentRegisteredAndAddedToContainer(pastedItem);
}
changeGroup.Commit();
}
}
public RemoveAtAction(XamlModelCollectionElementsCollection collection, int index, XamlDesignItem item)
{
this.collection = collection;
this.index = index;
this.item = item;
}