public DisplayManager(PresentationPanel presentationPanel, IGL gl, GLManager glManager)
{
GL = gl;
this.presentationPanel = presentationPanel;
GraphicsControl = this.presentationPanel.GraphicsControl;
CR_GraphicsControl = glManager.GetContextForGraphicsControl(GraphicsControl);
_glManager = glManager;
//it's sort of important for these to be initialized to something nonzero
currEmuWidth = currEmuHeight = 1;
if (GL is BizHawk.Bizware.BizwareGL.Drivers.OpenTK.IGL_TK)
Renderer = new GuiRenderer(GL);
else if (GL is BizHawk.Bizware.BizwareGL.Drivers.SlimDX.IGL_SlimDX9)
Renderer = new GuiRenderer(GL);
else
Renderer = new GDIPlusGuiRenderer((BizHawk.Bizware.BizwareGL.Drivers.GdiPlus.IGL_GdiPlus)GL);
VideoTextureFrugalizer = new BizHawk.Client.EmuHawk.TextureFrugalizer(GL);
ShaderChainFrugalizers = new RenderTargetFrugalizer[16]; //hacky hardcoded limit.. need some other way to manage these
for (int i = 0; i < 16; i++)
{
ShaderChainFrugalizers[i] = new RenderTargetFrugalizer(GL);
}
RefreshUserShader();
}
public GuiManager(Game game, IServiceProvider serviceProvider, InputManager inputManager, IGuiRenderer guiRenderer, IOptionsProvider optionsProvider)
{
Game = game;
ServiceProvider = serviceProvider;
InputManager = inputManager;
ScaledResolution = new GuiScaledResolution(game)
{
GuiScale = optionsProvider.AlexOptions.VideoOptions.GuiScale
};
ScaledResolution.ScaleChanged += ScaledResolutionOnScaleChanged;
FocusManager = new GuiFocusHelper(this, InputManager, game.GraphicsDevice);
GuiRenderer = guiRenderer;
guiRenderer.ScaledResolution = ScaledResolution;
SpriteBatch = new SpriteBatch(Game.GraphicsDevice);
GuiSpriteBatch = new GuiSpriteBatch(guiRenderer, Game.GraphicsDevice, SpriteBatch);
GuiRenderArgs = new GuiRenderArgs(Game.GraphicsDevice, SpriteBatch, ScaledResolution, GuiRenderer, new GameTime());
// DebugHelper = new GuiDebugHelper(this);
optionsProvider.AlexOptions.VideoOptions.GuiScale.Bind((value, newValue) =>
{
ScaledResolution.GuiScale = newValue;
});
}
protected override void Render(IGuiRenderer guiRenderer)
{
if (!string.IsNullOrEmpty(ImageName))
{
guiRenderer.Image(ImageName, Size, margin: Margin);
var imageSize = guiRenderer.GetImageSize(ImageName);
var goodImageSize = IsGoodImageSize(imageSize);
var textColour = goodImageSize ? Colours.White : Colours.Red;
if (!goodImageSize)
{
guiRenderer.Line(new Vector2(0, 0), new Vector2(Size.X, Size.Y), Colours.Red);
guiRenderer.Line(new Vector2(1, 1), new Vector2(Size.X + 1, Size.Y + 1), Colours.Red);
guiRenderer.Line(new Vector2(Size.X, 0), new Vector2(0, Size.Y), Colours.Red);
TooltipText = string.Format("Image is not a valid size ({0}, {1})", imageSize.X, imageSize.Y);
}
else
{
TooltipText = string.Format("{2} ({0}, {1})", imageSize.X, imageSize.Y, ImageName);
}
guiRenderer.Text("Arial", 12, FriendlyName, textColour, new Vector2(0, Size.Y));
}
base.Render(guiRenderer);
}
protected override void OnInit(IGuiRenderer renderer)
{
base.OnInit(renderer);
InitMiniMap(Alex.Instance.GraphicsDevice);
Background.Texture = (TextureSlice2D)_mapTexture;
}
public override void Draw(IGuiContext context, IGuiRenderer renderer, float deltaSeconds)
{
base.Draw(context, renderer, deltaSeconds);
ScrollIntoView(context);
DrawItemList(context, renderer);
}
protected override void OnInit(IGuiRenderer renderer)
{
RenderTarget = new RenderTarget2D(Alex.Instance.GraphicsDevice, 32, 32, false, SurfaceFormat.Color, DepthFormat.None);
base.OnInit(renderer);
}
public GuiSystem(ViewportAdapter viewportAdapter, IGuiRenderer renderer)
{
_viewportAdapter = viewportAdapter;
_renderer = renderer;
_mouseListener = new MouseListener(viewportAdapter);
_mouseListener.MouseMoved += (s, e) => OnPointerMoved(GuiPointerEventArgs.FromMouseArgs(e));
_mouseListener.MouseDown += (s, e) => OnPointerDown(GuiPointerEventArgs.FromMouseArgs(e));
_mouseListener.MouseUp += (s, e) => OnPointerUp(GuiPointerEventArgs.FromMouseArgs(e));
_mouseListener.MouseWheelMoved += (s, e) => _focusedControl?.OnScrolled(e.ScrollWheelDelta);
_touchListener = new TouchListener(viewportAdapter);
_touchListener.TouchStarted += (s, e) => OnPointerDown(GuiPointerEventArgs.FromTouchArgs(e));
_touchListener.TouchMoved += (s, e) => OnPointerMoved(GuiPointerEventArgs.FromTouchArgs(e));
_touchListener.TouchEnded += (s, e) => OnPointerUp(GuiPointerEventArgs.FromTouchArgs(e));
_keyboardListener = new KeyboardListener();
_keyboardListener.KeyTyped += (sender, args) => _focusedControl?.OnKeyTyped(this, args);
_keyboardListener.KeyPressed += (sender, args) => _focusedControl?.OnKeyPressed(this, args);
Screens = new GuiScreenCollection(this)
{
ItemAdded = InitializeScreen
};
}
protected override void OnInit(IGuiRenderer renderer)
{
base.OnInit(renderer);
DisabledBackground.TryResolveTexture(renderer);
HighlightedBackground.TryResolveTexture(renderer);
FocusedBackground.TryResolveTexture(renderer);
}
protected override void OnInit(IGuiRenderer renderer)
{
Alex.Services.GetRequiredService <IEventDispatcher>().RegisterEvents(_tipPopupComponent);
_bottomContainer.AddChild(_tipPopupComponent);
_healthContainer.AddChild(_healthComponent);
_healthContainer.AddChild(_hungerComponent);
_healthAndHotbar.AddChild(_healthContainer);
_healthAndHotbar.AddChild(_hotbar);
_bottomContainer.AddRow(
container =>
{
// container.AutoSizeMode = AutoSizeMode.GrowAndShrink;
container.Anchor = Alignment.BottomCenter;
container.ChildAnchor = Alignment.FillCenter;
container.AddChild(_healthAndHotbar);
//container.AddChild(_hotbar);
});
AddChild(_bottomContainer);
AddChild(Chat);
//AddChild(_hotbar);
AddChild(new GuiCrosshair());
AddChild(Title);
AddChild(Scoreboard);
}
protected virtual void DrawForeground(IGuiContext context, IGuiRenderer renderer, float deltaSeconds, TextInfo textInfo)
{
if (!string.IsNullOrWhiteSpace(textInfo.Text))
{
renderer.DrawText(textInfo.Font, textInfo.Text, textInfo.Position + TextOffset, textInfo.Color, textInfo.ClippingRectangle);
}
}
protected override void OnInit(IGuiRenderer renderer)
{
AddChild(_hotbar);
AddChild(new GuiCrosshair());
AddChild(Chat);
AddChild(Title);
}
/// <summary>
/// Draws the map tiles
/// </summary>
/// <param name="renderer">gui renderer</param>
private void DrawMapTiles(IGuiRenderer renderer)
{
MapPosition centerPosition = this.viewModel.MapCenterPosition;
for (int screenX = 0; screenX < this.sizeInTiles.X; screenX++)
{
for (int screenY = 0; screenY < this.sizeInTiles.Y; screenY++)
{
int mapX = screenX + centerPosition.X - (this.sizeInTiles.X / 2);
int mapY = screenY + centerPosition.Y - (this.sizeInTiles.Y / 2);
var position = new MapPosition(mapX, mapY);
if (!this.viewModel.IsTileVisible(position))
{
continue;
}
TileInfo tileInfo = this.viewModel.GetTileInfo(position);
if (tileInfo != null)
{
this.DrawTile(renderer, tileInfo.TileIndex, screenX, screenY);
}
}
}
}
protected override void DrawBackground(IGuiRenderer renderer, float deltaSeconds)
{
var boundingRectangle = BoundingRectangle;
var checkRectangle = new Rectangle(boundingRectangle.X, boundingRectangle.Y, BackgroundRegion.Width, BackgroundRegion.Height);
renderer.DrawRegion(BackgroundRegion, checkRectangle, Color);
}
// Renders a box
internal static void renderBox(Control ctrl, ref Color c, ref Game game)
{
if(renderer== null)
renderer= new BasicGuiRenderer();
renderer.renderBox(ref ctrl, ref c, ref game);
}
protected override void DrawText(IGuiRenderer renderer, float deltaSeconds, TextInfo textInfo)
{
textInfo.Position = BoundingRectangle.Location.ToVector2() +
new Vector2(BackgroundRegion.Width + 5, BackgroundRegion.Height * 0.5f - textInfo.Font.LineHeight * 0.5f);
base.DrawText(renderer, deltaSeconds, textInfo);
}
public void RenderString(IGuiRenderer renderer, float x, float y, string str)
{
int len = str.Length;
for (int i = 0; i < len; i++)
{
Cyotek.Drawing.BitmapFont.Character c;
if (!FontInfo.Characters.TryGetValue(str[i], out c))
c = FontInfo.Characters[unchecked((char)-1)];
//calculate texcoords (we shouldve already had this cached, but im speedcoding now)
Texture2d tex = TexturePages[c.TexturePage];
float w = tex.Width;
float h = tex.Height;
float u0 = c.Bounds.Left / w;
float v0 = c.Bounds.Top / h;
float u1 = c.Bounds.Right / w;
float v1 = c.Bounds.Bottom / h;
float gx = x + c.Offset.X;
float gy = y + c.Offset.Y;
renderer.DrawSubrect(tex, gx, gy, c.Bounds.Width, c.Bounds.Height, u0, v0, u1, v1);
x += c.XAdvance;
}
}
public void RenderString(IGuiRenderer renderer, float x, float y, string str)
{
int len = str.Length;
for (int i = 0; i < len; i++)
{
Cyotek.Drawing.BitmapFont.Character c;
if (!FontInfo.Characters.TryGetValue(str[i], out c))
{
c = FontInfo.Characters[unchecked ((char)-1)];
}
//calculate texcoords (we shouldve already had this cached, but im speedcoding now)
Texture2d tex = TexturePages[c.TexturePage];
float w = tex.Width;
float h = tex.Height;
float u0 = c.Bounds.Left / w;
float v0 = c.Bounds.Top / h;
float u1 = c.Bounds.Right / w;
float v1 = c.Bounds.Bottom / h;
float gx = x + c.Offset.X;
float gy = y + c.Offset.Y;
renderer.DrawSubrect(tex, gx, gy, c.Bounds.Width, c.Bounds.Height, u0, v0, u1, v1);
x += c.XAdvance;
}
}
protected override void DrawBackground(IGuiContext context, IGuiRenderer renderer, float deltaSeconds)
{
if (BackgroundRegion != null)
{
renderer.DrawRegion(BackgroundRegion, BoundingRectangle, Color);
}
}
public override void Draw(IGuiContext context, IGuiRenderer renderer, float deltaSeconds)
{
base.Draw(context, renderer, deltaSeconds);
if (IsOpen)
{
var dropDownRectangle = GetListAreaRectangle(context);
if (DropDownRegion != null)
{
renderer.DrawRegion(DropDownRegion, dropDownRectangle, DropDownColor);
}
else
{
renderer.FillRectangle(dropDownRectangle, DropDownColor);
renderer.DrawRectangle(dropDownRectangle, BorderColor);
}
DrawItemList(context, renderer);
}
var selectedTextInfo = GetItemTextInfo(context, ContentRectangle, SelectedItem);
if (!string.IsNullOrWhiteSpace(selectedTextInfo.Text))
{
renderer.DrawText(selectedTextInfo.Font, selectedTextInfo.Text, selectedTextInfo.Position + TextOffset, selectedTextInfo.Color, selectedTextInfo.ClippingRectangle);
}
}
protected override void DrawText(IGuiRenderer renderer, float deltaSeconds, TextInfo textInfo)
{
var caretRectangle = textInfo.Font.GetStringRectangle(Text.Substring(0, SelectionStart), textInfo.Position);
// TODO: Finish the caret position stuff when it's outside the clipping rectangle
if (caretRectangle.Right > ClippingRectangle.Right)
{
var textOffset = caretRectangle.Right - ClippingRectangle.Right;
textInfo.Position.X -= textOffset;
}
caretRectangle.X = caretRectangle.Right < ClippingRectangle.Right ? caretRectangle.Right : ClippingRectangle.Right;
caretRectangle.Width = 1;
base.DrawText(renderer, deltaSeconds, textInfo);
if (IsFocused)
{
if (_isCaretVisible)
{
renderer.DrawRectangle(caretRectangle, TextColor);
}
_nextCaretBlink -= deltaSeconds;
if (_nextCaretBlink <= 0)
{
_isCaretVisible = !_isCaretVisible;
_nextCaretBlink = _caretBlinkRate;
}
}
}
protected override void Render(IGuiRenderer guiRenderer)
{
if (RenderBackground)
{
guiRenderer.NinePatch(Size, _ninePatchHandle, alpha: Alpha);
}
base.Render(guiRenderer);
}
//public GuiElementRenderContext ActiveContext { get; private set; }
public GuiRenderArgs(GraphicsDevice graphicsDevice, SpriteBatch spriteBatch, GuiScaledResolution scaledResolution, IGuiRenderer renderer, GameTime gameTime) : base(graphicsDevice)
{
Renderer = renderer;
Graphics = graphicsDevice;
SpriteBatch = spriteBatch;
GameTime = gameTime;
ScaledResolution = scaledResolution;
}
public override void Draw(IGuiContext context, IGuiRenderer renderer, float deltaSeconds)
{
base.Draw(context, renderer, deltaSeconds);
var control = Template;
control?.Draw(context, renderer, deltaSeconds);
}
protected override void Render(IGuiRenderer guiRenderer)
{
base.Render(guiRenderer);
guiRenderer.Rectangle(
Size,
guiRenderer.ColourScheme.WindowBackground,
guiRenderer.ColourScheme.ButtonSurround);
}
protected override void DrawForeground(IGuiContext context, IGuiRenderer renderer, float deltaSeconds, TextInfo textInfo)
{
base.DrawForeground(context, renderer, deltaSeconds, textInfo);
if (IconRegion != null)
{
renderer.DrawRegion(IconRegion, new Rectangle(BoundingRectangle.Location + _iconPosition + Offset.ToPoint(), IconRegion.Bounds.Size), IconColor);
}
}
protected override void DrawBackground(IGuiRenderer renderer, float deltaSeconds)
{
base.DrawBackground(renderer, deltaSeconds);
var boundingRectangle = BoundingRectangle;
var clippingRectangle = new Rectangle(boundingRectangle.X, boundingRectangle.Y, (int)(boundingRectangle.Width * Progress), boundingRectangle.Height);
renderer.DrawRegion(BarRegion, BoundingRectangle, Color, clippingRectangle);
}
public GuiSpriteBatch(IGuiRenderer renderer, GraphicsDevice graphicsDevice, SpriteBatch spriteBatch)
{
_renderer = renderer;
_graphicsDevice = graphicsDevice;
SpriteBatch = spriteBatch;
Context = GraphicsContext.CreateContext(_graphicsDevice, BlendState.AlphaBlend, DepthStencilState.None, RasterizerState.CullNone, SamplerState.PointClamp);
Font = _renderer.Font;
ScaledResolution = _renderer.ScaledResolution;
}
/// <summary>
/// Draws the tile map
/// </summary>
/// <param name="context">gui context</param>
/// <param name="renderer">gui renderer</param>
/// <param name="deltaSeconds">delta of seconds since last draw</param>
public override void Draw(IGuiContext context, IGuiRenderer renderer, float deltaSeconds)
{
base.Draw(context, renderer, deltaSeconds);
renderer.FillRectangle(this.ContentRectangle, this.BackgroundColor);
this.DrawMapTiles(renderer);
this.DrawPlayer(renderer);
}
/// <summary>
/// Draws the message scroll view
/// </summary>
/// <param name="context">gui context</param>
/// <param name="renderer">gui renderer</param>
/// <param name="deltaSeconds">delta of seconds since last draw</param>
public override void Draw(IGuiContext context, IGuiRenderer renderer, float deltaSeconds)
{
base.Draw(context, renderer, deltaSeconds);
renderer.FillRectangle(this.ContentRectangle, this.BackgroundColor);
IEnumerable <string> scrollLines = this.GetScrollLines();
this.DrawTextLines(context, renderer, scrollLines);
}
protected override void OnInit(IGuiRenderer renderer)
{
base.OnInit(renderer);
Tip.Font = renderer.Font;
Popup.Font = renderer.Font;
AddChild(Tip);
AddChild(Popup);
}
public bool TryResolveTexture(IGuiRenderer renderer)
{
if (!TextureResource.HasValue)
{
return(true);
}
Texture = renderer.GetTexture(TextureResource.Value);
return(Texture != null);
}
protected override void OnInit(IGuiRenderer renderer)
{
base.OnInit(renderer);
if (SavedServerEntry.CachedIcon != null)
{
ServerIcon = SavedServerEntry.CachedIcon;
_serverIcon.Texture = ServerIcon;
}
// PingAsync();
}
protected override void Render(IGuiRenderer guiRenderer)
{
if (IsMouseDown)
{
guiRenderer.Rectangle(
Size,
guiRenderer.ColourScheme.ButtonBackgroundClick,
guiRenderer.ColourScheme.ButtonSurroundClick
);
}
else
{
var backgroundColour =
guiRenderer.ColourScheme.ButtonBackground.Interpolate(
guiRenderer.ColourScheme.ButtonBackgroundHighlight, Highlight);
var surroundColour =
guiRenderer.ColourScheme.ButtonSurround.Interpolate(
guiRenderer.ColourScheme.ButtonSurroundHighlight, Highlight);
guiRenderer.Rectangle(
Size,
backgroundColour,
surroundColour
);
}
string textureName;
if (IsMouseDown)
{
textureName = "guiskin_down.png";
}
else if (IsMouseOver)
{
textureName = "guiskin_sel.png";
}
else
{
textureName = null;
}
guiRenderer.NinePatch(Size, _ninePatchHandle, textureName);
guiRenderer.Text(
Label,
Size / 2,
VerticalAlignment.Middle,
HorizontalAlignment.Centre);
if (!string.IsNullOrEmpty(ImageName))
{
guiRenderer.Image(ImageName, Size);
}
}
protected override void Render(IGuiRenderer guiRenderer)
{
base.Render(guiRenderer);
var verticalOffset = CalculateVerticalOffset();
Color4? colour = null;
if (!string.IsNullOrEmpty(Colour))
colour = guiRenderer.ColourScheme.GetColour(Colour);
_maxWidth = guiRenderer.Text(Text, verticalOffset, VerticalAlignment, fontFace: FontFace, fontSize: FontSize, colour:colour);
}
protected override void DrawForeground(IGuiContext context, IGuiRenderer renderer, float deltaSeconds, TextInfo textInfo)
{
var selectedTextInfo = GetItemTextInfo(context, ClippingRectangle, SelectedItem, ClippingRectangle);
base.DrawForeground(context, renderer, deltaSeconds, selectedTextInfo);
if (IsOpen)
{
DrawItemList(context, renderer);
}
}
/// <summary>
/// Draws player
/// </summary>
/// <param name="renderer">gui renderer</param>
private void DrawPlayer(IGuiRenderer renderer)
{
int playerX = this.viewModel.PlayerPosition.X - this.viewModel.MapCenterPosition.X + (this.sizeInTiles.X / 2);
int playerY = this.viewModel.PlayerPosition.Y - this.viewModel.MapCenterPosition.Y + (this.sizeInTiles.Y / 2);
if (playerX >= 0 && playerX <= this.sizeInTiles.X &&
playerY >= 0 && playerY <= this.sizeInTiles.Y)
{
this.DrawTilesetTile(renderer, this.viewModel.ObjectTileset, 0, playerX, playerY);
}
}
protected override void Render(IGuiRenderer guiRenderer)
{
base.Render(guiRenderer);
var y = 0;
foreach (var line in Value.Split('\n'))
{
guiRenderer.Text(line, new Vector2(0, y));
y += LineHeight;
}
}
public GuiContext(IGuiRenderer guiRenderer)
{
{
GuiElementMousePositionChecker guiElementMousePositionChecker = new GuiElementMousePositionChecker(guiElements);
SelectionInteraction selectionInteraction = new SelectionInteraction(selectionTracker, guiElements);
mouseInteraction = new GuiElementMouseInteraction(guiElementMousePositionChecker, selectionInteraction);
}
elementRenderer = new GuiElementRenderer(guiElements, guiRenderer);
}
public DisplayManager(PresentationPanel presentationPanel)
{
GL = GlobalWin.GL;
this.presentationPanel = presentationPanel;
GraphicsControl = this.presentationPanel.GraphicsControl;
CR_GraphicsControl = GlobalWin.GLManager.GetContextForGraphicsControl(GraphicsControl);
//it's sort of important for these to be initialized to something nonzero
currEmuWidth = currEmuHeight = 1;
if (GL is BizHawk.Bizware.BizwareGL.Drivers.OpenTK.IGL_TK)
Renderer = new GuiRenderer(GL);
else if (GL is BizHawk.Bizware.BizwareGL.Drivers.SlimDX.IGL_SlimDX9)
Renderer = new GuiRenderer(GL);
else
Renderer = new GDIPlusGuiRenderer((BizHawk.Bizware.BizwareGL.Drivers.GdiPlus.IGL_GdiPlus)GL);
VideoTextureFrugalizer = new TextureFrugalizer(GL);
ShaderChainFrugalizers = new RenderTargetFrugalizer[16]; //hacky hardcoded limit.. need some other way to manage these
for (int i = 0; i < 16; i++)
{
ShaderChainFrugalizers[i] = new RenderTargetFrugalizer(GL);
}
using (var xml = typeof(Program).Assembly.GetManifestResourceStream("BizHawk.Client.EmuHawk.Resources.courier16px.fnt"))
using (var tex = typeof(Program).Assembly.GetManifestResourceStream("BizHawk.Client.EmuHawk.Resources.courier16px_0.png"))
TheOneFont = new StringRenderer(GL, xml, tex);
if (GL is BizHawk.Bizware.BizwareGL.Drivers.OpenTK.IGL_TK)
{
var fiHq2x = new FileInfo(Path.Combine(PathManager.GetExeDirectoryAbsolute(), "Shaders/BizHawk/hq2x.cgp"));
if (fiHq2x.Exists)
using (var stream = fiHq2x.OpenRead())
ShaderChain_hq2x = new Filters.RetroShaderChain(GL, new Filters.RetroShaderPreset(stream), Path.Combine(PathManager.GetExeDirectoryAbsolute(), "Shaders/BizHawk"));
var fiScanlines = new FileInfo(Path.Combine(PathManager.GetExeDirectoryAbsolute(), "Shaders/BizHawk/BizScanlines.cgp"));
if (fiScanlines.Exists)
using (var stream = fiScanlines.OpenRead())
ShaderChain_scanlines = new Filters.RetroShaderChain(GL, new Filters.RetroShaderPreset(stream), Path.Combine(PathManager.GetExeDirectoryAbsolute(), "Shaders/BizHawk"));
var fiBicubic = new FileInfo(Path.Combine(PathManager.GetExeDirectoryAbsolute(), "Shaders/BizHawk/bicubic-fast.cgp"));
if (fiBicubic.Exists)
using (var stream = fiBicubic.OpenRead())
ShaderChain_bicubic = new Filters.RetroShaderChain(GL, new Filters.RetroShaderPreset(stream), Path.Combine(PathManager.GetExeDirectoryAbsolute(), "Shaders/BizHawk"));
}
LuaSurfaceSets["emu"] = new SwappableDisplaySurfaceSet();
LuaSurfaceSets["native"] = new SwappableDisplaySurfaceSet();
LuaSurfaceFrugalizers["emu"] = new TextureFrugalizer(GL);
LuaSurfaceFrugalizers["native"] = new TextureFrugalizer(GL);
RefreshUserShader();
}
protected override void Render(IGuiRenderer guiRenderer)
{
if (Border && guiRenderer.RenderMode == RenderMode.Normal)
{
guiRenderer.NinePatch(Size, _ninePatchHandle, alpha: Alpha);
}
if (!string.IsNullOrEmpty(ImageName))
{
guiRenderer.Image(ImageName, Size, margin: Margin);
}
base.Render(guiRenderer);
}
protected override void Render(IGuiRenderer guiRenderer)
{
base.Render(guiRenderer);
var positionScale = Value/(float)(MaximumValue - MinimumValue);
guiRenderer.NinePatch(Size, _ninePatchHandle, "guiskin_down.png");
var railSize = new Vector2(Size.X - (SliderMargin * 2), 4);
guiRenderer.Image("slider_rail", railSize, new Vector2(SliderMargin, Size.Y / 2));
var x = (int)((positionScale * (Size.X - (SliderMargin * 2)))) - (SliderWidth / 2);
var y = (Size.Y / 2) - (SliderHeight / 2);
guiRenderer.Image("slider", null, new Vector2(x + SliderMargin, y));
}
protected override void Render(IGuiRenderer guiRenderer)
{
guiRenderer.Rectangle(
new Vector2(0, 0),
new Vector2(16, 16),
guiRenderer.ColourScheme.ButtonBackground,
guiRenderer.ColourScheme.ButtonSurround);
if (Value)
{
guiRenderer.Line(new Vector2(0, 0), new Vector2(16, 16), guiRenderer.ColourScheme.ButtonSurround);
guiRenderer.Line(new Vector2(16, 0), new Vector2(16, 0), guiRenderer.ColourScheme.ButtonSurround);
}
base.Render(guiRenderer);
}
protected override void Render(IGuiRenderer guiRenderer)
{
base.Render(guiRenderer);
var height = 0;
var width = 0;
if (Direction == TextListDirection.BottomUp)
{
var textY = Size.Y;
for (var index = Items.Count - 1; index >= 0; index--)
{
var row = Items[index];
textY -= row.FontSize;
height += row.FontSize;
var thisWidth = guiRenderer.Text(row.FontFace, row.FontSize, row.Text, row.Colour,
new Vector2(0, textY), horizontalAlignment: HorizontalAlignment.LeftAbsolute);
width = Math.Max(width, thisWidth);
}
}
else
{
var textY = 0;
foreach (var row in Items)
{
var thisWidth = guiRenderer.Text(row.FontFace, row.FontSize, row.Text, row.Colour,
new Vector2(0, textY), horizontalAlignment: HorizontalAlignment.LeftAbsolute);
textY += row.FontSize;
height += row.FontSize;
width = Math.Max(width, thisWidth);
}
}
if (ResizeParent)
{
Parent.Size = new Vector2(
width + (Parent.Margin.X * 2),
height + (Parent.Margin.Y * 2));
}
}
protected override void Render(IGuiRenderer guiRenderer)
{
base.Render(guiRenderer);
var horizontalAlignment = Border ? HorizontalAlignment.LeftWithMargin : HorizontalAlignment.LeftAbsolute;
if (Background)
{
guiRenderer.Rectangle(
Size,
guiRenderer.ColourScheme.ButtonSurround,
guiRenderer.ColourScheme.TextboxBackground, Border);
}
var textWidth = guiRenderer.Text(
Value,
new Vector2(0, Size.Y / 2), VerticalAlignment.Middle, horizontalAlignment);
guiRenderer.Text(
(HasFocus ? CaretSymbol : ""),
new Vector2(textWidth, Size.Y / 2),
VerticalAlignment.Middle,
horizontalAlignment, CaretOpacity);
}
protected override void Render(IGuiRenderer guiRenderer)
{
guiRenderer.NinePatch(Size, _ninePatchHandle);
guiRenderer.NinePatch(new Vector2(Size.X, HeaderHeight), _ninePatchHandle);
base.Render(guiRenderer);
if (_selectedRowIndex != -1)
{
RenderRowBox(_selectedRowIndex, guiRenderer, guiRenderer.ColourScheme.ToggledButton);
}
if (_highlightedRowIndex != -1)
{
RenderRowBox(
_highlightedRowIndex,
guiRenderer,
guiRenderer
.ColourScheme
.ToggledButton
.MakeTransparent(_mouseOverFade));
}
RenderRowText(guiRenderer);
}
private void RenderRowBox(int rowIndex, IGuiRenderer guiRenderer, Color4 colour)
{
if (rowIndex == -1)
return;
var pin = 4;
var rowY = (rowIndex * RowHeight) + HeaderHeight;
guiRenderer.Rectangle(
new Vector2(pin, rowY),
new Vector2(Size.X - pin, rowY + RowHeight),
colour,
colour,
false);
}
private void RenderRowText(IGuiRenderer guiRenderer)
{
var y = HeaderHeight; // accomodate for header.
foreach (var row in Data)
{
var i = 0;
var x = 0;
foreach (var column in Columns)
{
guiRenderer.Text(row[i], new Vector2(x, y));
i++;
x += column.Width;
}
y += RowHeight;
}
}
protected override void Render(IGuiRenderer guiRenderer)
{
string textureName;
if (Value && IsMouseOver)
{
textureName = "guiskin_sel_down.png";
}
else if (Value)
{
textureName = "guiskin_down.png";
}
else if (IsMouseOver)
{
textureName = "guiskin_sel.png";
}
else
{
textureName = null;
}
guiRenderer.NinePatch(Size, _ninePatchHandle, textureName);
guiRenderer.Text(
Label,
Size / 2,
VerticalAlignment.Middle,
HorizontalAlignment.Centre);
if (!string.IsNullOrEmpty(ImageName))
{
guiRenderer.Image(ImageName, Size);
}
}
protected override void Render(IGuiRenderer guiRenderer)
{
base.Render(guiRenderer);
var y = 0;
foreach (var item in Items.IndexOver())
{
var buttonBackground = _hoverRowIndex == item.Index ? Colours.LightBlue : guiRenderer.ColourScheme.ButtonBackground;
guiRenderer.Rectangle(
new Vector2(0, y),
new Vector2(Size.X, y + RowHeight),
guiRenderer.ColourScheme.ButtonSurround,
buttonBackground);
guiRenderer.Text(
"Arial",
RowHeight - 1,
item.Value.Text,
guiRenderer.ColourScheme.TextColour,
new Vector2(0, y));
y += RowHeight;
}
}
protected override void Render(IGuiRenderer guiRenderer)
{
base.Render(guiRenderer);
guiRenderer.Rectangle(
Size,
guiRenderer.ColourScheme.TextboxBackground,
guiRenderer.ColourScheme.ButtonSurround);
guiRenderer.Text(
SelectedItemText,
new Vector2(0, Size.Y / 2),
VerticalAlignment.Middle,
HorizontalAlignment.LeftAbsolute);
}
protected override void Render(IGuiRenderer guiRenderer)
{
guiRenderer.Desktop(this);
}
