public LabelStatement(Identifier Label, Statement Labeled, TextSpan Location, TextPoint Colon)
			:base(Operation.Label,Location)
		{
			this.Label = Label;
			this.Labeled = Labeled;
			this.Colon = Colon;
		}

		public DoStatement(Statement Body, Expression Condition, TextSpan Location, TextSpan HeaderLocation, TextPoint While, TextPoint LeftParen, TextPoint RightParen)
			:base(Operation.Do, Body, Location, LeftParen, RightParen)
		{
			this.While = While;
			this.Condition = Condition;
			this.HeaderLocation = HeaderLocation;
		}

		public ObjectLiteralElement(Expression Name, Expression Value, TextPoint ColonLocation, TextPoint CommaLocation)
		{
			this.Name = Name;
			this.Value = Value;
			this.ColonLocation = ColonLocation;
			this.CommaLocation = CommaLocation;
		}

        private CodeElement GetCodeElementAtTextPoint(vsCMElement eRequestedCodeElementKind,
            CodeElements colCodeElements, TextPoint objTextPoint)
        {

            //  CodeElement objCodeElement = default(CodeElement);
            CodeElement objResultCodeElement = default(CodeElement);
            CodeElements colCodeElementMembers = default(CodeElements);
            CodeElement objMemberCodeElement = default(CodeElement);


            if ((colCodeElements != null))
            {

                foreach (CodeElement objCodeElement in colCodeElements)
                {

                    if (objCodeElement.StartPoint.GreaterThan(objTextPoint))
                    {
                        // The code element starts beyond the point


                    }
                    else if (objCodeElement.EndPoint.LessThan(objTextPoint))
                    {
                        // The code element ends before the point

                        // The code element contains the point
                    }
                    else
                    {

                        if (objCodeElement.Kind == eRequestedCodeElementKind)
                        {
                            // Found
                            objResultCodeElement = objCodeElement;
                        }

                        // We enter in recursion, just in case there is an inner code element that also 
                        // satisfies the conditions, for example, if we are searching a namespace or a class
                        colCodeElementMembers = GetCodeElementMembers(objCodeElement);

                        objMemberCodeElement = GetCodeElementAtTextPoint(eRequestedCodeElementKind, colCodeElementMembers, objTextPoint);

                        if ((objMemberCodeElement != null))
                        {
                            // A nested code element also satisfies the conditions
                            objResultCodeElement = objMemberCodeElement;
                        }

                        break; // TODO: might not be correct. Was : Exit For

                    }

                }

            }

            return objResultCodeElement;

        }

		public BinaryOperatorExpression(Expression Left, Expression Right, Expression.Operation Opcode, TextSpan Location, TextPoint OperatorLocation)
			: base(Opcode,Location)
		{
			this.Left = Left;
			this.Right = Right;
			this.operatorLocation = OperatorLocation;
		}

		public SubscriptExpression(Expression Base, Expression Subscript, TextSpan Location, TextPoint LeftBracketLocation)
			: base(Operation.Subscript, Location)
		{
			this.Base = Base;
			this.Subscript = Subscript;
			this.LeftBracketLocation = LeftBracketLocation;
		}

		public LoopStatement(Statement.Operation Opcode, Statement Body, TextSpan Location, TextPoint LeftParen, TextPoint RightParen)
			:base(Opcode,Location)
		{
			this.Body = Body;
			this.LeftParen = LeftParen;
			this.RightParen = RightParen;
		}

		public ForInStatement(Statement.Operation Opcode, Expression Collection, Statement Body, TextSpan Location, TextSpan HeaderLocation, TextPoint In, TextPoint LeftParen, TextPoint RightParen)
			:base(Opcode, Body, Location, LeftParen, RightParen)
		{
			this.Collection = Collection;
			this.HeaderLocation = HeaderLocation;
			this.In = In;
		}

		public CaseClause(DList<Statement, CaseClause> Children, TextSpan Location, TextSpan HeaderLocation, TextPoint Colon)
		{
			this.colon = Colon;
			this.location = Location;
			this.Children = Children;
			this.HeaderLocation = HeaderLocation;
		}

		//=========================================================================================
		public Token(string typeName, string text, TextPoint start, TextPoint end, TextStyle style)
		{
			this.TokenTypeName = typeName;
			this.Text = text;
			this.Start = start;
			this.End = end;
			this.Style = style;
		}

		public QualifiedExpression(Expression Base, Identifier Qualifier, TextSpan Location, TextPoint DotLocation, TextPoint QualifierLocation)
			:base(Operation.Qualified, Location)
		{
			this.Base = Base;
			this.Qualifier = Qualifier;
			this.DotLocation = DotLocation;
			this.QualifierLocation = QualifierLocation;
		}

		public DeclarationForInStatement(VariableDeclaration Item, Expression Collection, Statement Body, TextSpan Location, TextSpan HeaderLocation, TextPoint In, TextPoint LeftParen, TextPoint RightParen)
			:base(Operation.DeclarationForIn,Collection,Body,Location,HeaderLocation,In,LeftParen,RightParen)
		{
			this.Item = Item;
			this.In = In;
			this.LeftParen = LeftParen;
			this.RightParen = RightParen;
		}

		public WithStatement(Expression Scope, Statement Body, TextSpan Location, TextSpan HeaderLocation, TextPoint LeftParen, TextPoint RightParen)
			:base(Operation.With,Location)
		{
			this.LeftParen = LeftParen;
			this.RightParen = RightParen;
			this.Body = Body;
			this.HeaderLocation = HeaderLocation;
			this.Scope = Scope;
		}

		public CatchClause(Identifier Name, BlockStatement Handler, TextSpan Location, TextSpan NameLocation, TextPoint LeftParen, TextPoint RightParen)
		{
			this.Name = Name;
			this.Handler = Handler;
			this.Location = Location;
			this.NameLocation = NameLocation;
			this.leftParen = LeftParen;
			this.rightParen = RightParen;
		}

 //������Ɖ����t���O
 //private bool _disabledTemporary;
 public TextSelection(CharacterDocumentViewer owner)
 {
     _owner = owner;
     _forwardPivot = new TextPoint();
     _backwardPivot = new TextPoint();
     _forwardDestination = new TextPoint();
     _backwardDestination = new TextPoint();
     _listeners = new List<ISelectionListener>();
 }

		public ForStatement(Statement.Operation Opcode, Expression Condition, Expression Increment, Statement Body, TextSpan Location, TextSpan HeaderLocation, TextPoint FirstSemicolon, TextPoint SecondSemicolon, TextPoint LeftParen, TextPoint RightParen)
			:base(Opcode,Body,Location,LeftParen,RightParen)
		{
			this.Condition = Condition;
			this.Increment = Increment;
			this.HeaderLocation = HeaderLocation;
			this.FirstSemicolon= FirstSemicolon;
			this.SecondSemicolon = SecondSemicolon;
		}

		public TernaryOperatorExpression(Expression First, Expression Second, Expression Third, Expression.Operation opcode, TextSpan Location, TextPoint FirstOperatorLocation, TextPoint SecondOperatorLocation)
			:base(opcode,Location)
		{
			this.First = First;
			this.Second = Second;
			this.Third = Third;
			this.FirstOperatorLocation = FirstOperatorLocation;
			this.SecondOperatorLocation = SecondOperatorLocation;
		}

		public SwitchStatement(Expression Value, DList<CaseClause, SwitchStatement> Cases, TextSpan Location, TextSpan HeaderLocation, TextPoint LeftParen, TextPoint RightParen, TextPoint LeftBrace)
			:base(Operation.Switch,Location)
		{
			this.Value = Value;
			this.Cases = Cases;
			this.HeaderLocation = HeaderLocation;
			this.LeftParen = LeftParen;
			this.RightParen = RightParen;
			this.LeftBrace = LeftBrace;
		}

			// [jt] This handler checks for things like paste operations. In theory we should be able to remove the handler above, but
			// I can't get this one to fire reliably... Wonder how much these handlers will slow down the IDE?
			private void OnLineChanged(TextPoint StartPoint, TextPoint EndPoint, int Hint)
			{
				if((Hint & (int)vsTextChanged.vsTextChangedNewline) == 0 &&
					(Hint & (int)vsTextChanged.vsTextChangedMultiLine) == 0 &&
					(Hint & (int)vsTextChanged.vsTextChangedNewline) == 0 &&
					(Hint != 0))
					return;
				if(mPlugin.App.ActiveDocument.ReadOnly && !mPlugin.App.ActiveDocument.Saved)
					P4Operations.EditFile(mPlugin.OutputPane, mPlugin.App.ActiveDocument.FullName);
			}

		public FunctionDefinition(Identifier Name, List<Parameter> Parameters, BlockStatement Body, TextSpan Location, TextSpan HeaderLocation, TextPoint NameLocation, TextPoint LeftParenLocation, TextPoint RightParenLocation)
		{
			this.Name = Name;
			this.Parameters = Parameters;
			this.Body = Body;
			this.Location = Location;
			this.HeaderLocation = HeaderLocation;
			this.NameLocation = NameLocation;
			this.LeftParenLocation = LeftParenLocation;
			this.RightParenLocation = RightParenLocation;
		}