public void MarkElement_SettingFirstValue_StateReturnThatValue(ElementState startingState)
        {
            // Setup
            var element = new GameBoardElement(0, 0);

            // Call
            element.MarkElement(startingState);

            // Assert
            Assert.AreEqual(startingState, element.State);
        }
Example #2
0
		public void PaintCheckBox (Graphics g, Rectangle bounds, Color backColor, Color foreColor, ElementState state, FlatStyle style, CheckState checkState)
		{
			switch (style) {
				case FlatStyle.Standard:
				case FlatStyle.System:
					switch (state) {
						case ElementState.Normal:
							DrawNormalCheckBox (g, bounds, backColor, foreColor, checkState);
							break;
						case ElementState.Hot:
							DrawHotCheckBox (g, bounds, backColor, foreColor, checkState);
							break;
						case ElementState.Pressed:
							DrawPressedCheckBox (g, bounds, backColor, foreColor, checkState);
							break;
						case ElementState.Disabled:
							DrawDisabledCheckBox (g, bounds, backColor, foreColor, checkState);
							break;
					}
					break;
				case FlatStyle.Flat:
					switch (state) {
						case ElementState.Normal:
							DrawFlatNormalCheckBox (g, bounds, backColor, foreColor, checkState);
							break;
						case ElementState.Hot:
							DrawFlatHotCheckBox (g, bounds, backColor, foreColor, checkState);
							break;
						case ElementState.Pressed:
							DrawFlatPressedCheckBox (g, bounds, backColor, foreColor, checkState);
							break;
						case ElementState.Disabled:
							DrawFlatDisabledCheckBox (g, bounds, backColor, foreColor, checkState);
							break;
					}
					break;
				case FlatStyle.Popup:
					switch (state) {
						case ElementState.Normal:
							DrawPopupNormalCheckBox (g, bounds, backColor, foreColor, checkState);
							break;
						case ElementState.Hot:
							DrawPopupHotCheckBox (g, bounds, backColor, foreColor, checkState);
							break;
						case ElementState.Pressed:
							DrawPopupPressedCheckBox (g, bounds, backColor, foreColor, checkState);
							break;
						case ElementState.Disabled:
							DrawPopupDisabledCheckBox (g, bounds, backColor, foreColor, checkState);
							break;
					}
					break;
			}
		}
Example #3
0
 public void SetUnFocus()
 {
     if (this.state != ElementState.UnFocus)
     {
         HotspotLeft.Visibility = Visibility.Collapsed;
         HotspotTop.Visibility = Visibility.Collapsed;
         HotspotRight.Visibility = Visibility.Collapsed;
         HotspotBottom.Visibility = Visibility.Collapsed;
         this.state = ElementState.UnFocus;
     }
 }
Example #4
0
		public void PaintRadioButton (Graphics g, Rectangle bounds, Color backColor, Color foreColor, ElementState state, FlatStyle style, bool isChecked)
		{
			switch (style) {
				case FlatStyle.Standard:
				case FlatStyle.System:
					switch (state) {
						case ElementState.Normal:
							DrawNormalRadioButton (g, bounds, backColor, foreColor, isChecked);
							break;
						case ElementState.Hot:
							DrawHotRadioButton (g, bounds, backColor, foreColor, isChecked);
							break;
						case ElementState.Pressed:
							DrawPressedRadioButton (g, bounds, backColor, foreColor, isChecked);
							break;
						case ElementState.Disabled:
							DrawDisabledRadioButton (g, bounds, backColor, foreColor, isChecked);
							break;
					}
					break;
				case FlatStyle.Flat:
					switch (state) {
						case ElementState.Normal:
							DrawFlatNormalRadioButton (g, bounds, backColor, foreColor, isChecked);
							break;
						case ElementState.Hot:
							DrawFlatHotRadioButton (g, bounds, backColor, foreColor, isChecked);
							break;
						case ElementState.Pressed:
							DrawFlatPressedRadioButton (g, bounds, backColor, foreColor, isChecked);
							break;
						case ElementState.Disabled:
							DrawFlatDisabledRadioButton (g, bounds, backColor, foreColor, isChecked);
							break;
					}
					break;
				case FlatStyle.Popup:
					switch (state) {
						case ElementState.Normal:
							DrawPopupNormalRadioButton (g, bounds, backColor, foreColor, isChecked);
							break;
						case ElementState.Hot:
							DrawPopupHotRadioButton (g, bounds, backColor, foreColor, isChecked);
							break;
						case ElementState.Pressed:
							DrawPopupPressedRadioButton (g, bounds, backColor, foreColor, isChecked);
							break;
						case ElementState.Disabled:
							DrawPopupDisabledRadioButton (g, bounds, backColor, foreColor, isChecked);
							break;
					}
					break;
			}
		}
