/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
public override void Update(GameTime gameTime)
{
base.Update(gameTime);
this.UpdateDrawPositionByConfigAndParent();
this.UpdateDrawSizeByConfig();
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
public override void Update(GameTime gameTime)
{
// **** do the basic stuff
base.Update(gameTime);
if (Config.Changed)
{
this.RedrawSizeControl = true;
this.RedrawTitleControl = true;
this.UpdateDrawSourceRectangleByConfig();
this.UpdateDrawPositionByConfigAndParent();
this.UpdateDrawSizeByConfig();
Manager.ImageCompositor.Delete(this.CurrentTextureName);
this.CurrentTextureName = Manager.ImageCompositor.CreateRectangleTexture(
this.Name,
(int)State.Width,
(int)State.Height,
Theme.BorderWidth,
Theme.WindowFillColor,
Theme.BorderColor);
Config.ResetChanged();
}
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
public override void Update(GameTime gameTime)
{
// do the basic stuff first
base.Update(gameTime);
if (Config.Changed)
{
Config.ResetChanged();
this.SetVisibility();
}
// take the config position , and stick it in the current visual state
this.UpdateDrawPositionByConfigAndParent();
// the next code will be all about dragging
if (!this.Dragging)
{
return;
}
// find out the movement, compared to from the point where we started dragging
this.DragCurrent = this.PointRelative(Manager.InputManager.ReadMouseLocation());
var delta = DragCurrent - DragStart;
// Debug.WriteLine("Dragging is now at " + DragCurrentLocation + " with Delta " + delta);
// move the indicator the distance as the mouse moved.
this.IndicatorCurrent = this.IndicatorStartPosition + delta;
// Debug.WriteLine("'New Indicator location " + IndicatorCurrent);
// force the new location for the indicator in between the min and max button
var scrollIndicatorLocationX = IndicatorCurrent.X;
if (scrollIndicatorLocationX < MinButton.Config.PositionX + MinButton.Config.Width)
{
scrollIndicatorLocationX = MinButton.Config.PositionX + MinButton.Config.Width;
}
if (scrollIndicatorLocationX + ScrollIndicator.Config.Width > MaxButton.Config.PositionX)
{
scrollIndicatorLocationX = MaxButton.Config.PositionX - ScrollIndicator.Config.Width;
}
// convert the new Indicator location into a new value , and use that value
var scrollIndicatorDrawnCentre = scrollIndicatorLocationX + (ScrollIndicator.Config.Width / 2);
// get the minimum that the drawn center for the indicator can be set
var left = MinButton.Config.Width + (ScrollIndicator.Config.Width / 2);
// get the maximum that the drawn center for the indicator can be set
var right = Config.Width - MaxButton.Config.Width - (ScrollIndicator.Config.Width / 2);
var percentage = (scrollIndicatorDrawnCentre - left) / (right - left);
Debug.WriteLine((int)(percentage * 100) + "%");
var value = ConfigMin + ((ConfigMax - ConfigMin) * percentage);
Debug.WriteLine("message" + value);
this.ConfigValue = value;
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
public override void Update(GameTime gameTime)
{
base.Update(gameTime);
if (Config.Changed)
{
this.Text.Config.Visible = this.Config.Visible;
}
}
/// <summary>
/// Updates the scene-graph.
/// And finds the control that has focus.
/// </summary>
/// <param name="gameTime">The game time.</param>
public void Update(GameTime gameTime)
{
// update the scene graph
Debug.Assert(this.sceneGraph != null, "SceneGraph can never be null ! Fix this.");
this.sceneGraph.Update(gameTime);
// Calculate focus based on update index
this.FindFocusedControl();
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
public override void Update(GameTime gameTime)
{
base.Update(gameTime);
if (this.MustRedraw)
{
this.MustRedraw = false;
this.Redraw();
}
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
public override void Update(GameTime gameTime)
{
base.Update(gameTime);
this.UpdateDrawPositionByConfigAndParent();
this.UpdateDrawSizeByConfig();
this.UpdateDrawSourceRectangleByConfig();
if (this.CheckIsFocused())
{
}
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
public override void Update(GameTime gameTime)
{
base.Update(gameTime);
var pos = Manager.InputManager.ReadMouseLocation();
Config.PositionX = pos.X;
Config.PositionY = pos.Y;
State.DrawPosition = new DVector2(pos.X, pos.Y);
State.Offset = new DVector2(-Config.Width / 8, -Config.Height / 8);
State.Width = Config.Width / 4;
State.Height = Config.Height / 4;
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
public override void Update(GameTime gameTime)
{
if (Config.Changed)
{
this.Config.ResetChanged();
this.SetVisibility();
}
base.Update(gameTime);
this.UpdateDrawPositionByConfigAndParent();
if (!this.Dragging)
{
return;
}
// find out the movement, compared to from the point where we started dragging
this.DragCurrent = this.PointRelative(Manager.InputManager.ReadMouseLocation());
var delta = DragCurrent - DragStart;
//// Debug.WriteLine("Dragging is now at " + DragCurrentLocation + " with Delta " + delta);
// move the indicator the distance as the mouse moved.
this.IndicatorCurrent = this.IndicatorStartPosition + delta;
//// Debug.WriteLine("'New Indicator location " + IndicatorCurrent);
// force the new location for the indicator in between the min and max button
var indicatorLocationY = IndicatorCurrent.Y;
if (indicatorLocationY < MinButton.Config.PositionY + MinButton.Config.Height)
{
indicatorLocationY = MinButton.Config.PositionY + MinButton.Config.Height;
}
if (indicatorLocationY + ScrollIndicator.Config.Height > MaxButton.Config.PositionY)
{
indicatorLocationY = MaxButton.Config.PositionY - ScrollIndicator.Config.Height;
}
// convert the new Indicator location into a new value , and use that value
var scrollIndicatorDrawnCentre = indicatorLocationY + (ScrollIndicator.Config.Height / 2);
var top = MinButton.Config.Height + (ScrollIndicator.Config.Height / 2); // get the minimum that the drawn center for the indicator can be set
var bottom = Config.Height - MaxButton.Config.Height - (ScrollIndicator.Config.Height / 2); // get the maximum that the drawn center for the indicator can be set
var percentage = (scrollIndicatorDrawnCentre - top) / (bottom - top);
Debug.WriteLine((int)(percentage * 100) + "%");
var value = ConfigMin + ((ConfigMax - ConfigMin) * percentage);
Debug.WriteLine("message" + value);
this.ConfigValue = value;
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
public override void Update(GameTime gameTime)
{
base.Update(gameTime);
// use all current configuration towards current visual state
this.UpdateDrawPositionByConfigAndParent();
this.UpdateDrawSizeByConfig();
// if we have a change in config.. then take it to the text-box too
if (Config.Changed)
{
this.Text.Config.Visible = this.Config.Visible;
}
// if the mouse is over me
var hover = State.MouseHoveringOver;
if (hover)
{
// show that the mouse is over me
this.CurrentTextureName = this.TextureNameHover;
// read the mouse
var mousePress = Manager.InputManager.ReadLeftMousePressed();
if (mousePress == true && this.mouseClicked == false)
{
this.mouseClicked = true;
this.RaiseMouseClick();
}
var mouseReleased = Manager.InputManager.ReadLeftMouseReleased();
if (mouseReleased)
{
this.mouseClicked = false;
}
}
else
{
// show that the mouse is not over me
this.CurrentTextureName = this.TextureNameDefault;
}
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
public override void Update(GameTime gameTime)
{
// do the basic stuff first
base.Update(gameTime);
// get all the values from current configuration ,
// and create a visual state that can be drawn from it
this.UpdateDrawPositionByConfigAndParent();
this.UpdateDrawSizeByConfig();
this.UpdateDrawSourceRectangleByConfig();
// Update the title
this.TextLabel.ConfigText = this.ConfigText;
// take mouse input
var leftMousePressed = this.Manager.InputManager.ReadLeftMousePressed();
var leftMouseReleased = this.Manager.InputManager.ReadLeftMouseReleased();
// is the control visible ?
if (this.Config.Visible)
{
// Is mouse hovering over, and does the control have focus ?
if (this.State.MouseHoveringOver && this.CheckIsFocused())
{
// Is there a mouse press and the button is OFF ?
if (leftMousePressed && this.StateIsPressed == false)
{
this.StateIsPressed = true;
}
else if (leftMouseReleased && this.StateIsPressed == true)
{
this.StateIsPressed = false;
}
}
else if (leftMouseReleased)
{
this.StateIsPressed = false;
}
}
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
public override void Update(GameTime gameTime)
{
base.Update(gameTime);
if (this.mustredraw)
{
this.Calculate();
this.Populate();
this.CurrentTextureName = Manager.ImageCompositor.CreateRectangleTexture(this.Name + "-Background", (int)Config.Width, (int)Config.Height, 1, Theme.WindowFillColor, Theme.BorderColor);
this.mustredraw = false;
}
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
public override void Update(GameTime gameTime)
{
base.Update(gameTime);
this.colorBoxGradient.HSL = this.slider.HSL;
this.colorBoxSolid.HSL = this.colorBoxGradient.HSL;
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
public override void Update(GameTime gameTime)
{
base.Update(gameTime);
var pos = Manager.InputManager.ReadMouseLocation();
Config.PositionX = pos.X;
Config.PositionY = pos.Y;
State.DrawPosition = new DVector2(pos.X, pos.Y) + new DVector2(10, 0);
this.Label.ConfigText = this.GetParentTooltipText();
// check if parent has focus , if not: turn off drawing
if (this.Parent != null)
{
this.parentHasFocus = Parent.CheckIsFocused();
}
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
public override void Update(GameTime gameTime)
{
this.UpdateDrawPositionByConfigAndParent();
this.UpdateTextWhenNeeded();
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
public override void Update(GameTime gameTime)
{
// set draw-position
if (this.Parent == null)
{
return;
}
var newPosition = Parent.State.DrawPosition + new DVector2(Config.PositionX, Config.PositionY);
State.DrawPosition = newPosition;
}
public void UpdateKeyboardInput(GameTime gameTime)
{
#if DEBUG
if (gameTime == null)
{
throw new ArgumentNullException("gameTime", "Gametime is used here, can not be null.");
}
#endif
// read the keyboard state
this.keyboardState = Keyboard.GetState();
if (this.DebugMode)
{
var s = "Pressed keys";
foreach (var pressedKey in this.keyboardState.GetPressedKeys())
{
s = string.Format("{0} {1}", s, pressedKey);
}
Debug.WriteLine(s);
this.PressedKeys = s;
}
// Remove any keys from last pressed keys if time has expired, or if they're released
// Use a fast repeat keys list after the initial delay to input keys faster after being held down for a short time (windows textbox-like behavior)
// What it does is catch the last pressed keys, and if they are pressed long enough, convert them to fast-repeat keys
var culledKeys = new List<Keys>();
// list of keys that can be repeated again because they have timed out or key is lifted
foreach (var keyPair in this.lastPressedKeys)
{
if (this.keyboardState.IsKeyUp(keyPair.Key))
{
if (this.fastRepeatKeys.Contains(keyPair.Key))
{
this.fastRepeatKeys.Remove(keyPair.Key);
}
culledKeys.Add(keyPair.Key);
}
else
{
var keyTimeSpan = gameTime.TotalGameTime - keyPair.Value;
if (keyTimeSpan > this.keyRepeatTime && !this.fastRepeatKeys.Contains(keyPair.Key))
{
// Input key and then add to the fast list
culledKeys.Add(keyPair.Key);
this.fastRepeatKeys.Add(keyPair.Key);
}
else if (keyTimeSpan > this.fastKeyRepeatTime && this.fastRepeatKeys.Contains(keyPair.Key))
{
// Fast repeat
culledKeys.Add(keyPair.Key);
}
}
}
foreach (var key in culledKeys)
{
this.lastPressedKeys.Remove(key);
}
if (this.lastPressedKeys.Count != this.lastPressedKeysCount)
{
KeySwitches.ChangeText = true;
this.lastPressedKeysCount = this.lastPressedKeys.Count;
}
// ****************************************** do the commands ******************************************
// Select All (Ctrl+A)
if (KeyFilter.IsSelectAll(this.keyboardState))
{
this.RaiseSelectAll();
}
// Left Shift Control
if (KeyFilter.IsLeftShiftControl(this.keyboardState))
{
return;
}
// Backspace
if (KeyFilter.IsBackspace(this.keyboardState) && !this.lastPressedKeys.ContainsKey(Keys.Back))
{
this.RaiseKeyBackSpace();
this.lastPressedKeys.Add(Keys.Back, gameTime.TotalGameTime);
}
else if (KeyFilter.IsDelete(this.keyboardState) && !this.lastPressedKeys.ContainsKey(Keys.Delete))
{
// Delete
this.RaiseKeyDelete();
this.lastPressedKeys.Add(Keys.Delete, gameTime.TotalGameTime);
}
else if (KeyFilter.IsEnter(this.keyboardState) && this.Text.Length > 0 && !this.lastPressedKeys.ContainsKey(Keys.Enter))
{
// Enter
this.lastPressedKeys.Add(Keys.Enter, gameTime.TotalGameTime);
this.RaiseEnterPressed();
}
else
{
string textToInsert = null;
var keys = this.keyboardState.GetPressedKeys();
foreach (var key in keys)
{
if (this.lastPressedKeys.ContainsKey(key))
{
continue;
}
// if key is left or if key is right
if (KeyFilter.IsKeyLeft(key))
{
this.RaiseGoLeft();
}
else if (KeyFilter.IsKeyRight(key))
{
this.RaiseGoRight();
}
// if key is a number
if (KeyFilter.IsKeyNumber(key))
{
if (KeyFilter.IsKeyLeftShift(this.keyboardState))
{
textToInsert += key.ToString().Replace("D", string.Empty);
}
else
{
textToInsert += KeyFilter.ParseNumbersAsShifted(key);
}
}
else if (KeyFilter.IsKeyAlphabet(key))
{
// if key is a character from the alphabet
if (this.keyboardState.IsKeyUp(Keys.LeftShift) && this.keyboardState.IsKeyUp(Keys.CapsLock))
{
textToInsert += key.ToString().ToLower();
}
else
{
textToInsert += key;
}
}
else
{
// if the key is uppercase
if (KeyFilter.IsKeyLeftShift(this.keyboardState))
{
textToInsert += KeyFilter.ParseSpecialAsShifted(key);
}
else
{
textToInsert += KeyFilter.ParseSpecialAsNormal(key);
}
// if there is a spacebar
if (KeyFilter.IsKeySpacebar(key))
{
textToInsert += " ";
}
}
// if the key is grammatical
if (KeyFilter.IsKeyGrammatical(key))
{
textToInsert += key;
}
// If we have input a valid string
if (string.IsNullOrEmpty(textToInsert) == false)
{
this.RaiseInsertText(textToInsert);
}
this.lastPressedKeys.Add(key, gameTime.TotalGameTime);
}
}
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
public override void Update(GameTime gameTime)
{
base.Update(gameTime);
// calculate the draw position , by adding my parents pos + my pos + where the cursor should be
State.DrawPosition = Parent.State.DrawPosition + new DVector2(Config.PositionX, Config.PositionY);
// set cursor-blink on or off per time chunk
if (this.cursorFlashCounter >= CursorFlashTime)
{
this.ConfigBlinking = !this.ConfigBlinking;
this.cursorFlashCounter = 0;
if (this.ConfigDebugMode)
{
Debug.WriteLine("Blink : " + this.ConfigBlinking);
}
}
this.cursorFlashCounter++;
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
public override void Update(GameTime gameTime)
{
// retrieve the mouse pressed
var leftMousePressed = Manager.InputManager.ReadLeftMousePressed();
var leftMouseReleased = Manager.InputManager.ReadLeftMouseReleased();
// update the label
if (this.ConfigText != Label.ConfigText)
{
Label.ConfigText = this.ConfigText;
}
// update the visibility
if (this.Config.Changed)
{
this.Config.ResetChanged();
this.Label.Config.Visible = this.Config.Visible;
}
// is the control visible ?
if (Config.Visible)
{
// Is mouse hovering over, and does the control have focus ?
if (State.MouseHoveringOver && this.CheckIsFocused())
{
this.CurrentTextureName = this.TextureNameHover;
// Is there a mouse press and the button is OFF ?
if (leftMousePressed && this.ButtonState == ButtonState.Off)
{
this.RaiseMouseDownEvent(gameTime);
this.CurrentTextureName = this.textureNameLeftMouseDown;
this.ButtonState = ButtonState.On;
}
else if (leftMouseReleased && this.ButtonState == ButtonState.On)
{
this.ButtonState = ButtonState.Off;
Config.HoverColorsEnabled = true;
this.RaiseMouseUpEvent(gameTime);
this.RaiseMouseClickEvent(gameTime);
}
}
else
{
this.CurrentTextureName = this.TextureNameDefault;
// turn it off if the mouse hovers off it
if (this.ButtonState == ButtonState.On)
{
this.ButtonState = ButtonState.Off;
this.RaiseMouseUpEvent(gameTime);
}
}
}
base.Update(gameTime);
}
/// <summary>Tells that we start drawing , draws the scene-graph , and them stops the drawing.</summary>
/// <param name="gameTime">The game time.</param>
public void Draw(GameTime gameTime)
{
Debug.Assert(this.sceneGraph != null, "SceneGraph can never be null ! Fix this.");
ImageCompositor.BeginDraw();
this.sceneGraph.Draw(gameTime);
ImageCompositor.EndDraw();
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
public override void Update(GameTime gameTime)
{
// do the basic stuff first
base.Update(gameTime);
// ? huh no code to take config into visual-state ?
// get all the values from current configuration ,
// and create a visual state that can be drawn from it
this.UpdateDrawPositionByConfigAndParent();
this.UpdateDrawSizeByConfig();
this.UpdateDrawSourceRectangleByConfig();
// redraw the title if we must
this.RedrawTitleControl = true;
if (this.RedrawTitleControl == true)
{
this.RedrawTitleControl = false;
this.TitleBar.ConfigText = this.title;
this.TitleBar.Config.Width = this.Config.Width;
}
// redraw the sizer if we must
this.RedrawSizeControl = true;
if (this.RedrawSizeControl == true)
{
this.RedrawSizeControl = false;
this.SizingCorner.Config.PositionX = this.Config.Width - this.SizingCorner.Config.Width;
this.SizingCorner.Config.PositionY = this.Config.Height - this.SizingCorner.Config.Height;
}
// redraw the menu-bar if we must
this.RedrawMenuBarControl = true;
if (this.RedrawMenuBarControl == true)
{
this.RedrawMenuBarControl = false;
this.MenuBarHorizontal.WindowModus = true;
this.MenuBarHorizontal.Config.Width = this.Config.Width - 2;
this.MenuBarHorizontal.Config.PositionX = 1;
this.MenuBarHorizontal.Config.PositionY = this.TitleBar.Config.Height;
this.MenuBarHorizontal.Config.Height = this.Theme.ControlHeight;
}
// read dragging
this.ReadIfDragging();
this.ReadIfEndDragging();
if (this.Dragging)
{
// find out the movement, compared to from the point where we started dragging
if (this.Parent != null)
{
this.DragCurrentLocation = this.Parent.PointRelative(this.Manager.InputManager.ReadMouseLocation());
}
else
{
this.DragCurrentLocation = this.Manager.InputManager.ReadMouseLocation();
}
var delta = this.DragCurrentLocation - this.DragStartLocation;
var formCurrent = this.WindowDragStartLocation + delta;
this.Config.PositionX = formCurrent.X;
this.Config.PositionY = formCurrent.Y;
// this.Title = string.Format("{0},{1}", this.Config.PositionX, this.Config.PositionY);
this.UpdateDrawPositionByConfigAndParent();
}
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
public override void Update(GameTime gameTime)
{
base.Update(gameTime);
if (this.mustRedraw)
{
this.RedrawControl();
}
this.UpdateDrawPositionByConfigAndParent();
this.UpdateDrawSizeByConfig();
this.UpdateDrawSourceRectangleByConfig();
var leftMousePressed = Manager.InputManager.ReadLeftMousePressed();
var mouseLocation = Manager.InputManager.ReadMouseLocation();
if (this.CheckIsFocused() && leftMousePressed)
{
this.dragging = true;
}
if (this.dragging && leftMousePressed)
{
var relativeLocation = PointRelative(mouseLocation);
this.sliderValue = relativeLocation.Y / Config.Height;
this.RedrawControl();
this.TakeValue(this.sliderValue);
Debug.WriteLine("Rel " + relativeLocation + " val " + this.sliderValue);
}
if (this.dragging && leftMousePressed == false)
{
this.dragging = false;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="GameTimeEventArgs"/> class.
/// </summary>
/// <param name="gameTime">The game time.</param>
public GameTimeEventArgs(GameTime gameTime)
{
this.GameTime = gameTime;
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
public override void Update(GameTime gameTime)
{
base.Update(gameTime);
if (this.mustRevalidate)
{
this.Revalidate();
this.mustRevalidate = false;
}
if (this.mustRedraw)
{
this.Redraw();
this.mustRedraw = false;
}
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
public virtual void Update(GameTime gameTime)
{
if (this.mustReload)
{
this.mustReload = false;
this.UnloadContent();
this.IsLoaded = false;
}
this.UpdateDrawPositionByConfigAndParent();
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
public override void Update(GameTime gameTime)
{
base.Update(gameTime);
this.UpdateDrawPositionByConfigAndParent();
this.UpdateDrawSizeByConfig();
this.UpdateDrawSourceRectangleByConfig();
var leftMousePressed = Manager.InputManager.ReadLeftMousePressed();
var mouseLocation = Manager.InputManager.ReadMouseLocation();
// check the redraw FLAG !
if (this.redrawControlFlag == true)
{
this.RedrawControl();
this.redrawControlFlag = false;
}
if (this.CheckIsFocused() && leftMousePressed)
{
this.dragging = true;
}
if (this.dragging && leftMousePressed)
{
var relativeLocation = PointRelative(mouseLocation);
this.gradientValue = new DVector2(relativeLocation.X / Config.Width, relativeLocation.Y / Config.Height);
this.redrawControlFlag = true;
this.TakeValue(this.gradientValue);
Debug.WriteLine("Rel " + relativeLocation + " val " + this.gradientValue);
}
if (this.dragging && leftMousePressed == false)
{
this.dragging = false;
}
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
public override void Update(GameTime gameTime)
{
base.Update(gameTime);
if (this.doRebuild)
{
this.doRebuild = false;
this.textBoxUtility.ValidateAndRepair(this);
}
if (this.CheckIsFocused() && Config.Enabled && !this.ReadOnly)
{
// do keyboard
Manager.InputManager.UpdateKeyboardInput(gameTime);
this.ReadKeyboardMessages();
// show cursor
this.TextBoxCursor.ConfigShowCursor = true;
}
else
{
// hide cursor
this.TextBoxCursor.ConfigShowCursor = false;
}
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
public override void Update(GameTime gameTime)
{
base.Update(gameTime);
var leftPressed = this.Manager.InputManager.ReadLeftMousePressed();
if (leftPressed)
{
Debug.WriteLine("ComboBox pressed !");
}
////if (!_dropDownButton.State.MouseHoveringOver && !DropDownList.State.MouseHoveringOver && leftPressed && _listShown)
////{
//// _dropDownButton.Toggle(this, new ButtonStateEventArgs(ButtonState.Off));
//// OnToggleDropDown(this, new ButtonStateEventArgs(ButtonState.Off));
////}
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
public override void Update(GameTime gameTime)
{
base.Update(gameTime);
this.UpdateDrawPositionByConfigAndParent();
this.UpdateDrawSizeByConfig();
this.UpdateDrawSourceRectangleByConfig();
if (this.mustRedraw)
{
this.Redraw();
this.mustRedraw = false;
}
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
public override void Update(GameTime gameTime)
{
base.Update(gameTime);
this.UpdateDrawPositionByConfigAndParent();
this.UpdateDrawSizeByConfig();
if (this.mustRedrawBox)
{
this.RedrawBox();
}
if (this.ConfigDebug)
{
var rnd = new Random();
var r = rnd.Next(255);
var g = rnd.Next(255);
var b = rnd.Next(255);
var a = rnd.Next(255);
this.RGBA = new GUIColor((byte)r, (byte)g, (byte)b, (byte)a);
}
}
