/// <summary> /// Creates a UIButton element. /// </summary> /// <param name="game">XNA Game that owns this element.</param> /// <param name="controller">UIController associated with the state machine for this element.</param> /// <param name="positionX">Element position X-coordinate (relative or screen coordinate).</param> /// <param name="positionY">Element position Y-coordinate (relative or screen coordinate).</param> /// <param name="width">Desired width of the element in pixels.</param> /// <param name="height">Desired height of the element in pixels.</param> /// <param name="parent">The containing UIElement for this button (optional).</param> /// <remarks>If parent is not null (x,y) position coordinates are expected to be relative to the parent, /// otherwise they are interpreted as screen coordinates.</remarks> public UIButton(Game game, UIController controller, float positionX, float positionY, int width, int height, UIElement parent) : base(game, controller, null, new Vector2(positionX, positionY), width, height, parent) { buttonStateMachine = new ButtonStateMachine(controller, (int)width, (int)height); buttonStateMachine.Click += OnButtonClick; base.StateMachine = buttonStateMachine; StateMachine.Tag = this; }
/// <summary> /// Create a UIContainer with the specified parameters. /// </summary> /// <param name="game">Game to which the element belongs.</param> /// <param name="controller">UIController associated with this element.</param> /// <param name="texture"></param> /// <param name="position"></param> /// <param name="width"></param> /// <param name="height"></param> /// <param name="parent"></param> public UIContainer(Game game, UIController controller, string texture, Vector2? position, int width, int height, UIElement parent) : base(game, controller, texture, position, width, height, parent) { nullStateMachine = new NullStateMachine(controller, width, height); StateMachine = nullStateMachine; StateMachine.Tag = this; }
/// <summary> /// Initializes the <strong><see cref="UIElementStateMachine"/></strong> objects. /// </summary> /// <param name="controller">The controller for this <strong>UIElementStateMachine</strong> object.</param> /// <param name="numberOfPixelsInHorizontalAxis"> /// The number of pixels that this control occupies horizontally. /// For more information, see /// <strong><see cref="P:CoreInteractionFramework.UIElementStateMachine.NumberOfPixelsInHorizontalAxis">NumberOfPixelsInHorizontalAxis</see></strong>. /// </param> /// <param name="numberOfPixelsInVerticalAxis"> /// The number of pixels that this control occupies vertically. /// For more information, see /// <strong><see cref="P:CoreInteractionFramework.UIElementStateMachine.NumberOfPixelsInVerticalAxis">NumberOfPixelsInVerticalAxis</see></strong>. /// </param> protected UIElementStateMachine(UIController controller, int numberOfPixelsInHorizontalAxis, int numberOfPixelsInVerticalAxis) { if (controller == null) throw SurfaceCoreFrameworkExceptions.ArgumentNullException("controller"); this.numberOfPixelsInHorizontalAxis = numberOfPixelsInHorizontalAxis; this.numberOfPixelsInVerticalAxis = numberOfPixelsInVerticalAxis; this.controller = controller; this.controller.ResetState += new EventHandler(OnResetState); }
/// <summary> /// A parameterized public constructor for the MeshCanvas class. /// </summary> /// <param name="game">The game that to which this UIElement belongs.</param> /// <param name="controller">The UIController that will route touch events this UIElement's state machine.</param> /// <param name="texture">The name of a file containing the texture to use for this UIElement.</param> /// <param name="width">The desired width of this UIElement in pixels.</param> /// <param name="height">The desired height of this UIElemnt in pixels.</param> public MeshCanvas(Game game, UIController controller, string texture, int width, int height) : base(game, controller, texture, null, width, height, null) { IgnoreTextureSize = true; viewPort = new ScrollViewerStateMachine(controller, width, height); // Add a little elasticity so it's apparent when boundary of // the ScrollViewer is reached. viewPort.HorizontalElasticity = 0.03f; viewPort.VerticalElasticity = 0.03f; StateMachine = viewPort; StateMachine.Tag = this; viewPort.TouchDown += OnContactDown; }
/// <summary> /// Creates a ScrollBar HUD element with the specified parameters. /// </summary> public ScrollBar(Game game, UIController controller, Vector2? position, float length, ListBoxStateMachine listBox, ScrollBarStateMachine scrollBar, UIElement parent) : base(game, controller, null, position, scrollBar.NumberOfPixelsInHorizontalAxis, scrollBar.NumberOfPixelsInVerticalAxis, parent) { if (scrollBar.Orientation != Orientation.Horizontal) { throw new InvalidOperationException(Properties.Resources.ScrollBarStateMachineShouldBeHorizontal); } this.listBox = listBox; StateMachine = scrollBar; StateMachine.Tag = this; StateMachine.MaximumFlickVelocity = MaximumFlickVelocity; scrollBarLength = length; }
/// <summary> /// Creates an initialized instance of a /// <strong><see cref="ScrollBarStateMachine"/></strong> object with the specified parameters. /// </summary> /// <param name="controller">The <strong>UIController</strong> object that dispatches hit testing.</param> /// <param name="numberOfPixelsInHorizontalAxis"> /// The number of pixels that this control occupies horizontally. /// For more information, see /// <strong><see cref="P:CoreInteractionFramework.UIElementStateMachine.NumberOfPixelsInHorizontalAxis">NumberOfPixelsInHorizontalAxis</see></strong>. /// </param> /// <param name="numberOfPixelsInVerticalAxis"> /// The number of pixels that this control occupies vertically. /// For more information, see /// <strong><see cref="P:CoreInteractionFramework.UIElementStateMachine.NumberOfPixelsInVerticalAxis">NumberOfPixelsInVerticalAxis</see></strong>. /// </param> public ScrollBarStateMachine(UIController controller, int numberOfPixelsInHorizontalAxis, int numberOfPixelsInVerticalAxis) : base(controller, numberOfPixelsInHorizontalAxis, numberOfPixelsInVerticalAxis) { stopwatch = Stopwatch.StartNew(); }
/// <summary> /// Private contructor invoked by overloaded base contructors to build the UIElement. /// </summary> /// <param name="game"></param> /// <param name="controller"></param> /// <param name="textureFile"></param> /// <param name="texture"></param> /// <param name="position">Position of the UIElement (relative or screen coordinates)</param> /// <param name="width"></param> /// <param name="height"></param> /// <param name="parent"></param> private UIElement(Game game, UIController controller, string textureFile, Texture2D texture, Vector2? position, int width, int height, UIElement parent) : base(game) { // Should only set one or the other, not both. Debug.Assert(textureFile == null || texture == null); this.controller = controller; this.textureSourceFile = textureFile; this.texture = texture; this.width = width; this.height = height; this.parent = parent; instanceCount++; Name = "UIElement " + instanceCount.ToString(CultureInfo.InvariantCulture); if (parent != null) { // Inherit some properties from the parent (containing) UIElement. currentOrientation = parent.currentOrientation; screenTransform = parent.ScreenTransform; spriteBlendState = parent.SpriteBlendState; spriteSortMode = parent.spriteSortMode; // Draw children in front of parents. layerDepth = parent.layerDepth * 0.9f; // Position is a relative to parent's Center. if (position != null) { relativePosition = Vector2.Clamp(position.Value, new Vector2(-0.5f, -0.5f), new Vector2(0.5f, 0.5f)); Vector2 center = parent.Center; float x = center.X + relativePosition.X * parent.Width; float y = center.Y + relativePosition.Y * parent.Height; Center = new Vector2(x, y); } // Add this to parent's liest of children. parent.AddChild(this); } else { // Position is in screen coordinates. if (position != null) { Center = position.Value; } } }
/// <summary> /// Base constructor for UIElement. Only derived classes may call the base constructor. /// </summary> /// <param name="game"></param> /// <param name="controller"></param> /// <param name="position"></param> /// <param name="width"></param> /// <param name="height"></param> /// <param name="parent"></param> protected UIElement(Game game, UIController controller, Vector2? position, int width, int height, UIElement parent) : this(game, controller, null, null, position, width, height, parent) { // Empty. }
//==========================================================// /// <summary> /// Constructor. /// </summary> /// <param name="passedColor">The color of the item.</param> /// <param name="passedParent">The item's parent XnaScatterView.</param> public XnaScatterViewItem(UIController controller, string contentImage, XnaScatterView passedParent) :base(controller, 1, 1 ) { textureSourceFile = contentImage; parent = passedParent; }
/// <summary> /// Creates a TextilesStatemachine. /// </summary> /// <param name="controller">The UIController for this state machine.</param> /// <param name="textiles">The UIElement encapsulating this state machine.</param> public TextilesStateMachine(UIController controller, Textiles textiles) : base(controller, 0, 0) { this.textiles = textiles; }
/// <summary> /// Creates a Listbox UIElement that may or may not have a parent UIElement. /// </summary> /// <param name="game">XNA Game that contains this ListBox</param> /// <param name="contoller">UIController to associate with the ListBoxStateMachine.</param> /// <param name="x">X-coordinate of elements position (relative or screen).</param> /// <param name="y">Y-coordinate of elements position (relative or screen).</param> /// <param name="width">Width of the ListBox in pixels.</param> /// <param name="height">Height of the ListBox in pixels.</param> /// <param name="parent">UIElement that contains the Listbox.</param> /// <param name="textiles">Textiles UIElement controlled by this list box</param> public ListBox(Game game, UIController contoller, float x, float y, int width, int height, UIElement parent, Textiles textiles) : base(game, contoller, new Vector2(x, y), width, height, parent) { listBoxStateMachine = new ListBoxStateMachine(Controller, (int)width, (int)height) { SelectionMode = SelectionMode.Single, Orientation = Orientation.Horizontal, HorizontalElasticity = 0.0f, VerticalElasticity = 0.0f, HorizontalViewportSize = 1f, VerticalViewportSize = 1f, }; StateMachine = listBoxStateMachine; StateMachine.Tag = this; this.textiles = textiles; listBoxStateMachine.ItemStateChanged += OnItemStateChanged; iconScale = new Vector2((float)iconWidth / itemWidth, (float)iconHeight / itemHeight); UIContainer container = parent as UIContainer; if (container != null) { // Create the scrollbar and position it below the listbox. int offset = Convert.ToInt32(Top - parent.Top + Height); Vector2 position = UIElement.CenterHorizontal(offset, scrollBarBackgroundHeight, container); ScrollBar = new ScrollBar(parent, position, width, listBoxStateMachine, listBoxStateMachine.HorizontalScrollBarStateMachine); // Create the Maximze/Minimize button and position it above the listbox. offset = Convert.ToInt32(Top - parent.Top - buttonHeight); position = UIElement.CenterHorizontal(offset, (float) buttonHeight, Parent); minMaxButton = new Button(parent, position, buttonWidth, buttonHeight); minMaxButton.Name = "button"; minMaxButton.AutoScaleTexture = false; } else { throw new InvalidOperationException(Properties.Resources.ListBoxShouldBeInUIContainer); } }
/// <summary> /// Creates an initialized instance of a /// <strong><see cref="T:CoreInteractionFramework.ButtonStateMachine" /></strong> object. /// </summary> /// <param name="controller">A <strong>UIController</strong> object with buffered contacts and successfully /// hit testing contacts.</param> /// <param name="numberOfPixelsInHorizontalAxis"> /// The number of pixels that this control occupies horizontally. /// For more information, see /// <strong><see cref="P:CoreInteractionFramework.UIElementStateMachine.NumberOfPixelsInHorizontalAxis"> /// NumberOfPixelsInHorizontalAxis</see></strong>. /// </param> /// <param name="numberOfPixelsInVerticalAxis"> /// The number of pixels that this control occupies vertically. /// For more information, see <strong><see cref="P:CoreInteractionFramework.UIElementStateMachine.NumberOfPixelsInVerticalAxis"> /// NumberOfPixelsInVerticalAxis</see></strong>. /// </param> /// <remarks>The <strong><see cref="T:CoreInteractionFramework.UIElementStateMachine" /></strong> base /// class takes the same <strong>UIController</strong> object and pixel parameters as the /// <strong>ButtonStateMachine</strong> object. /// </remarks> public ButtonStateMachine(UIController controller, int numberOfPixelsInHorizontalAxis, int numberOfPixelsInVerticalAxis) : base(controller, numberOfPixelsInHorizontalAxis, numberOfPixelsInVerticalAxis) { }
/// <summary> /// Creates a new <strong><see cref="ScrollViewerStateMachine"/></strong> instance /// with the specified parameters. /// </summary> /// <param name="controller">The <strong>UIController</strong> object that dispatches hit testing.</param> /// <param name="numberOfPixelsInHorizontalAxis"> /// The number of pixels that this control occupies horizontally. /// For more information, see /// <strong><see cref="P:CoreInteractionFramework.UIElementStateMachine.NumberOfPixelsInHorizontalAxis">NumberOfPixelsInHorizontalAxis</see></strong>. /// </param> /// <param name="numberOfPixelsInVerticalAxis"> /// The number of pixels that this control occupies vertically. /// For more information, see /// <strong><see cref="P:CoreInteractionFramework.UIElementStateMachine.NumberOfPixelsInVerticalAxis">NumberOfPixelsInVerticalAxis</see></strong>. /// </param> public ScrollViewerStateMachine(UIController controller, int numberOfPixelsInHorizontalAxis, int numberOfPixelsInVerticalAxis) : base(controller, numberOfPixelsInHorizontalAxis, numberOfPixelsInVerticalAxis) { scrollAdapter = new ScrollAdapter(controller, this); scrollAdapter.ViewportChanged += new EventHandler(OnViewportChanged); }
// // The following virtual methods from the Game class have been overridden: // // Initialize, LoadContent, Update, Draw, UnLoadContent // // The following methods are also available for override, but are not overridden // at this time: // // BeginRun, BeginDraw, EndDraw, EndRun, OnActivated, OnDeactivated, OnExiting // /// <summary> /// Allows the app to perform any initialization it needs to before starting to run. /// This is where it can query for any required services and load any non-graphic /// related content. Calling base.Initialize will enumerate through any components /// and initialize them as well. /// </summary> protected override void Initialize() { IsMouseVisible = true; // easier for debugging not to "lose" mouse SetWindowOnSurface(); InitializeSurfaceInput(); // Make sure things are aware of the window size. UpdateViewportSettings(); Window.ClientSizeChanged += OnClientSizeChanged; // Create the UIController for the StateMachines. controller = new UIController(touchTarget, HitTestCallback); PopulateGame(); // Initialize UIElements which are not in Game.Components // and are not children of another UIElement. textiles.Initialize(); // Subscribe to surface window availability events ApplicationServices.WindowInteractive += OnWindowInteractive; ApplicationServices.WindowNoninteractive += OnWindowNoninteractive; ApplicationServices.WindowUnavailable += OnWindowUnavailable; base.Initialize(); }
/// <summary> /// Creates a NullStateMachine. /// </summary> /// <param name="controller">The UIcontroller assocatiated with this state machine.</param> /// <param name="width">Number of pixels in horizontal axis.</param> /// <param name="height">Number of pixels in vertical axis</param> public NullStateMachine(UIController controller, int width, int height) : base(controller, width, height) { // Empty. }
/// <summary> /// Creates a Textiles UIElement. /// </summary> /// <param name="game"></param> /// <param name="controller"></param> /// <param name="touchTarget"></param> public Textiles(Game game, UIController controller) : base(game, controller, null, null, 0, 0, null) { textileComponent = new TextileManipulationComponent(game); game.Components.Add(textileComponent); StateMachine = new TextilesStateMachine(controller, this) { Tag = this }; }
/// <summary> /// Creates a new ScrollViewerStateMachine. /// </summary> /// <param name="controller">The UIController which dispatches hit testing.</param> /// <param name="elementToScroll">The element which is scrolling.</param> public ScrollAdapter(UIController controller, UIElementStateMachine elementToScroll) { // By default scrolling should be allowed in both directions. Orientation = Orientation.Both; this.elementToScroll = elementToScroll; // Handle the ScrollBars for this ScrollViewer. horizontalScrollBarStateMachine = new ScrollBarStateMachine(controller, elementToScroll.NumberOfPixelsInHorizontalAxis, 0); horizontalScrollBarStateMachine.Orientation = Orientation.Horizontal; verticalScrollBarStateMachine = new ScrollBarStateMachine(controller, 0, elementToScroll.NumberOfPixelsInVerticalAxis); verticalScrollBarStateMachine.Orientation = Orientation.Vertical; // Default to 1 (full size). HorizontalViewportSize = 1; VerticalViewportSize = 1; horizontalScrollBarStateMachine.ValueChanged += OnHorizontalScrollBarStateMachineValueChanged; horizontalScrollBarStateMachine.ThumbChanged += OnHorizontalScrollBarStateMachineThumbChanged; horizontalScrollBarStateMachine.NumberOfPixelsInHorizontalAxisChanged += HorizontalScrollBarStateMachineNumberOfPixelsInHorizontalAxisChanged; verticalScrollBarStateMachine.ValueChanged += OnVerticalScrollBarStateMachineValueChanged; verticalScrollBarStateMachine.ThumbChanged += OnVerticalScrollBarStateMachineThumbChanged; verticalScrollBarStateMachine.NumberOfPixelsInVerticalAxisChanged += VerticalScrollBarStateMachineNumberOfPixelsInVerticalAxisChanged; // Manipulations should only cause translations, not rotations or scaling. manipulationProcessor = new ManipulationProcessor2D(Manipulations2D.TranslateX | Manipulations2D.TranslateY); manipulationProcessor.Completed += OnAffine2DManipulationCompleted; stopwatch = Stopwatch.StartNew(); }
/// <summary> /// Allows the app to perform any initialization it needs to before starting to run. /// This is where it can query for any required services and load any non-graphic /// related content. Calling base.Initialize will enumerate through any components /// and initialize them as well. /// </summary> protected override void Initialize() { IsMouseVisible = true; // easier for debugging not to "lose" mouse SetWindowOnSurface(); InitializeSurfaceInput(); controller = new UIController(touchTarget, HitTestCallback); // Set the application's orientation based on the orientation at launch currentOrientation = ApplicationServices.InitialOrientation; // Subscribe to surface window availability events ApplicationServices.WindowInteractive += OnWindowInteractive; ApplicationServices.WindowNoninteractive += OnWindowNoninteractive; ApplicationServices.WindowUnavailable += OnWindowUnavailable; // Create a rotation matrix to orient the screen so it is viewed correctly, // when the user orientation is 180 degress different. Matrix rotation = Matrix.CreateRotationZ(MathHelper.ToRadians(180)); Matrix translation = Matrix.CreateTranslation(graphics.GraphicsDevice.Viewport.Width, graphics.GraphicsDevice.Viewport.Height, 0); Matrix inverted = rotation * translation; PopulateGameWorld(); if (currentOrientation == UserOrientation.Top) { screenTransform = inverted; } scatterView.Transform = screenTransform; base.Initialize(); }
/// <summary> /// Creates an initialized instance of a /// <strong><see cref="ListBoxStateMachine"/></strong> object with the specified parameters. /// </summary> /// <param name="controller">The <strong>UIController</strong> object that dispatches hit testing.</param> /// <param name="numberOfPixelsInHorizontalAxis"> /// The number of pixels that this control occupies horizontally. /// For more information, see <strong><see cref="P:CoreInteractionFramework.UIElementStateMachine.NumberOfPixelsInHorizontalAxis"> /// NumberOfPixelsInHorizontalAxis</see></strong>. /// </param> /// <param name="numberOfPixelsInVerticalAxis"> /// The number of pixels that this control occupies vertically. /// For more information, see <strong><see cref="P:CoreInteractionFramework.UIElementStateMachine.NumberOfPixelsInVerticalAxis"> /// NumberOfPixelsInVerticalAxis</see></strong>. /// </param> public ListBoxStateMachine(UIController controller, int numberOfPixelsInHorizontalAxis, int numberOfPixelsInVerticalAxis) : base(controller, numberOfPixelsInHorizontalAxis, numberOfPixelsInVerticalAxis) { scrollAdapter = new ScrollAdapter(controller, this); scrollAdapter.ViewportChanged += OnScrollAdapterViewportChanged; ListBoxMode = ListBoxMode.Selection; // Create container objects. items = new ListBoxStateMachineItemCollection(this); selectedItems = new ListBoxStateMachineItemCollection(this); contactTargetEventContactIds = new Dictionary<int, ContactTargetEvent>(); capturedItemContactIds = new Dictionary<int, ListBoxStateMachineItem>(); items.ListBoxItemRemoved += OnListBoxItemRemoved; items.ListBoxItemAdded += OnListBoxItemAdded; selectedItems.ListBoxItemAdded += OnSelectedItemsListBoxItemAdded; selectedItems.ListBoxItemRemoved += OnSelectedItemsListBoxItemRemoved; }
//==========================================================// /// <summary> /// Constructor. Sets allowed manipulations and creates the manipulation processor. /// </summary> public XnaScatterView(UIController controller, string backgroundImage, int top, int bottom, int left, int right) : base(controller, right - left, bottom - top) { textureSourceFile = backgroundImage; transformedCenter = new Vector2(0, 0); topBoundary = top; bottomBoundary = bottom; leftBoundary = left; rightBoundary = right; Manipulations2D supportedManipulations = Manipulations2D.TranslateX | Manipulations2D.TranslateY | Manipulations2D.Scale; manipulationProcessor = new ManipulationProcessor2D(supportedManipulations); manipulationProcessor.Delta += OnAffine2DDelta; }