Example #5
0
 public void SetFocus()
 {
     if (this.state != ElementState.Focus)
     {
         SetHotspotStyle(Colors.Blue, 1.0);
         HotspotLeft.Visibility = Visibility.Visible;
         HotspotTop.Visibility = Visibility.Visible;
         HotspotRight.Visibility = Visibility.Visible;
         HotspotBottom.Visibility = Visibility.Visible;
         this.state = ElementState.Focus;
     }
 }
        public void MarkElement_FromYesToAnyNotStates_StateReturnsNewNotState(ElementState newNotState)
        {
            // Setup
            var element = new GameBoardElement(0, 0);
            element.MarkElement(ElementState.Yes);

            // Call
            element.MarkElement(newNotState);

            // Assert
            Assert.AreEqual(newNotState, element.State);
        }
        public void MarkElement_FromAnyStateToEmpty_StateReturnsEmpty(ElementState startingState)
        {
            // Setup
            var element = new GameBoardElement(0, 0);
            element.MarkElement(startingState);

            // Call
            element.MarkElement(ElementState.Empty);

            // Assert
            Assert.AreEqual(ElementState.Empty, element.State);
        }
Example #8
0
        public void SetSelected()
        {
            if (this.state != ElementState.Selected)
            {
                SetHotspotStyle(Colors.Red, 0.5);
                HotspotLeft.Visibility = Visibility.Visible;
                HotspotTop.Visibility = Visibility.Visible;
                HotspotRight.Visibility = Visibility.Visible;
                HotspotBottom.Visibility = Visibility.Visible;

                this.state = ElementState.Selected;
            }
        }
Example #9
0
		/// <summary>
		/// 
		/// </summary>
		/// <param name="gr"></param>
		/// <param name="rect"></param>
		/// <param name="d"></param>
		/// <param name="state"></param>
		protected override void DrawArrow(Graphics gr, Rectangle rect, Direction d, ElementState state)
		{
			if (ThemeFactory.VisualStylesEnabled && ThemeFactory.VisualStylesSupported)
			{
				ThemeFactory.DrawScrollBar(gr, rect, GetArrowScrollBarStates(d, state), ScrollBarParts.ArrowBtn);	
			}
			else				
			{
				ScrollButton sb = DirectionToScrollButton(d);
				ButtonState bs = ElementStateToButtonState(state);

				ControlPaint.DrawScrollButton(gr, rect, sb, bs);
			}
		}
