/// <summary>
 /// Construct a new <see cref="Table" />.
 /// </summary>
 /// <param name="tableName">
 /// The name of the <see cref="Table" />.
 /// </param>
 /// <param name="headerAlignment">
 /// The method to use to align the text in the table's header.
 /// Defaults to <see cref="StringFormatting.LeftJustified" />.
 /// </param>
 public Table(string tableName=null, Alignment headerAlignment=null)
 {
     Title = tableName ?? string.Empty;
     HeaderAlignment = headerAlignment ?? StringFormatting.LeftJustified;
     Columns = new ColumnCollection();
     Rows = new RowCollection(this);
 }

        public void Center(Rectangle theDisplayArea, Alignment theAlignment)
        {
            Vector2 theTextSize = mFont.MeasureString(mText);

            switch (theAlignment)
            {
                case Alignment.Horizonatal:
                    {
                        Position.X = theDisplayArea.X + (theDisplayArea.Width / 2 - theTextSize.X / 2);
                        break;
                    }

                case Alignment.Vertical:
                    {
                        Position.Y = theDisplayArea.Y + (theDisplayArea.Height / 2 - theTextSize.Y / 2);
                        break;
                    }

                case Alignment.Both:
                    {
                        Position.X = theDisplayArea.X + (theDisplayArea.Width / 2 - theTextSize.X / 2);
                        Position.Y = theDisplayArea.Y + (theDisplayArea.Height / 2 - theTextSize.Y / 2);
                        break;
                    }
            }
        }

 public AlignmentState (Alignment alignment, float padding, uint[] numberOfItems)
     : this()
 {
     Alignment = alignment;
     Padding = padding;
     NumberOfItemsPer = numberOfItems;
 }

        //------------------------------------------------------------------------------
        // Function: ItemSelector
        // Author: nholmes
        // Summary: item constructor, allows user to specify the width of the button,
        //          the options that can be selected from, the vertical position, the
        //          alignment and the font
        //------------------------------------------------------------------------------
        public ItemSelector(Menu menu, Game game, string[] optionsText, int selectedOption, int y, int width, Alignment alignment, SpriteFont font, Color fontColor, int textOffset)
            : base(menu, game, textOffset)
        {
            // store the width of the button, options text, selected option and the font to use
            this.width = width;
            this.optionsText = optionsText;
            this.selectedOption = selectedOption;
            this.font = font;
            this.fontColor = fontColor;

            // set the vy position of this button item
            position.Y = y;

            // calculate position based on alignment provided
            switch (alignment)
            {
                case Alignment.left:
                    position.X = 0;
                    break;
                case Alignment.centre:
                    position.X = (menu.ItemArea.Width / 2) - (width / 2);
                    break;
                case Alignment.right:
                    position.X = width - (int)font.MeasureString(optionsText[selectedOption]).X;
                    break;
                default:
                    position.X = 0;
                    break;
            }

            // store the size of this button item
            size.X = width;
            size.Y = menu.ButtonTexture.Height;
        }

        public AlignmentButton()
        {
            InitializeComponent();

            m_alignment = Alignment.Centre;
            m_image = Resources.DefaultButtonImage;
        }

        //------------------------------------------------------------------------------
        // Function: ItemSlider
        // Author: nholmes
        // Summary: item constructor, allows user to specify the width of the slider,
        //          the values that can be selected between, the vertical position, the
        //          alignment and the font
        //------------------------------------------------------------------------------
        public ItemSlider(Menu menu, Game game, int minValue, int maxValue, int initialValue, int y, int width, Alignment alignment, SpriteFont font, Color fontColor, int textOffset)
            : base(menu, game, textOffset)
        {
            // store the width of the button, options text, selected option and the font to use
            this.width = width;
            this.minValue = minValue;
            this.maxValue = maxValue;
            this.currentValue = initialValue;
            this.font = font;
            this.fontColor = fontColor;

            // set the vy position of this button item
            position.Y = y;

            // calculate position based on alignment provided
            switch (alignment)
            {
                case Alignment.left:
                    position.X = 0;
                    break;
                case Alignment.centre:
                    position.X = (menu.ItemArea.Width / 2) - (width / 2);
                    break;
                case Alignment.right:
                    position.X = width;
                    break;
                default:
                    position.X = 0;
                    break;
            }

            // store the size of this button item
            size.X = width;
            size.Y = menu.ButtonTexture.Height;
        }

 public void AddComponent(MSGUIUnclickable component, Alignment alignment)
 {
     switch (alignment)
     {
         case Alignment.TOP_LEFT:
             component.Position = boundedPosition;
             break;
         case Alignment.TOP_CENTER:
             component.Position = boundedPosition + new Vector2((boundedSize.X - component.Size.X) / 2, 0);
             break;
         case Alignment.TOP_RIGHT:
             component.Position = boundedPosition + new Vector2(boundedSize.X - component.Size.X, 0);
             break;
         case Alignment.MIDDLE_LEFT:
             component.Position = boundedPosition + new Vector2(0, (boundedSize.Y - component.Size.Y) / 2);
             break;
         case Alignment.MIDDLE_CENTER:
             component.Position = boundedPosition + (boundedSize - component.Size) / 2;
             break;
         case Alignment.MIDDLE_RIGHT:
             component.Position = boundedPosition + new Vector2(boundedSize.X - component.Size.X, (boundedSize.Y - component.Size.Y) / 2);
             break;
         case Alignment.BOTTOM_LEFT:
             component.Position = boundedPosition + new Vector2(0, boundedSize.Y - component.Size.Y);
             break;
         case Alignment.BOTTOM_CENTER:
             component.Position = boundedPosition + new Vector2((boundedSize.X - component.Size.X) / 2, boundedSize.Y - component.Size.Y);
             break;
         case Alignment.BOTTOM_RIGHT:
             component.Position = boundedPosition + new Vector2(boundedSize.X - component.Size.X, boundedSize.Y - component.Size.Y);
             break;
     }
     components.Add(component);
 }

 public AlignmentCriterion(XmlJointType centerJoint, XmlJointType[] joints, float variance)
     : base(variance)
 {
     this.Alignment = Alignment.Point;
     this.CenterJoint = centerJoint;
     this.Joints = joints;
 }

    static IEnumerable<string> alignText(IEnumerable<string> lines, Alignment alignment, int width)
    {
        switch (alignment)
        {
            case Alignment.LEFT:
                return lines;

            case Alignment.RIGHT:
                return lines.Select(t => new String(' ', width - t.Length) + t);

            case Alignment.CENTER:
                return lines.Select(t => new String(' ', (width - t.Length) / 2) + t);

            case Alignment.JUSTIFY:
                return lines.Select(t =>
                {
                    var words = t.Split();
                    var spaceRequired = width - t.Length;
                    var spacing = spaceRequired / (words.Length - 1) + 1;
                    return string.Join(new String(' ', spacing), words);
                });

            default:
                throw new NotImplementedException();
        }
    }

        /// <summary>
        /// Finds the <see cref="Vector2"/> that represents the position to align an object
        /// to another object based on the given <see cref="Alignment"/>. The object being aligned
        /// to is assumed to be at {0,0).
        /// </summary>
        /// <param name="alignment">The <see cref="Alignment"/> describing how to align the target
        /// to the source.</param>
        /// <param name="sourceSize">The object that is being aligned to the target.</param>
        /// <param name="targetSize">The size of the object being aligned to.</param>
        /// <returns>The <see cref="Vector2"/> that represents the position to align an object
        /// to another object based on the given <paramref name="alignment"/>.</returns>
        /// <exception cref="ArgumentException"><paramref name="alignment"/> is not a defined value of the <see cref="Alignment"/>
        /// enum.</exception>
        public static Vector2 FindOffset(Alignment alignment, Vector2 sourceSize, Vector2 targetSize)
        {
            switch (alignment)
            {
                case Alignment.TopLeft:
                    return new Vector2(0, 0);

                case Alignment.TopRight:
                    return new Vector2(targetSize.X - sourceSize.X, 0);

                case Alignment.BottomLeft:
                    return new Vector2(0, targetSize.Y - sourceSize.Y);

                case Alignment.BottomRight:
                    return targetSize - sourceSize;

                case Alignment.Top:
                    return new Vector2(targetSize.X / 2f - sourceSize.X / 2f, 0);

                case Alignment.Bottom:
                    return new Vector2(targetSize.X / 2f - sourceSize.X / 2f, targetSize.Y - sourceSize.Y);

                case Alignment.Left:
                    return new Vector2(0, targetSize.Y / 2f - sourceSize.Y / 2f);

                case Alignment.Right:
                    return new Vector2(targetSize.X - sourceSize.X, targetSize.Y / 2f - sourceSize.Y / 2f);

                case Alignment.Center:
                    return targetSize / 2f - sourceSize / 2f;

                default:
                    throw new ArgumentException("Unknown alignment value specified", "alignment");
            }
        }

        public static void Draw(SpriteBatch spriteBatch,int number, Alignment aligment ,Rectangle rect, int scale = 1)
        {
            var numbers = number.ToString ().ToCharArray ().Select (n => n.ToString ());
            var images = numbers.Select (n => textures [n]).ToList ();
            var width = images.Sum (n => n.Width* scale) + ((images.Count - 1) * padding*scale);

            int x = rect.Left;
            if (aligment == Alignment.Right)
                x = rect.Right - width;
            else if (aligment == Alignment.Center)
                x = (rect.Right / 2) - (width / 2);
            int y = rect.Top;
            var drawRect = new Rectangle (x, y, 0, 0);

            images.ForEach (i => {
                drawRect.X =x;
                drawRect.Width = i.Width*scale;
                drawRect.Height = i.Height*scale;
                spriteBatch.Draw (
                    i,
                    null,
                    drawRect,
                    null,
                    null,
                    0,
                    new Vector2(scale),
                    Color.White,
                    SpriteEffects.None,
                    0.0f);

                spriteBatch.Draw(i,drawRect,Color.White);
                x += i.Width * scale + padding*scale;
            });
        }

 public void ApplyTextPositionAndAlignment(Position pos, Alignment alignment)
 {
     new TextBoxes(Shapes.Range(), SlideWidth, SlideHeight)
         .SetPosition(pos)
         .SetAlignment(alignment)
         .StartBoxing();
 }

 public TabWidgetModel(String id, Alignment alignment, String href)
 {
     this.Id = "tab" + id;
     this.Alignment = alignment;
     this.TabImage = "~/Content/img/tabs/" + id + ".png";
     this.Href = href;
 }

        //------------------------------------------------------------------------------
        // Function: ItemText
        // Author: nholmes
        // Summary: item constructor, allows user to specify text, vertical position,
        //          alignment and font as well as whether the text is selectable
        //------------------------------------------------------------------------------
        public ItemText(Menu menu, Game game, string text, int y, Alignment alignment, SpriteFont font, Color fontColor, int textOffset, bool selectable)
            : base(menu, game, textOffset)
        {
            // store the text font and font color to use
            this.text = text;
            this.font = font;
            this.fontColor = fontColor;

            // store whether this item is selectable
            this.selectable = selectable;

            // set the vy position of this text item
            position.Y = y;

            // calculate position based on alignment provided
            switch (alignment)
            {
                case Alignment.left:
                    position.X = 0;
                    break;
                case Alignment.centre:
                    position.X = (int)((menu.ItemArea.Width - font.MeasureString(text).X) / 2);
                    break;
                case Alignment.right:
                    position.X = (int)(menu.ItemArea.Width - font.MeasureString(text).X);
                    break;
                default:
                    position.X = 0;
                    break;
            }

            // store the size of this text item
            size = font.MeasureString(text);
        }

    protected void OnButtonClicked(object sender, EventArgs e)
    {
        if (sender == button1)
        {

            Gtk.FileChooserDialog dialog = new Gtk.FileChooserDialog ("Choose item...", this, FileChooserAction.Open, "Cancel",  ResponseType.Cancel, "Insert Spacer",  ResponseType.None, "Add", ResponseType.Accept);

            Gtk.Alignment align = new Alignment (1, 0, 0, 1);
            Gtk.Frame frame = new Frame ("Position");
            Gtk.HBox hbox = new HBox (false, 4);

            RadioButton rbRight;
            rbRight = new RadioButton ("Right");
            hbox.PackEnd(rbRight, false, false, 1);
            hbox.PackEnd(new RadioButton (rbRight, "Left"), false, false, 1);

            frame.Add (hbox);
            align.Add (frame);
            align.ShowAll ();
            dialog.ExtraWidget = align;

            ResponseType response = (ResponseType)dialog.Run ();
            if (response == ResponseType.Accept) {
                RunCommand ("defaults write com.apple.dock " + GetAlign(dialog.ExtraWidget) + " -array-add '<dict><key>tile-data</key><dict><key>file-data</key><dict><key>_CFURLString</key><string>" + dialog.Filename + "</string><key>_CFURLStringType</key><integer>0</integer></dict></dict></dict>' && /bin/sleep 1 &&/usr/bin/killall Dock");
            } else if (response == ResponseType.None) {
                RunCommand ("defaults write com.apple.dock " + GetAlign(dialog.ExtraWidget) + " -array-add '{tile-data={}; tile-type=\"spacer-tile\";}' && /bin/sleep 1 &&/usr/bin/killall Dock");
            }
            dialog.Destroy ();

        }
    }

        public WordPairViewModel(IWordAligner aligner, WordPair wordPair, bool areVarietiesInOrder)
        {
            _wordPair = wordPair;
            _areVarietiesInOrder = areVarietiesInOrder;
            _meaning = new MeaningViewModel(_wordPair.Word1.Meaning);
            _variety1 = new VarietyViewModel(_wordPair.VarietyPair.Variety1);
            _variety2 = new VarietyViewModel(_wordPair.VarietyPair.Variety2);

            IWordAlignerResult results = aligner.Compute(_wordPair);
            _alignment = results.GetAlignments().First();
            _prefixNode = new AlignedNodeViewModel(_alignment.Prefixes[0], _alignment.Prefixes[1]);
            var nodes = new List<AlignedNodeViewModel>();
            int i = 0;
            for (int column = 0; column < _alignment.ColumnCount; column++)
            {
                string note = null;
                if (i < _wordPair.AlignmentNotes.Count)
                    note = _wordPair.AlignmentNotes[i];
                nodes.Add(new AlignedNodeViewModel(column, _alignment[0, column], _alignment[1, column], note));
                i++;
            }
            _suffixNode = new AlignedNodeViewModel(_alignment.Suffixes[0], _alignment.Suffixes[1]);

            _alignedNodes = new ReadOnlyCollection<AlignedNodeViewModel>(nodes);

            _showInMultipleWordAlignmentCommand = new RelayCommand(ShowInMultipleWordAlignment);
        }

        int sightRange; // how far a character can see in squares

        #endregion Fields

        #region Constructors

        public Unit(int str, int mag, int dex, int agi, int def, int res, int spd,
            int strGrowth, int magGrowth, int dexGrowth, int agiGrowth, int defGrowth, int resGrowth, int spdGrowth,
            int strCap, int magCap, int dexCap, int agiCap, int defCap, int resCap, int spdCap,
            string name, Alignment ali, Role role)
        {
            attributes = new Dictionary<string, int>();

            attributes["strength"] = str;
            attributes["magic"] = mag;
            attributes["dexterity"] = dex;
            attributes["agility"] = agi;
            attributes["defense"] = def;
            attributes["resistance"] = res;
            attributes["speed"] = spd;

            caps["strength"] = strCap;
            caps["magic"] = magCap;
            caps["dexterity"] = dexCap;
            caps["agility"] = agiCap;
            caps["defense"] = defCap;
            caps["resistance"] = resCap;
            caps["speed"] = spdCap;

            growths["strength"] = strGrowth;
            growths["magic"] = magGrowth;
            growths["dexterity"] = dexGrowth;
            growths["agility"] = agiGrowth;
            growths["defense"] = defGrowth;
            growths["resistance"] = resGrowth;
            growths["speed"] = spdGrowth;

            alignment = ali;
        }

 public Button(Vector2 position, Texture2D texture, Texture2D textureDown, Alignment align, string text, SpriteFont font)
     : this(position,texture,textureDown)
 {
     this.font = font;
     this.text = text;
     this.align = align;
 }

 public ExcelContentFormat(string fontName, short fontSize, bool fontBold, Alignment align)
 {
     FontName = fontName;
     FontSize = fontSize;
     FontBold = fontBold;
     Align = align;
 }

        public static void DrawString(SpriteBatch spriteBatch, SpriteFont font, string text, Rectangle bounds, Alignment align, Color color)
        {
            Vector2 size = font.MeasureString(text);
            Vector2 pos = new Vector2(bounds.X + (bounds.Width >> 1), bounds.Y + (bounds.Height >> 1));
            Vector2 origin = size * 0.5f;

            switch (align)
            {
                case Alignment.Left:
                    origin.X += (bounds.Width - size.X) / 2;
                    break;
                case Alignment.Right:
                    origin.X -= (bounds.Width - size.X) / 2;
                    break;
                case Alignment.Top:
                    origin.Y += (bounds.Height - size.Y) / 2;
                    break;
                case Alignment.Bottom:
                    origin.Y -= (bounds.Height - size.Y) / 2;
                    break;
                case Alignment.Center:
                    break;
            }
            spriteBatch.DrawString(font, text, pos, color, 0, origin, 1, SpriteEffects.None, 0);
        }