public MultiOptionSelector(AssetManager assets, string themeName, Vector2 position, Anchor anchor, List<Option> options, MultiOptionArrangement arrangement, Cursor cursor, int initialValue)
            : base(themeName, position, initialValue)
        {
            //process arrangement
            if (arrangement == MultiOptionArrangement.ListX)
                arrangement = new MultiOptionArrangement(options.Count, 1);
            if (arrangement == MultiOptionArrangement.ListY)
                arrangement = new MultiOptionArrangement(1, options.Count);
            this.arrangement = arrangement;

            TextDictionary assetDictionary = new TextDictionary(assets.GetText("selector"));
            //load themes
            string cursorTheme = assetDictionary.LookupString(themeName, "cursorTheme");
            string optionTheme = assetDictionary.LookupString(themeName, "optionTheme");
            Anchor justify = Anchor.Center;
            bool justifySuccess = assetDictionary.CheckPropertyExists(themeName, "justify");
            if (justifySuccess)
            {
                string justifyString = assetDictionary.LookupString(themeName, "justify");
                if (justifyString == "Left")
                    justify = Anchor.CenterLeft;
                else if (justifyString == "Right")
                    justify = Anchor.CenterRight;
            }
            //position components
            cursor.Initialize(options, assets, cursorTheme);
            Vector2 individualSize = Vector2.Zero;
            for (int i = 0; i < options.Count; i++)
            {
                options[i].Initialize(assets, optionTheme);
                if (options[i].Dimensions.X > individualSize.X)
                    individualSize.X = options[i].Dimensions.X;
                if (options[i].Dimensions.Y > individualSize.Y)
                    individualSize.Y = options[i].Dimensions.Y;
            }
            for (int i = 0; i < options.Count; i++)
                options[i].Position = (individualSize + cursor.Spacing * Vector2.One) * arrangement.GetPosition(i);
            Vector2 overallSize = new Vector2(arrangement.Columns * (individualSize.X + cursor.Spacing) - cursor.Spacing, arrangement.Rows * (individualSize.Y + cursor.Spacing) - cursor.Spacing);
            for (int i = 0; i < options.Count; i++)
            {
                Vector2 p = options[i].Position;
                if (justify == Anchor.TopCenter || justify == Anchor.Center || justify == Anchor.BottomCenter)
                    p.X += (individualSize.X - options[i].Dimensions.X) / 2;
                else if (justify == Anchor.TopRight || justify == Anchor.CenterRight || justify == Anchor.BottomRight)
                    p.X += individualSize.X - options[i].Dimensions.X;
                if (justify == Anchor.CenterLeft || justify == Anchor.Center || justify == Anchor.CenterRight)
                    p.Y += (individualSize.Y - options[i].Dimensions.Y) / 2;
                else if (justify == Anchor.BottomLeft || justify == Anchor.BottomCenter || justify == Anchor.BottomRight)
                    p.Y += individualSize.Y - options[i].Dimensions.Y;
                options[i].Position = p;
            }
            this.Position -= GraphicsHelper.ComputeAnchorOrigin(anchor, overallSize / GraphicsConstants.VIEWPORT_DIMENSIONS);
            this.options = options;
            this.cursor = cursor;
            //initialize position
            Vector2 initialPosition = arrangement.GetPosition(IntValue);
            x = (int)initialPosition.X;
            y = (int)initialPosition.Y;
            cursor.Update(IntValue);
        }

        public AnimatedSprite(Animation animation, Vector2 position, Anchor anchor)
        {
            this.animation = animation;
            int width = animation.FrameWidth;
            int height = animation.FrameHeight;

            switch (anchor)
            {
                case Anchor.TOPLEFT:
                    this.mCenter.X = position.X + width / 2;
                    this.mCenter.Y = position.Y + height / 2;
                    break;
                case Anchor.TOPRIGHT:
                    this.mCenter.X = position.X - width / 2;
                    this.mCenter.Y = position.Y + height / 2;
                    break;
                case Anchor.CENTER:
                    this.mCenter = position;
                    break;
                case Anchor.BOTTOMLEFT:
                    this.mCenter.X = position.X + width / 2;
                    this.mCenter.Y = position.Y - height / 2;
                    break;
                case Anchor.BOTTOMRIGHT:
                    this.mCenter.X = position.X - width / 2;
                    this.mCenter.Y = position.Y - height / 2;
                    break;
            }
        }

	// ************************************************************************
	public static Vector2 GetScreenPointFromAnchor(Anchor anchor)
	{
		switch (anchor)
		{

		case Anchor.TOP_LEFT :
			return new Vector2 ( 0.0f,				Screen.height );
		case Anchor.TOP :
			return new Vector2 ( Screen.width / 2,	Screen.height );
		case Anchor.TOP_RIGHT :
			return new Vector2 ( Screen.width,		Screen.height );

		case Anchor.LEFT :
			return new Vector2 ( 0.0f,				Screen.height / 2 );
		case Anchor.CENTER :
			return new Vector2 ( Screen.width / 2,	Screen.height / 2 );
		case Anchor.RIGHT :
			return new Vector2 ( Screen.width,		Screen.height / 2 );

		case Anchor.BOTTOM_LEFT :
			return new Vector2 ( 0.0f,				0 );
		case Anchor.BOTTOM :
			return new Vector2 ( Screen.width / 2,	0 );
		case Anchor.BOTTOM_RIGHT :
			return new Vector2 ( Screen.width,		0 );

		default :

			return Vector2.zero;
		}
	}

        //----------------------------------------------------------------------
        public Button( Screen _screen, ButtonStyle _style, string _strText = "", Texture2D _iconTex = null, Anchor _anchor = Anchor.Center, string _strTooltipText="", object _tag=null )
            : base(_screen)
        {
            Style = _style;

            mPadding    = new Box(5, 0);
            mMargin     = new Box(0);

            mLabel          = new Label( _screen );

            mIcon           = new Image( _screen );
            mIcon.Texture   = _iconTex;
            mIcon.Padding   = new Box( Style.VerticalPadding, 0, Style.VerticalPadding, Style.HorizontalPadding );

            Text            = _strText;
            TextColor       = Screen.Style.DefaultTextColor;

            Anchor          = _anchor;

            mPressedAnim    = new SmoothValue( 1f, 0f, 0.2f );
            mPressedAnim.SetTime( mPressedAnim.Duration );

            mTooltip        = new Tooltip( Screen, "" );

            TooltipText     = _strTooltipText;
            Tag             = _tag;

            UpdateContentSize();
        }

 public Sprite(Texture2D texture, Vector2 position, Anchor anchor)
 {
     this.mTexture = texture;
     switch (anchor)
     {
         case Anchor.TOPLEFT:
             this.mCenter.X = position.X + texture.Width / 2;
             this.mCenter.Y = position.Y + texture.Height / 2;
             break;
         case Anchor.TOPRIGHT:
             this.mCenter.X = position.X - texture.Width / 2;
             this.mCenter.Y = position.Y + texture.Height / 2;
             break;
         case Anchor.CENTER:
             this.mCenter = position;
             break;
         case Anchor.BOTTOMLEFT:
             this.mCenter.X = position.X + texture.Width / 2;
             this.mCenter.Y = position.Y - texture.Height / 2;
             break;
         case Anchor.BOTTOMRIGHT:
             this.mCenter.X = position.X - texture.Width / 2;
             this.mCenter.Y = position.Y - texture.Height / 2;
             break;
     }
     this.mPosition.X = mCenter.X - mTexture.Width / 2;
     this.mPosition.Y = mCenter.Y - mTexture.Height / 2;
 }

        /// <summary>
        /// Creates a new widget with desired background texture.
        /// </summary>
        public Widget(SpriteBatch spriteBatch, String background, int offsetX, int parentX, int offsetY, int parentY, Anchor anchor)
            : this(spriteBatch)
        {
            this.background = AssetManager.GetInstance().getAsset<Texture2D>(background);

            BuildBody(this.background.Width, this.background.Height, offsetX, parentX, offsetY, parentY, anchor);
        }

 /// <summary>
 /// 添加链接点
 /// </summary>
 /// <param name="Content">链接文字</param>
 /// <param name="FontSize">字体大小</param>
 /// <param name="Name">链接点名</param>
 public void AddAnchorName(string Content, float FontSize, string Name)
 {
     SetFont(FontSize);
     Anchor auc = new Anchor(Content, font);
     auc.Name = Name;
     document.Add(auc);
 }

 protected void MakeButtonAt( string text, int width, int height, Font font, Anchor horAnchor,
     Anchor verAnchor, int x, int y)
 {
     WidgetConstructors.MakeButtonAt( game, widgets, ref widgetIndex,
                                     text, width, height, font, horAnchor,
                                     verAnchor, x, y, null );
 }

        public ModelDisplayWidget(SpriteBatch spriteBatch, string bg, int p_3, int p_4, int p_5, int p_6, Anchor anchor_2)
            : base(spriteBatch, bg, p_3, p_4, p_5, p_6, anchor_2)
        {
            camera = new Camera();

            BoundingSphere sphere = new BoundingSphere();
            float scale;
            /*Debug.WriteLine("Hey" + (
                (body.Left - (SettingsManager.GetInstance().ResolutionX/2.0f))
                / SettingsManager.GetInstance().ResolutionX));*/
            //translationAndScale = Matrix.Multiply(Matrix.CreateTranslation(translation), Matrix.CreateScale(new Vector3(0.5f,0.5f,0.5f)));

            //BoundingSphere will give us the size of the model, so we can scale accordingly
            foreach (ModelMesh mesh in myModel.Meshes)
            {
                if (sphere.Radius == 0)
                    sphere = mesh.BoundingSphere;
                else
                    sphere = BoundingSphere.
                             CreateMerged(sphere, mesh.BoundingSphere);
            }
            Debug.WriteLine(sphere.Radius);
            scale = 2.0f / sphere.Radius;
            translationAndScale = Matrix.Multiply(Matrix.CreateTranslation(translation), Matrix.CreateScale(new Vector3(scale, scale, scale)));
        }

 protected void MakeBooleanAt( Anchor horAnchor, Anchor verAnchor, Font font, bool initValue,
     int width, int height, int x, int y)
 {
     WidgetConstructors.MakeBooleanAt( game, widgets, ref widgetIndex,
                                      horAnchor, verAnchor, font, initValue,
                                      width, height, x, y, null );
 }

 public static Point ToAbsolute(Anchor anchor, Point point, Rectangle rect)
 {
     switch (anchor)
     {
         case Anchor.TopLeft:
             point.Offset(rect.Left, rect.Top);
             break;
         case Anchor.TopCenter:
             point.Offset(rect.Left + (rect.Width / 2), rect.Top);
             break;
         case Anchor.TopRight:
             point.Offset(rect.Right, rect.Top);
             break;
         case Anchor.MiddleLeft:
             point.Offset(rect.Left, rect.Top + (rect.Height / 2));
             break;
         case Anchor.MiddleCenter:
             point.Offset(rect.Left + (rect.Width / 2), rect.Top + (rect.Height / 2));
             break;
         case Anchor.MiddleRight:
             point.Offset(rect.Right, rect.Top + (rect.Height / 2));
             break;
         case Anchor.BottomLeft:
             point.Offset(rect.Left, rect.Bottom);
             break;
         case Anchor.BottomCenter:
             point.Offset(rect.Left + (rect.Width / 2), rect.Bottom);
             break;
         case Anchor.BottomRight:
             point.Offset(rect.Right, rect.Bottom);
             break;
     }
     return point;
 }

 ButtonWidget Make( int x, int y, string text, Anchor vDocking, Action<Game, ButtonWidget> onClick,
     Func<Game, string> getter, Action<Game, string> setter)
 {
     ButtonWidget widget = ButtonWidget.Create( game, x, y, 240, 35, text, Anchor.Centre, vDocking, titleFont, onClick );
     widget.GetValue = getter;
     widget.SetValue = setter;
     return widget;
 }

 private void bind(PropertyItem propertyItem, RadioButton btnTopLeft, Anchor anchor)
 {
     BindingOperations.SetBinding(btnTopLeft, ToggleButton.IsCheckedProperty, LambdaBinding.New(
         new Binding("Value") { Source = propertyItem, Mode = propertyItem.IsReadOnly ? BindingMode.OneWay : BindingMode.TwoWay },
         (object source) => { return (Anchor) source == anchor; },
         (bool source) => { return source ? anchor : Binding.DoNothing; }
     ));
 }

 public void DrawAt( IDrawer2D drawer, string text, Font font,
     Anchor horAnchor, Anchor verAnchor, int width, int height, int x, int y)
 {
     ButtonWidth = width; ButtonHeight = height;
     Width = width; Height = height;
     CalculateOffset( x, y, horAnchor, verAnchor );
     Redraw( drawer, text, font );
 }

 /// <summary>
 /// Initializes a new instance of <see cref="Page"/>.
 /// </summary>
 /// <param name="id">Initializes the required <see cref="Id"/>.</param>
 /// <param name="title">Initializes the required <see cref="Title"/>.</param>
 /// <param name="isHome">Initializes the required <see cref="IsHome"/>.</param>
 /// <param name="anchor">Initializes the required <see cref="Anchors"/>.</param>
 /// <param name="content">Initializes the required <see cref="Content"/>.</param>
 public Page(string id, string title, bool isHome, Anchor[] anchor, string content)
 {
     this.Id = id;
     this.Title = title;
     this.IsHome = isHome;
     this.Anchors = anchor;
     this.Content = content;
 }

 protected void MakeInput( string text, int width, Anchor horAnchor, Anchor verAnchor,
     bool password, int x, int y, int maxChars, string hint)
 {
     WidgetConstructors.MakeInput( game, widgets, ref widgetIndex,
                                  text, width, horAnchor, verAnchor,
                                  inputFont, inputHintFont, null,
                                  password, x, y, maxChars, hint );
 }

 public void attachRuler(Anchor anchor)
 {
     // when we attach the specified anchor, rotate it according to the orientation of the owner brick
     anchor.rotate(mOwnerBrick.Orientation);
     // then notify the ruler of the attachment
     anchor.AttachedRuler.attachControlPointToBrick(anchor.AttachedPointIndex, mOwnerBrick);
     // and add the anchor in the attachment list
     mAnchors.Add(anchor);
 }

 /// <summary>
 /// A menu widget needs everything a normal widget has plus a title for the menu
 /// </summary>
 /// SpriteBatch spriteBatch, String background, int offsetX, int parentX, int offsetY, int parentY, Anchor anchor
 public MenuWidget(SpriteBatch spriteBatch, String background, String name, int offsetX, int parentX, int offsetY, int parentY, Anchor anchor)
     : base(spriteBatch, background, offsetX, parentX, offsetY, parentY, anchor)
 {
     this.title = name;
     this.titleBW = new TextButtonWidget(spriteBatch, name, HandleWidgetInput, offsetX, parentX, offsetY, parentY, Widget.Anchor.TOP_CENTER);
     this.menuItems = new List<TextButtonWidget>();
     this.titleFont = fontHeader;
     this.numItems = 0;
 }

 public static new ChatTextWidget Create( Game game, int x, int y, string text, Anchor horizontal, Anchor vertical, Font font )
 {
     ChatTextWidget widget = new ChatTextWidget( game, font );
     widget.Init();
     widget.HorizontalAnchor = horizontal; widget.VerticalAnchor = vertical;
     widget.XOffset = x; widget.YOffset = y;
     widget.SetText( text );
     return widget;
 }

        //----------------------------------------------------------------------
        public BoxGroup( Screen _screen, Orientation _orientation, int _iSpacing, Anchor _contentAnchor = Anchor.Center )
            : base(_screen)
        {
            mlExpandedChildren = new List<bool>();

            mOrientation    = _orientation;
            miSpacing       = _iSpacing;
            mContentAnchor = _contentAnchor;
        }