Example #10
0
        protected override void DeserializeCore(XmlElement element, SaveContext context)
        {
            XmlElementHelper helper = new XmlElementHelper(element);
            this.GUID = helper.ReadGuid("guid", Guid.NewGuid());

            // Resolve node nick name.
            string nickName = helper.ReadString("nickname", string.Empty);
            if (!string.IsNullOrEmpty(nickName))
                this.nickName = nickName;
            else
            {
                System.Type type = this.GetType();
                var attribs = type.GetCustomAttributes(typeof(NodeNameAttribute), true);
                NodeNameAttribute attrib = attribs[0] as NodeNameAttribute;
                if (null != attrib)
                    this.nickName = attrib.Name;
            }

            this.X = helper.ReadDouble("x", 0.0);
            this.Y = helper.ReadDouble("y", 0.0);
            this.isVisible = helper.ReadBoolean("isVisible", true);
            this.isUpstreamVisible = helper.ReadBoolean("isUpstreamVisible", true);
            this.argumentLacing = helper.ReadEnum("lacing", LacingStrategy.Disabled);

            if (context == SaveContext.Undo)
            {
                // Fix: MAGN-159 (nodes are not editable after undo/redo).
                interactionEnabled = helper.ReadBoolean("interactionEnabled", true);
                this.state = helper.ReadEnum("nodeState", ElementState.ACTIVE);

                // We only notify property changes in an undo/redo operation. Normal
                // operations like file loading or copy-paste have the models created
                // in different ways and their views will always be up-to-date with
                // respect to their models.
                RaisePropertyChanged("InteractionEnabled");
                RaisePropertyChanged("State");
                RaisePropertyChanged("NickName");
                RaisePropertyChanged("ArgumentLacing");
                RaisePropertyChanged("IsVisible");
                RaisePropertyChanged("IsUpstreamVisible");

                // Notify listeners that the position of the node has changed,
                // then all connected connectors will also redraw themselves.
                this.ReportPosition();
            }
        }
Example #11
0
        public void SetSelected()
        {
            if (this._State != ElementState.Selected)
            {
                SetHotspotStyle(Colors.Red, 1.0);
                ellipseBegin.Visibility = Visibility.Visible;
                rectangleCenter.Visibility = Visibility.Visible;
                ellipseEnd.Visibility = Visibility.Visible;

                this._State = ElementState.Selected;
            }
        }
