public DocUIList(XmlNode xmlNode, XmlSchemaAnnotated xsdNode, Panel contentpanel, Panel overlaypanel, DynamicForm parentForm, bool horizontal = true) : base(xmlNode, xsdNode, contentpanel, overlaypanel, parentForm) { _optlist = new List<ListItemComponent>(); _parent = xmlNode; _listpanel = new StackPanel(); _listpanel.Orientation = horizontal ? Orientation.Horizontal : Orientation.Vertical; XmlSchemaElement schemaEl = xsdNode as XmlSchemaElement; if (schemaEl != null) { XmlSchemaSequence seq = XmlSchemaUtilities.tryGetSequence(schemaEl.ElementSchemaType); if (seq != null && seq.Items.Count == 1 && seq.Items[0] is XmlSchemaElement) { _el = seq.Items[0] as XmlSchemaElement; //get all elements from current node foreach (XmlNode node in xmlNode.ChildNodes) { ListItemComponent lio = new ListItemComponent(node, _el, _listpanel, overlaypanel, _optlist, parentForm); _optlist.Add(lio); } } Button add = new Button(); add.Content = "Add item"; add.Click += AddItem; _listpanel.Children.Add(add); contentpanel.Children.Add(_listpanel); } }
public DocUITabbed(XmlNode xmlNode, XmlSchemaAnnotated xsdNode, Panel contentpanel, Panel overlaypanel, DynamicForm parentForm) : base(xmlNode, xsdNode, contentpanel, overlaypanel, parentForm) { this.Sideways = true; _tabControl = new TabControl(); this.Control = _tabControl; _optlist = new List<AbstractDocUIComponent>(); XmlSchemaElement schemaEl = xsdNode as XmlSchemaElement; if (schemaEl != null) { XmlSchemaSequence seq = XmlSchemaUtilities.tryGetSequence(schemaEl.ElementSchemaType); if (seq != null) { foreach (XmlSchemaElement el in seq.Items) { TabItem ti = new TabItem(); ti.Header = XmlSchemaUtilities.tryGetDocumentation(el); ; Grid newpanel = new Grid(); ColumnDefinition cdnew1 = new ColumnDefinition(); cdnew1.Width = new GridLength(1, GridUnitType.Auto); ColumnDefinition cdnew2 = new ColumnDefinition(); newpanel.ColumnDefinitions.Add(cdnew1); newpanel.ColumnDefinitions.Add(cdnew2); Utilities.recursive(el, xmlNode.SelectSingleNode(el.Name), newpanel, overlaypanel, (comp) => { _optlist.Add(comp); comp.placeOption(); }, parentForm); ti.Content = newpanel; this._tabControl.Items.Add(ti); } } } }
/// <summary> /// Creates a new instance of the comboOption /// </summary> /// <param name="xmlNode">The xmlNode containing the data (selected value) of the comboOption</param> /// <param name="xsdNode">The corresponding xsdNode</param> /// <param name="panel">The panel on which the option should be placed</param> /// <param name="parentForm">The form of which this option is a part.</param> public DocUICombo(XmlNode xmlNode, XmlSchemaAnnotated xsdNode, Panel contentpanel, Panel overlaypanel, DynamicForm parentForm) : base(xmlNode, xsdNode, contentpanel, overlaypanel, parentForm) { XmlSchemaElement schemaEl = xsdNode as XmlSchemaElement; if (schemaEl != null) { cb = new ComboBox() { Margin = new Thickness(5) }; cb.SelectionChanged += (s, e) => { hasPendingChanges(); }; cb.VerticalContentAlignment = System.Windows.VerticalAlignment.Center; // get enumeration IEnumerable<XmlSchemaEnumerationFacet> enumFacets = XmlSchemaUtilities.tryGetEnumRestrictions(schemaEl.ElementSchemaType); if (enumFacets != null) { foreach (var facet in enumFacets) { // fill the combobox cb.Items.Add(facet.Value); } cb.SelectedIndex = 0; } else { Log.Info("This combobox has no enumeration restriction. The Combobox will be empty."); } Control = cb; cb.Padding = new Thickness(10, 2, 10, 2); setup(); } }
/// <summary> /// Creates a new instance of MultiSelectOption /// </summary> /// <param name="xmlNode">The xmlNode that contains the data.</param> /// <param name="xsdNode">The corresponding xsdNode.</param> /// <param name="panel">The panel on which the option should be placed.</param> /// <param name="parentForm">The form of which this option is a part.</param> public DocUIMultiSelect(XmlNode xmlNode, XmlSchemaAnnotated xsdNode, Panel contentpanel, Panel overlaypanel, DynamicForm parentForm) : base(xmlNode, xsdNode, contentpanel, overlaypanel, parentForm) { XmlSchemaElement schemaEl = xsdNode as XmlSchemaElement; if (schemaEl != null) { XmlSchemaSequence seq = XmlSchemaUtilities.tryGetSequence(schemaEl.ElementSchemaType); if (seq != null && seq.Items.Count > 0) { XmlSchemaElement el = seq.Items[0] as XmlSchemaElement; IEnumerable<XmlSchemaEnumerationFacet> restrictions = XmlSchemaUtilities.tryGetEnumRestrictions(el.ElementSchemaType); foreach (XmlSchemaEnumerationFacet e in restrictions) { AddOption(e.Value, FontWeights.Normal); } } CheckBox all = AddOption("All", FontWeights.Bold); all.Checked += (s, e) => { SelectAll(); }; all.Unchecked += (s, e) => { UnselectAll(); }; _wrapPanel.Orientation = Orientation.Horizontal; Control = _wrapPanel; setup(); } }
/// <summary> /// Creates a new instance of the TimeOption /// </summary> /// <param name="xmlNode">The xmlnode containing the data.</param> /// <param name="xsdNode">The corresponding xsdnode.</param> /// <param name="panel">The panel on which this option should be placed.</param> /// <param name="parentForm">The form of which this option is a part.</param> public DocUITime(XmlNode xmlNode, XmlSchemaAnnotated xsdNode, Panel contentpanel, Panel overlaypanel, DynamicForm parentForm) : base(xmlNode, xsdNode, contentpanel, overlaypanel, parentForm) { Control = new TimePicker() { Format = TimeFormat.Custom, FormatString = "HH:mm:ss" }; (Control as TimePicker).ValueChanged += (s, e) => { hasPendingChanges(); }; setup(); }
public DocUIBoolean(XmlNode xmlNode, XmlSchemaAnnotated xsdNode, Panel contentpanel, Panel overlaypanel, DynamicForm parentForm) : base(xmlNode, xsdNode, contentpanel, overlaypanel, parentForm) { Control = new CheckBox(); (Control as CheckBox).Click += (s, e) => { hasPendingChanges(); }; setup(); }
/// <summary> /// Creates a new instance of the SubSectionOption /// </summary> /// <param name="xmlNode">The xmlnode containing the data.</param> /// <param name="xsdNode">The corresponding xsdNode.</param> /// <param name="panel">The panel on which this option should be placed.</param> /// <param name="parentForm">The form of which this option is a part.</param> public DocUISubSection(XmlNode xmlNode, XmlSchemaAnnotated xsdNode, Panel contentpanel, Panel overlaypanel, DynamicForm parentForm) : base(xmlNode, xsdNode, contentpanel, overlaypanel, parentForm) { XmlSchemaElement schemaEl = xsdNode as XmlSchemaElement; if (schemaEl != null) { optionlist = new List<AbstractDocUIComponent>(); box = new GroupBox(); DockPanel panel = new DockPanel(); Grid g = new Grid() { Margin = new Thickness(5, 0, 0, 0) }; g.ColumnDefinitions.Add(new ColumnDefinition() { Width = new GridLength(1, GridUnitType.Auto) }); g.ColumnDefinitions.Add(new ColumnDefinition() { Width = new GridLength(1, GridUnitType.Star) }); XmlSchemaSequence seq = XmlSchemaUtilities.tryGetSequence(schemaEl.ElementSchemaType); if (seq != null) { foreach (XmlSchemaElement el in seq.Items) Utilities.recursive(el, xmlNode.SelectSingleNode(el.Name), g, overlaypanel, (comp) => { comp.placeOption(); optionlist.Add(comp); }, parentForm); } if (xmlNode.Attributes["checked"] != null) { check = new CheckBox() { Margin = new Thickness(5, 5, 0, 5) }; check.Checked += check_changed; check.Checked += (s, e) => { hasPendingChanges(); }; check.Unchecked += check_changed; check.Unchecked += (s, e) => { hasPendingChanges(); }; panel.Children.Add(check); } // if there is no label, there should be no groupbox. if (Label.Text != "") { panel.Children.Add(Label); box.Header = panel; box.Content = g; Control = box; } else { panel.Children.Add(g); //Control = g; Control = panel; } setup(); } }
public DocUIGUID(XmlNode xmlNode, XmlSchemaAnnotated xsdNode, Panel contentpanel, Panel overlaypanel, DynamicForm parentForm) : base(xmlNode, xsdNode, contentpanel, overlaypanel, parentForm) { Label l = new Label(); this.Control = l; //check if node contains default value if (xmlNode.InnerText == "") { xmlNode.InnerText = Guid.NewGuid().ToString(); //save the key //parentForm.saveFile(this, null); } l.Content = xmlNode.InnerText; }
/// <summary> /// Creates a new incstance of the StringOption. /// </summary> /// <param name="xmlNode">The xmlnode containing the data.</param> /// <param name="xsdNode">The corresponding xsdNode.</param> /// <param name="panel">The panel on which this option should be placed.</param> /// <param name="parentForm">The form of which this option is a part.</param> /// <param name="metaname">Whether this option can be filled with metadata. And if so, whether it will get the name or the value of the metadata.</param> public DocUIString(XmlNode xmlNode, XmlSchemaAnnotated xsdNode, Panel contentpanel, Panel overlaypanel, DynamicForm parentForm) : base(xmlNode, xsdNode, contentpanel, overlaypanel, parentForm) { string regex = XmlSchemaUtilities.tryGetPatternRestriction(xsdNode); if (regex == null) { regex = ""; } string watermark = XmlSchemaUtilities.tryGetUnhandledAttribute(xsdNode, "watermark"); string req = XmlSchemaUtilities.tryGetUnhandledAttribute(xsdNode, "required"); bool required = req == "true" ? true : false; Control = new ExtendedTextBox("", watermark, regex, required, parentForm); (Control as ExtendedTextBox).TextBlock.TextChanged += (s, e) => { hasPendingChanges(); }; Setup(); }
/// <summary> /// Creates a new instance of the TimeOption /// </summary> /// <param name="xmlNode">The xmlnode containing the data.</param> /// <param name="xsdNode">The corresponding xsdnode.</param> /// <param name="contentpanel">The panel on which this option should be placed.</param> /// <param name="parentForm">The form of which this option is a part.</param> public DocUIDateTime(XmlNode xmlNode, XmlSchemaAnnotated xsdNode, Panel contentpanel, Panel overlaypanel, DynamicForm parentForm) : base(xmlNode, xsdNode, contentpanel, overlaypanel, parentForm) { //Control = new DatePicker(); //{ Form Format = TimeFormat.Custom, FormatString = "HH:mm:ss" }; //(Control as DatePicker).ValueChanged += (s, e) => { hasPendingChanges(); }; stack = new StackPanel() { Orientation = Orientation.Horizontal }; Control = stack; DateControl = new DatePicker(); DateControl.SelectedDateChanged += (s, e) => { hasPendingChanges(); }; TimeControl = new TimePicker() { Format = TimeFormat.Custom, FormatString = "HH:mm:ss" }; TimeControl.ValueChanged += (s, e) => { hasPendingChanges(); }; setup(); }
protected virtual void Visit(XmlSchemaAnnotated annotated) { XmlSchemaAnyAttribute anyAttribute; XmlSchemaAttribute attribute; XmlSchemaAttributeGroup attributeGroup; XmlSchemaAttributeGroupRef attributeGroupRef; XmlSchemaContent content; XmlSchemaContentModel contentModel; XmlSchemaFacet facet; XmlSchemaGroup group; XmlSchemaIdentityConstraint constraint; XmlSchemaNotation notation; XmlSchemaParticle particle; XmlSchemaSimpleTypeContent schemaSimpleTypeContent; XmlSchemaType type; XmlSchemaXPath xPath; if (Casting.TryCast(annotated, out anyAttribute)) Visit(anyAttribute); else if (Casting.TryCast(annotated, out attribute)) Visit(attribute); else if (Casting.TryCast(annotated, out attributeGroup)) Visit(attributeGroup); else if (Casting.TryCast(annotated, out attributeGroupRef)) Visit(attributeGroupRef); else if (Casting.TryCast(annotated, out content)) Visit(content); else if (Casting.TryCast(annotated, out contentModel)) Visit(contentModel); else if (Casting.TryCast(annotated, out facet)) Visit(facet); else if (Casting.TryCast(annotated, out group)) Visit(group); else if (Casting.TryCast(annotated, out constraint)) Visit(constraint); else if (Casting.TryCast(annotated, out notation)) Visit(notation); else if (Casting.TryCast(annotated, out particle)) Visit(particle); else if (Casting.TryCast(annotated, out schemaSimpleTypeContent)) Visit(schemaSimpleTypeContent); else if (Casting.TryCast(annotated, out type)) Visit(type); else if (Casting.TryCast(annotated, out xPath)) Visit(xPath); else throw ExceptionBuilder.UnexpectedSchemaObjectType(annotated); }
/// <summary> /// Creates a new instance of the passwordOption /// </summary> /// <param name="xmlNode">The xmlNode that contains the data.</param> /// <param name="xsdNode">The corresponding xsdNode.</param> /// <param name="panel">The panel on which this option should be placed.</param> /// <param name="parentForm">The form of which this option is a part.</param> public DocUIPassword(XmlNode xmlNode, XmlSchemaAnnotated xsdNode, Panel contentpanel, Panel overlaypanel, DynamicForm parentForm) : base(xmlNode, xsdNode, contentpanel, overlaypanel, parentForm) { PasswordBox pw = new PasswordBox() { PasswordChar = '*' }; string req = XmlSchemaUtilities.tryGetUnhandledAttribute(xsdNode, "required"); required = req == "true" ? true : false; pw.PasswordChanged += (s, e) => { pw.Background = required && pw.Password == "" ? ExtendedTextBox.IncorrectColor : ExtendedTextBox.CorrectColor; hasPendingChanges(); }; Control = pw; setup(); }
/// <summary> /// Creates a new instance of the BigTextOption /// </summary> /// <param name="xmlNode">The node containing the data for the textbox</param> /// <param name="xsdNode">The corresponding xsdNode</param> /// <param name="panel">the panel on which this option should be placed</param> /// <param name="parentForm">the form of which this option is a part</param> public DocUIBigTextBox(XmlNode xmlNode, XmlSchemaAnnotated xsdNode, Panel contentpanel, Panel overlaypanel, DynamicForm parentForm) : base(xmlNode, xsdNode, contentpanel, overlaypanel, parentForm) { ScrollViewer scroll = new ScrollViewer(); string req = XmlSchemaUtilities.tryGetUnhandledAttribute(xsdNode, "required"); bool required = req == "true" ? true : false; box = new ExtendedTextBox("", "", "", required, parentForm); box.TextBlock.AcceptsReturn = true; box.TextBlock.TextWrapping = TextWrapping.Wrap; box.Height = 200; scroll.Content = box; Control = scroll; setup(); }
/// <summary> /// Creates a new instance of the IntegerOption /// </summary> /// <param name="xmlNode">The node that contains the data for the integerOption</param> /// <param name="xsdNode">The corresponding xsdNode.</param> /// <param name="panel">The panel in which this option should be placed.</param> /// <param name="parentForm">The form of which this option is a part.</param> public DocUIInteger(XmlNode xmlNode, XmlSchemaAnnotated xsdNode, Panel contentpanel, Panel overlaypanel, DynamicForm parentForm) : base(xmlNode, xsdNode, contentpanel, overlaypanel, parentForm) { int maxIncl = XmlSchemaUtilities.tryGetMaxIncl(xsdNode); int minIncl = XmlSchemaUtilities.tryGetMinIncl(xsdNode); _defaultValue = minIncl; Control = new DoubleUpDown() { ShowButtonSpinner = true, AllowSpin = true, MouseWheelActiveTrigger = MouseWheelActiveTrigger.MouseOver, Increment = 1, ClipValueToMinMax = true, Minimum = minIncl, Maximum = maxIncl }; (Control as DoubleUpDown).ValueChanged += (s, e) => { hasPendingChanges(); }; setup(); }
/// <summary> /// Creates a new instance of the RadioSelector /// </summary> /// <param name="xmlNode">The xmlNode containing the data.</param> /// <param name="xsdNode">The corresponding xsdNode.</param> /// <param name="panel">The panel on which this option should be placed.</param> /// <param name="parentForm">The form of which this option is a part.</param> public DocUIRadioSelect(XmlNode xmlNode, XmlSchemaAnnotated xsdNode, Panel contentpanel, Panel overlaypanel, DynamicForm parentForm) : base(xmlNode, xsdNode, contentpanel, overlaypanel, parentForm) { XmlSchemaElement schemaEl = xsdNode as XmlSchemaElement; if (schemaEl != null) { g.ColumnDefinitions.Add(new ColumnDefinition() { Width = new GridLength(1, GridUnitType.Auto) }); g.ColumnDefinitions.Add(new ColumnDefinition() { Width = new GridLength(1, GridUnitType.Auto) }); g.ColumnDefinitions.Add(new ColumnDefinition() { Width = new GridLength(1, GridUnitType.Star) }); g.HorizontalAlignment = HorizontalAlignment.Stretch; Control = g; XmlSchemaSequence seq = XmlSchemaUtilities.tryGetSequence(schemaEl.ElementSchemaType); if (seq != null) foreach (XmlSchemaElement el in seq.Items) Utilities.recursive(el, xmlNode.SelectSingleNode(el.Name), contentpanel, overlaypanel, addOption, parentForm); else Log.Info("this comboselector does not contain any options."); setup(); } }
private void CopyPosition(XmlSchemaAnnotated to, XmlSchemaAnnotated from, bool copyParent) { to.SourceUri = from.SourceUri; to.LinePosition = from.LinePosition; to.LineNumber = from.LineNumber; to.SetUnhandledAttributes(from.UnhandledAttributes); if (copyParent) { to.Parent = from.Parent; } }
private bool CheckUnhandledAttributes(XmlSchemaAnnotated annotated) { if (annotated.UnhandledAttributes != null) { foreach (XmlAttribute att in annotated.UnhandledAttributes) { if (att.LocalName == "root" && att.NamespaceURI == Constants.TypedXLinqNs) { return true; } } } return false; }
// common process for element and attribute private void ImportColumnMetaInfo (XmlSchemaAnnotated obj, XmlQualifiedName name, DataColumn col) { int ordinal = -1; if (obj.UnhandledAttributes != null) { foreach (XmlAttribute attr in obj.UnhandledAttributes) { if (attr.NamespaceURI != XmlConstants.MsdataNamespace) continue; switch (attr.LocalName) { case XmlConstants.Caption: col.Caption = attr.Value; break; case XmlConstants.DataType: col.DataType = Type.GetType (attr.Value); break; case XmlConstants.AutoIncrement: col.AutoIncrement = bool.Parse (attr.Value); break; case XmlConstants.AutoIncrementSeed: col.AutoIncrementSeed = int.Parse (attr.Value); break; case XmlConstants.AutoIncrementStep: col.AutoIncrementStep = int.Parse (attr.Value); break; case XmlConstants.ReadOnly: col.ReadOnly = XmlConvert.ToBoolean (attr.Value); break; case XmlConstants.Ordinal: ordinal = int.Parse (attr.Value); break; } } } }
public static XmlSchemaDocumentation GetDocumentation(XmlSchemaAnnotated a, string language) { XmlSchemaAnnotation ann = a.Annotation; if (ann == null) return null; foreach (XmlSchemaObject o in ann.Items) { // search for xs:documentation nodes XmlSchemaDocumentation doc = o as XmlSchemaDocumentation; if (doc != null) { if (string.IsNullOrEmpty(language) || doc.Language == language) { return doc; } } } return null; }
public static string GetAnnotation(XmlSchemaAnnotated a, AnnotationNode node, string language) { XmlSchemaAnnotation ann = a.Annotation; if (ann == null) return null; string filter = node.ToString().ToLowerInvariant(); if (filter == "default") filter = ""; string result = GetMarkup(ann, filter, language); if (!string.IsNullOrEmpty(result)) return result; return GetMarkup(ann, null, language); }
/// <summary> /// Creates a new instance of the ListSelectOption. /// </summary> /// <param name="xmlNode">The xmlNode that contains the data for the list</param> /// <param name="xsdNode">The corresponding xsdNode</param> /// <param name="p">The panel on which the option should be placed</param> /// <param name="ordered">Whether the list should be ordered or not.</param> public DocUIFileList(XmlNode xmlNode, XmlSchemaAnnotated xsdNode, Panel contentpanel, Panel overlaypanel, DynamicProjectForm parentForm) : base(xmlNode, xsdNode, contentpanel, overlaypanel, parentForm) { //init variables this.parentForm = parentForm; this.projectpath = parentForm.ProjectSystem.WorkingDirectory.FullName; ext = XmlSchemaUtilities.tryGetUnhandledAttribute(xsdNode, "ext"); folder = XmlSchemaUtilities.tryGetUnhandledAttribute(xsdNode, "folder"); string tmprel = XmlSchemaUtilities.tryGetUnhandledAttribute(xsdNode, "relative"); relative = tmprel == "true" ? true : false; DockPanel dock = new DockPanel(); // init the grid Grid g = new Grid(); g.ColumnDefinitions.Add(new ColumnDefinition()); g.ColumnDefinitions.Add(new ColumnDefinition()); g.RowDefinitions.Add(new RowDefinition()); g.RowDefinitions.Add(new RowDefinition()); // init the Components menu = new ContextMenu(); MenuItem OpenMenu = new MenuItem(); OpenMenu.Icon = ModernImageLibrary.GetImage((int)ModernImageLibrary.FileIcons.Open, 16); OpenMenu.Click += OpenMenu_Click; OpenMenu.Header = "Add"; menu.Items.Add(OpenMenu); if (folder != "") { MenuItem EditMenu = new MenuItem(); EditMenu.Click += EditMenu_Click; EditMenu.Icon = ModernImageLibrary.GetImage((int)ModernImageLibrary.FileIcons.Edit, 16); EditMenu.Header = "Edit"; menu.Items.Add(EditMenu); } MenuItem RemoveMenu = new MenuItem(); RemoveMenu.Click += RemoveMenu_Click; RemoveMenu.Icon = ModernImageLibrary.GetImage((int)ModernImageLibrary.FileIcons.Close, 16); RemoveMenu.Header = "Remove"; menu.Items.Add(RemoveMenu); Image DropMenuImage = ModernImageLibrary.GetImage((int)ModernImageLibrary.FileIcons.Shortcut, 16); DropMenuImage.ContextMenu = menu; DropMenuImage.MouseEnter += DropMenuImage_MouseEnter; StackPanel stack = new StackPanel(); stack.Children.Add(DropMenuImage); DockPanel.SetDock(stack, Dock.Right); dock.Children.Add(stack); View = new ListView() { ItemsSource = ViewCollection }; View.Height = 50; ((INotifyCollectionChanged)ViewCollection).CollectionChanged += (s, e) => { hasPendingChanges(); }; dock.Children.Add(View); //init drag en drop extras this.View.DragEnter += DropList_Drag; this.View.Drop += DropList_Drop; this.View.DragOver += DropList_Drag; this.View.AllowDrop = true; // set the Control this.Control = dock; // make the list ordered if (ordered) new ListViewDragDropManager<string>(View); setup(); }
private List<XmlNode> GetAnnotation(XmlSchemaAnnotated annotated) { List<XmlNode> nodes = new List<XmlNode>(); XmlSchemaAnnotation annotation = annotated.Annotation; if (annotation != null) { // find the first <xs:appinfo> element foreach (XmlSchemaObject schemaObj in annotation.Items) { XmlSchemaAppInfo appInfo = schemaObj as XmlSchemaAppInfo; if (appInfo != null) { // copy annotation, removing comments foreach (XmlNode node in appInfo.Markup) if (node.NodeType != XmlNodeType.Comment) nodes.Add(node); } } } return nodes; }
internal static String GetMsdataAttribute(XmlSchemaAnnotated node, String ln) { XmlAttribute[] nodeAttributes = node.UnhandledAttributes; if (nodeAttributes!=null) for(int i=0; i<nodeAttributes.Length;i++) if (nodeAttributes[i].LocalName == ln && nodeAttributes[i].NamespaceURI == Keywords.MSDNS) return nodeAttributes[i].Value; return null; }
internal XmlSchemaAnnotated FindTypeNode(XmlSchemaAnnotated node) { // this function is returning null // if the typeNode for node is in the XSD namespace. XmlSchemaAttribute attr = node as XmlSchemaAttribute; XmlSchemaElement el = node as XmlSchemaElement; bool isAttr = false; if (attr != null) { isAttr = true; } String _type = isAttr ? attr.SchemaTypeName.Name : el.SchemaTypeName.Name; String _typeNs = isAttr ? attr.SchemaTypeName.Namespace : el.SchemaTypeName.Namespace; if (_typeNs == Keywords.XSDNS) return null; XmlSchemaAnnotated typeNode; if (_type == null || _type.Length == 0) { _type = isAttr ? attr.RefName.Name : el.RefName.Name; if (_type == null || _type.Length == 0) typeNode = (XmlSchemaAnnotated) (isAttr ? attr.SchemaType : el.SchemaType); else typeNode = isAttr ? FindTypeNode((XmlSchemaAnnotated)attributes[attr.RefName]) :FindTypeNode((XmlSchemaAnnotated)elementsTable[el.RefName]); } else typeNode = (XmlSchemaAnnotated)schemaTypes[isAttr ? ((XmlSchemaAttribute)node).SchemaTypeName : ((XmlSchemaElement)node).SchemaTypeName]; return typeNode; }
internal string GetInstanceName(XmlSchemaAnnotated node) { string instanceName = null; Debug.Assert( (node is XmlSchemaElement) || (node is XmlSchemaAttribute), "GetInstanceName should only be called on attribute or elements"); if (node is XmlSchemaElement) { XmlSchemaElement el = (XmlSchemaElement) node; instanceName = el.Name != null ? el.Name : el.RefName.Name; } else if (node is XmlSchemaAttribute) { XmlSchemaAttribute el = (XmlSchemaAttribute) node; instanceName = el.Name != null ? el.Name : el.RefName.Name; } Debug.Assert((instanceName != null) && (instanceName.Length != 0), "instanceName cannot be null or empty. There's an error in the XSD compiler"); return instanceName; }
string GetDocumentation (XmlSchemaAnnotated elem) { string res = ""; XmlSchemaAnnotation anot = elem.Annotation; if (anot == null || anot.Items == null) return null; foreach (object ob in anot.Items) { XmlSchemaDocumentation doc = ob as XmlSchemaDocumentation; if (doc != null && doc.Markup != null && doc.Markup.Length > 0) { if (res != string.Empty) res += "\n"; foreach (XmlNode node in doc.Markup) res += node.Value; } } return res; }
/// <summary> /// Creates a new AbstractOption. This, of course, is impossible, due to the fact that AbstractOption is an abstract class. /// </summary> /// <param name="xmlNode">The xml node containing the data that will be manipulated.</param> /// <param name="xsdNode">The corresponding xsdnode of this xmlnode.</param> /// <param name="contentpanel">The panel on which this option should be placed.</param> /// <param name="parentForm">The form of which this option is a part.</param> /// <param name="ismdname">Whether this option allows metadata and if so, whether it needs the name or the value of the metadata.</param> public AbstractDocUIComponent(XmlNode xmlNode, XmlSchemaAnnotated xsdNode, Panel contentpanel = null, Panel overlaypanel = null, DynamicForm parentForm = null) { Log = LogManager.GetCurrentClassLogger(); Label = new TextBlock() { Margin = new Thickness(5) }; this.xmlNode = xmlNode; this.xsdNode = xsdNode; this.Contentpanel = contentpanel; this.ParentForm = parentForm; this.Overlaypanel = overlaypanel; Description = XmlSchemaUtilities.tryGetDocumentation(xsdNode); Visible = XmlSchemaUtilities.tryGetUnhandledAttribute(xsdNode, "visible") == "false" ? false : true; if (Description == null) { Description = xmlNode.LocalName; } }
internal bool GetBooleanAttribute(XmlSchemaAnnotated element, String attrName, bool defVal) { string value = GetMsdataAttribute(element, attrName); if (value == null || value.Length == 0) { return defVal; } if ((value == Keywords.TRUE) || (value == Keywords.ONE_DIGIT)){ return true; } if ((value == Keywords.FALSE) || (value == Keywords.ZERO_DIGIT)){ return false; } // Error processing: throw ExceptionBuilder.InvalidAttributeValue(attrName, value); }
/// <summary> /// Gets the documentation associated with the given XML element. /// </summary> /// <param name="p_xsaAnnotatedElement">The element for which to retrieve the documentations.</param> /// <returns>The documentation associated with the given XML element, or <lang cref="null"/> /// if there is no documentation in the schema.</returns> private string GetDocumentation(XmlSchemaAnnotated p_xsaAnnotatedElement) { XmlSchemaAnnotation xsaAnnotation = p_xsaAnnotatedElement.Annotation; if (xsaAnnotation != null) { StringBuilder stbDescriptions = new StringBuilder(); foreach (XmlSchemaObject xmoObject in xsaAnnotation.Items) { if (xmoObject is XmlSchemaDocumentation) { XmlSchemaDocumentation xsdDocumentation = (XmlSchemaDocumentation)xmoObject; foreach (XmlNode xndNode in xsdDocumentation.Markup) stbDescriptions.AppendLine(xndNode.Value); } } return stbDescriptions.ToString(); } return null; }
internal String GetStringAttribute(XmlSchemaAnnotated element, String attrName, String defVal) { string value = GetMsdataAttribute(element, attrName); if (value == null || value.Length == 0) { return defVal; } return value; }