Example #12
0
        public void SetFocus()
        {
            if (this._State != ElementState.Focus)
            {
                SetHotspotStyle(Colors.Yellow, 1.0);
                ellipseBegin.Visibility = Visibility.Visible;
                rectangleCenter.Visibility = Visibility.Visible;
                ellipseEnd.Visibility = Visibility.Visible;
                //直线状态不显示中间点
                //if (IsStraightLine() == true) rectangleCenter.Visibility = Visibility.Collapsed;

                this._State = ElementState.Focus;
            }
        }
 private bool ReadRoot()
 {
     this._elementStack.Push(this._rootElement);
     if (this._rootElement is OpenXmlMiscNode)
     {
         this._elementState = ElementState.MiscNode;
     }
     else
     {
         this._elementState = ElementState.Start;
     } 
     return true;
 }
 /// <summary>
 /// Closes the reader.
 /// </summary>
 public override void Close()
 {
     ThrowIfObjectDisposed();
     this._elementState = ElementState.EOF;
     this._elementStack.Clear();
     this._rootElement = null;
 }
        /// <summary>
        /// Move to  next sibling element 
        /// </summary>
        /// <returns>true if the next sibling element was read successfully; false if there are no more sibling elements to read. </returns>
        /// <remarks>Current will move to the end tag of the parent if no more sibling element.</remarks>
        private bool MoveToNextSibling()
        {
            if (this._elementState == ElementState.EOF)
            {
                return false;
            }

            ThrowIfNull();

            if (this._elementStack.Count == 0)
            {
                this._elementState = ElementState.EOF;
                return false;
            }

            OpenXmlElement element = this._elementStack.Pop();

            // Fix bug #253890, case: the element used to constructor this DOM reader is not root element ( aka. it has parents and siblings. )
            // the stack is empty means we should move to EOF.
            if (this._elementStack.Count == 0)
            {
                this._elementState = ElementState.EOF;
                return false;
            }

            element = element.NextSibling();
            if (element != null)
            {
                this._elementStack.Push(element);
                if (element is OpenXmlMiscNode)
                {
                    this._elementState = ElementState.MiscNode;
                }
                else
                {
                    this._elementState = ElementState.Start;
                } 
                return true;
            }
            else
            {
                if (this._elementStack.Count > 0)
                {
                    this._elementState = ElementState.End;
                }
                else
                {
                    // no more element, EOF
                    this._elementState = ElementState.EOF;
                }
                return false;
            }
        }
        /// <summary>
        /// Move to next element 
        /// </summary>
        /// <returns>true if the next element was read successfully; false if there are no more elements to read. </returns>
        private bool MoveToNextElement()
        {
            if (this._elementState == ElementState.Null)
            {
                return this.ReadRoot();
            }

            OpenXmlElement element;

            switch (this._elementState)
            {
                case ElementState.EOF:
                    return false;

                case ElementState.Start:
                    {
                        element = this._elementStack.Peek();
                        if (element.HasChildren)
                        {
                            this._elementStack.Push(element.FirstChild);
                            if (element.FirstChild is OpenXmlMiscNode)
                            {
                                this._elementState = ElementState.MiscNode;
                            }
                            else
                            {
                                this._elementState = ElementState.Start;
                            }
                        }
                        else
                        {
                            // at start state
                            this._elementState = ElementState.End;
                        }
                    }
                    break;

                case ElementState.End:
                case ElementState.MiscNode:
                    {
                        // at end state, find next element
                        element = this._elementStack.Pop();

                        if (this._elementStack.Count > 0)
                        {
                            element = element.NextSibling();
                            if (element != null)
                            {
                                this._elementStack.Push(element);

                                if (element is OpenXmlMiscNode)
                                {
                                    this._elementState = ElementState.MiscNode;
                                }
                                else
                                {
                                    this._elementState = ElementState.Start;
                                }
                            }
                            else
                            {
                                this._elementState = ElementState.End;
                            }
                        }
                        else
                        {
                            Debug.Assert(element == this._rootElement);
                            // no more elements
                            this._elementState = ElementState.EOF;
                            return false;
                        }
                    }
                    break;

                default:
                    Debug.Assert(this._elementState == ElementState.Start ||
                        this._elementState == ElementState.End ||
                        this._elementState == ElementState.EOF);
                    return false;
            }
            return true;
        }
        /// <summary>
        /// Move to first child 
        /// </summary>
        /// <returns>true if the first child element was read successfully; false if there are no child elements to read. </returns>
        /// <remarks>Only can be called on element start. Current will move to the end tag if no child element.</remarks>
        private bool MoveToFirstChild()
        {
            ThrowIfNull();

            if (this._elementState != ElementState.Start)
            {
                return false;
            }            

            OpenXmlElement element = this._elementStack.Peek();
            if (element.HasChildren)
            {
                this._elementStack.Push(element.FirstChild);
                if (element.FirstChild is OpenXmlMiscNode)
                {
                    this._elementState = ElementState.MiscNode;
                }
                else
                {
                    this._elementState = ElementState.Start;
                }
                return true;
            }
            else
            {
                this._elementState = ElementState.End;
                return false;
            }
        }
        /// <summary>
        /// Loads the element at the current cursor.
        /// </summary>
        /// <returns>The OpenXmlElement object.</returns>
        /// <exception cref="InvalidOperationException">Thrown when the current element is element end.</exception>
        /// <remarks>The new current element is the end of the element after LoadCurrentElement().</remarks>
        public override OpenXmlElement LoadCurrentElement()
        {
            ThrowIfObjectDisposed();
            OpenXmlElement element;

            switch (this._elementState)
            {
                case ElementState.LeafStart:
                    element = this._elementStack.Pop();
                    this._elementStack.Push(element.CloneNode(true));

                    // stop at the end tag. 
                    this._elementState = ElementState.LoadEnd;
                    return element;

                case ElementState.Start:
                    element = this._elementStack.Peek();
                    element.Load(this._xmlReader, OpenXmlLoadMode.Full);

                    // stop at the end tag. 
                    this._elementState = ElementState.LoadEnd;
                    return element;

                case ElementState.MiscNode:
                    Debug.Assert(this.ReadMiscNodes);

                    element = this._elementStack.Pop();
                    element.Load(this._xmlReader, OpenXmlLoadMode.Full);
                    // stop at next element.
                    GetElementInformation();
                    return element;


                case ElementState.Null:
                    ThrowIfNull();
                    break;

                case ElementState.EOF:
                    ThrowIfEof();
                    break;

                case ElementState.LoadEnd:
                case ElementState.End:
                case ElementState.LeafEnd:
                    throw new InvalidOperationException(ExceptionMessages.ReaderInEndState);

                default:
                    Debug.Assert(false);
                    break;
            }
            return null;
        }
        /// <summary>
        /// Loads the element at the current cursor.
        /// </summary>
        /// <returns>The OpenXmlElement object.</returns>
        /// <exception cref="InvalidOperationException">Thrown when the current element is element end.</exception>
        /// <remarks>The new current element is the end of the element after LoadCurrentElement().</remarks>
        public override OpenXmlElement LoadCurrentElement()
        {
            // TODO: should we return a clone?
            // The user expect the element in the tree returned? Is this assumption correct?
            ThrowIfObjectDisposed();
            ThrowIfNull();
            ThrowIfEof();

            if (this._elementState == ElementState.Start)
            {
                OpenXmlElement element = this._elementStack.Peek();

                this._elementState = ElementState.End;

                return element;
            }
            else if (this._elementState == ElementState.MiscNode)
            {
                Debug.Assert(this.ReadMiscNodes);

                OpenXmlElement element = this._elementStack.Peek();

                this.Skip();

                return element;
            }
            else
            {
                throw new InvalidOperationException(ExceptionMessages.ReaderInEndState);
            }
        }
 /// <summary>
 /// Closes the reader.
 /// </summary>
 public override void Close()
 {
     ThrowIfObjectDisposed();
     this._elementState = ElementState.EOF;
     this._elementStack.Clear();
     this._xmlReader.Close();
 }
 private void Init(OpenXmlElement openXmlElement)
 {
     this._rootElement = openXmlElement;
     this._elementState = ElementState.Null;
 }
        private void Init(Stream partStream, bool closeInput)
        {
            _elementContext.XmlReaderSettings.CloseInput = closeInput;
            _elementContext.XmlReaderSettings.DtdProcessing = DtdProcessing.Prohibit; // set true explicitly for security fix
            _elementContext.XmlReaderSettings.IgnoreWhitespace = true; // O15:#3024890, the default is false, but we set it to True for compatibility of OpenXmlPartReader behavior
            this._xmlReader = XmlConvertingReaderFactory.Create(partStream, _elementContext.XmlReaderSettings);

            this._xmlReader.Read();

            if ( this._xmlReader.NodeType == XmlNodeType.XmlDeclaration)
            {
                 this._encoding = this._xmlReader["encoding"]; // get the "encoding" attribute

                //if (!String.IsNullOrEmpty(encoding))
                //{
                //    try
                //    {
                //        this._encoding = Encoding.GetEncoding(encoding);
                //    }
                //    catch (ArgumentException)
                //    {
                //        // should we catch?
                //        this._encoding = Encoding.UTF8;
                //    }
                //}

                string standalone = this._xmlReader["standalone"]; // get the "standalone" attribute

                if (!String.IsNullOrEmpty(standalone))
                {
                    if (standalone == "yes")
                    {
                        this._standalone = true;
                    }
                    else
                    {
                        this._standalone = false;
                    }
                }
            }

            this._elementState = ElementState.Null;
        }
 private OpenXmlPartReader(bool readMiscNodes)
     : base ( readMiscNodes )
 {
     this._attributeList = new List<OpenXmlAttribute>();
     this._nsDecls = new List<KeyValuePair<string, string>>();
     this._elementStack = new Stack<OpenXmlElement>();
     this._elementContext = new OpenXmlElementContext();
     this._elementState = ElementState.Null;
 }
        private bool ReadRoot()
        {
            Debug.Assert(this._elementState == ElementState.Null);
            Debug.Assert(this._elementStack.Count == 0);

            // TODO: should we take care of entity? <!DOCTYPE page [ <!ENTITY company "Microsoft"> ]>
            // TODO: is it OK that we skip all prolog ( DOCTYPE, Comment, PT ) ?

            this._xmlReader.MoveToContent();

            while (!this._xmlReader.EOF && this._xmlReader.NodeType != XmlNodeType.Element)
            {
                this._xmlReader.Skip();
            }

            if (this._xmlReader.EOF || !this._xmlReader.IsStartElement())
            {
                throw new InvalidDataException(ExceptionMessages.PartIsEmpty);
            }

            // create the root element object
            OpenXmlElement rootElement = RootElementFactory.CreateElement(this._xmlReader.NamespaceURI, this._xmlReader.LocalName);

            if (rootElement == null)
            {
                throw new InvalidDataException(ExceptionMessages.PartUnknown);
            }

            this._elementStack.Push(rootElement);

            LoadAttributes();

            if (this._xmlReader.IsEmptyElement)
            {
                this._elementState = ElementState.LeafStart;
                rootElement.Load(this._xmlReader, OpenXmlLoadMode.Full);
            }
            else
            {
                this._elementState = ElementState.Start;
            }
            return true;
        }
Example #25
0
        public void SetUnFocus()
        {
            if (this._State != ElementState.UnFocus)
            {
                SetHotspotStyle(Colors.Blue, 0.8);
                ellipseBegin.Visibility = Visibility.Collapsed;
                rectangleCenter.Visibility = Visibility.Collapsed;
                ellipseEnd.Visibility = Visibility.Collapsed;

                this._State = ElementState.UnFocus;
            }
        }
        private void GetElementInformation()
        {
            if (this._xmlReader.EOF)
            {
                Debug.Assert(this._elementStack.Count == 0);

                this._elementState = ElementState.EOF;
                return;
            }

            Debug.Assert(this._elementStack.Count > 0);

            OpenXmlElement element;
            switch (this._xmlReader.NodeType)
            {
                case XmlNodeType.EndElement:
//#if DEBUG
//                    {
//                        OpenXmlElement top = this._elementStack.Pop();

//                        element = this.CreateElement();

//                        this._elementStack.Push(top);

//                        Debug.Assert(element.GetType() == this._elementStack.Peek().GetType());
//                    }
//#endif
                    this._elementState = ElementState.End;
                    break;

                case XmlNodeType.Element:
                    element = this.CreateChildElement();

                    LoadAttributes();

                    if (this._xmlReader.IsEmptyElement)
                    {
                        this._elementState = ElementState.LeafStart;
                        element.Load(this._xmlReader, OpenXmlLoadMode.Full);
                    }
                    else if (element is OpenXmlLeafElement  || element is OpenXmlLeafTextElement )
                    {
                        this._elementState = ElementState.LeafStart;
                        element.Load(this._xmlReader, OpenXmlLoadMode.Full);
                    }
                    else if (element is OpenXmlUnknownElement)
                    {
                        this._elementState = ElementState.Start;
                    }
                    else
                    {
                        Debug.Assert(element is OpenXmlCompositeElement);
                        this._elementState = ElementState.Start;
                    }

                    this._elementStack.Push(element);
                    break;

                default:
                    // non element ( PI, Comment, Notation, XmlDeclaration )
                    element = this.CreateChildElement();
                    (element as OpenXmlMiscNode).LoadOuterXml(this._xmlReader);
                    this._elementStack.Push(element);
                    this._elementState = ElementState.MiscNode;
                    break;
            }
        }
Example #27
0
 /// <summary>
 /// Sets the element state. The <see cref="Screen"/> must have been assigned before the element state is set to
 /// <see cref="Visuals.ElementState.Running"/>.
 /// </summary>
 /// <param name="state"></param>
 public void SetElementState(ElementState state)
 {
   ForEachElementInTree_BreadthFirst(new SetElementStateAction(state));
 }
 private OpenXmlDomReader()
     : base()
 {
     this._elementStack = new Stack<OpenXmlElement>();
     this._elementState = ElementState.Null;
 }
Example #29
0
 void SetState(dynNode el, ElementState state)
 {
     el.State = state;
 }
 private OpenXmlDomReader(bool readMiscNodes)
     : base(readMiscNodes)
 {
     this._elementStack = new Stack<OpenXmlElement>();
     this._elementState = ElementState.Null;
 }