protected override void Draw(ref UiViewDrawParameters parameters)
{
float opacity = parameters.Opacity;
if (opacity == 0)
{
return;
}
base.Draw(ref parameters);
Rectangle target = ScreenBounds;
Rectangle source = Rectangle.Empty;
source = new Rectangle(0, 0, _spriteInstance.FrameSize.X, _spriteInstance.FrameSize.Y);
double scaleX = 1;
double scaleY = 1;
scaleX = scaleY = Math.Min((double)target.Width / (double)source.Width, (double)target.Height / (double)source.Height);
Point pos = target.Center;
int width = (int)(Math.Ceiling(_spriteInstance.FrameSize.X * scaleX));
int height = (int)(Math.Ceiling(_spriteInstance.FrameSize.Y * scaleY));
Rectangle targetRect = new Rectangle(pos.X - width / 2 - width % 2, pos.Y - height / 2 - height % 2, width, height);
target = GraphicsHelper.IntersectRectangle(targetRect, target);
PartialTexture2D image = _spriteInstance.FrameImage;
parameters.DrawBatch.DrawImage(image.Texture, target, image.Source, Color.White);
}
protected override void Draw(ref UiViewDrawParameters parameters)
{
float opacity = parameters.Opacity;
if (opacity == 0 || TextColor.Value.A == 0)
{
return;
}
base.Draw(ref parameters);
UiFont font = Font;
float scale = font.Scale;
scale *= _rescale;
Rectangle bounds = ScreenBounds;
if (Text.Length > 0)
{
bounds = _textMargin.ComputeRect(bounds);
}
parameters.DrawBatch.DrawText(font.Font, Text, bounds, TextAlign, TextColor.Value * opacity, font.Spacing, (float)_lineHeight / 100.0f, scale, _rotation);
}
protected override void Draw(ref UiViewDrawParameters parameters)
{
float opacity = parameters.Opacity;
if (opacity == 0)
{
return;
}
DrawBackground(ref parameters);
UiViewDrawParameters drawParams = parameters;
drawParams.Opacity = opacity;
drawParams.Transition = 1 - DisplayVisibility;
drawParams.TransitionRectangle = ScreenBounds;
drawParams.TransitionMode = DisplayVisibility == 1 ? TransitionMode.None : (Visible ? TransitionMode.Show : TransitionMode.Hide);
if (DisplayVisibility == 1 && !_alreadyFullyVisible)
{
_alreadyFullyVisible = true;
UiTask.BeginInvoke(() => CallDelegate("PageShown"));
}
for (int idx = 0; idx < _children.Count; ++idx)
{
_children[idx].ViewDraw(ref drawParams);
}
}
protected override void Draw(ref UiViewDrawParameters parameters)
{
if (Colors == null)
{
base.Draw(ref parameters);
return;
}
float opacity = parameters.Opacity;
if (opacity == 0 || TextColor.Value.A == 0)
{
return;
}
float scale = _font.Scale;
if (_font.Font.SitanaFont == null)
{
throw new Exception("Only Sitana fonts support UiColoredLabel.");
}
lock (Text)
{
lock (Colors)
{
parameters.DrawBatch.DrawText(_font.Font, Text.StringBuilder, ScreenBounds, TextAlign, Colors, opacity, _font.Spacing, (float)_lineHeight / 100.0f, scale);
}
}
}
public bool Draw(float ellapsedTime)
{
if (_drawBatch == null)
{
return(false);
}
var drawParameters = new UiViewDrawParameters()
{
DrawBatch = _drawBatch,
Opacity = 1,
Transition = 0,
EllapsedTime = ellapsedTime
};
GraphicsDevice.Clear(MainView.BackgroundColor);
_drawBatch.Reset();
MainView.ViewDraw(ref drawParameters);
_drawBatch.Flush();
PerformanceProfiler.Instance.Draw(_drawBatch);
_drawBatch.Flush();
return(true);
}
protected override void Draw(ref UiViewDrawParameters parameters)
{
float opacity = parameters.Opacity;
if (opacity == 0 || TextColor.Value.A == 0)
{
return;
}
base.Draw(ref parameters);
if (_fontFace == null)
{
_fontFace = FontManager.Instance.FindFont(FontName);
}
float scale;
UniversalFont font = _fontFace.Find(FontSize, out scale);
Rectangle bounds = ScreenBounds;
if (Text.Length > 0)
{
bounds = _textMargin.ComputeRect(bounds);
}
parameters.DrawBatch.DrawText(font, Text, bounds, TextAlign, TextColor.Value * opacity, (float)FontSpacing / 1000.0f, (float)LineHeight / 100.0f, scale, _rotation);
}
protected override void Draw(ref UiViewDrawParameters parameters)
{
float opacity = parameters.Opacity;
if (opacity == 0)
{
return;
}
DrawBackground(ref parameters);
UiViewDrawParameters drawParams = parameters;
drawParams.Opacity = opacity;
if (_clipChildren)
{
parameters.DrawBatch.PushClip(ScreenBounds);
}
for (int idx = 0; idx < _children.Count; ++idx)
{
_children[idx].ViewDraw(ref drawParams);
}
if (_clipChildren)
{
parameters.DrawBatch.PopClip();
}
}
void DrawCurrentLayer(ref UiViewDrawParameters parameters)
{
if (Document.Current.SelectedLayer is DocTiledLayer)
{
TiledLayer layer = Document.Current.SelectedLayer.Layer as TiledLayer;
DrawTiles(ref parameters, layer);
}
}
protected override void Draw(ref UiViewDrawParameters parameters)
{
float opacity = parameters.Opacity;
if (opacity == 0)
{
return;
}
int spacing = _spacing.Compute(_vertical ? Bounds.Width : Bounds.Height);
Rectangle rect = GetFirstRect();
int size = _vertical ? rect.Height : rect.Width;
int selected = _element.SelectedIndex;
int count = _element.Count;
var drawInfo = new DrawButtonInfo();
drawInfo.Opacity = opacity;
drawInfo.EllapsedTime = parameters.EllapsedTime;
for (int idx = 0; idx < count; ++idx)
{
_element.GetText(_text, idx);
drawInfo.ButtonState = ButtonState.None;
if (idx == _pushedIndex)
{
drawInfo.ButtonState |= ButtonState.Pushed;
}
if (idx == selected)
{
drawInfo.ButtonState |= ButtonState.Checked;
}
drawInfo.Text = _text;
drawInfo.Target = rect;
for (int di = 0; di < _drawables.Count; ++di)
{
_drawables[di].DontForceRedraw();
_drawables[di].Draw(parameters.DrawBatch, drawInfo);
}
if (_vertical)
{
rect.Y += size + spacing;
}
else
{
rect.X += size + spacing;
}
}
}
protected override void Draw(ref UiViewDrawParameters parameters)
{
float opacity = parameters.Opacity;
if (opacity == 0)
{
return;
}
if (_currentTileset != null)
{
Rectangle sb = ScreenBounds;
int width = _currentTileset.Width / _divideWidth;
float scale = _scale;
int ww = (int)(scale * width);
Point size = new Point((int)ww, (int)(_currentTileset.Height * scale));
parameters.DrawBatch.DrawRectangle(new Rectangle(sb.X, sb.Y, (int)ww, (int)Math.Ceiling(_currentTileset.Height * scale * _divideWidth)), BackgroundColor);
SamplerState oldSampler = parameters.DrawBatch.SamplerState;
parameters.DrawBatch.SamplerState = SamplerState.PointClamp;
for (int idx = 0; idx < _divideWidth; ++idx)
{
Point target = sb.Location;
target.Y += size.Y * idx;
Point source = Point.Zero;
source.X += (int)width * idx;
parameters.DrawBatch.DrawImage(_currentTileset, target, size, source, scale, Color.White * opacity);
}
parameters.DrawBatch.SamplerState = oldSampler;
if (_selection.HasValue)
{
float tileSize = _tileSize;
Rectangle selection = sb;
selection.X += (int)(_selection.Value.X * tileSize);
selection.Y += (int)(_selection.Value.Y * tileSize);
selection.Width = (int)Math.Ceiling((_selection.Value.Width + 1) * tileSize);
selection.Height = (int)Math.Ceiling((_selection.Value.Height + 1) * tileSize);
parameters.DrawBatch.DrawRectangle(selection, _selectionColor.Value * opacity);
}
}
}
protected override void Draw(ref UiViewDrawParameters parameters)
{
float opacity = parameters.Opacity;
if (opacity == 0 || TextColor.Value.A == 0)
{
return;
}
base.Draw(ref parameters);
UniversalFont font;
float scale;
GetFont(out font, out scale);
Rectangle target = ScreenBounds;
int height = (int)(font.Height * LineHeight * scale / 100);
int startX = target.X;
int fullHeight = height * _lines.Count;
switch (TextAlign & TextAlign.Vert)
{
case TextAlign.Middle:
target.Y = target.Center.Y - fullHeight / 2;
break;
case TextAlign.Bottom:
target.Y = target.Bottom - fullHeight;
break;
}
int indent = _indent.Compute(Bounds.Width);
for (int idx = 0; idx < _lines.Count; ++idx)
{
string line = _lines[idx].Line;
float spacing = _lines[idx].Spacing;
target.X = startX;
target.X += _lines[idx].Indent * indent;
parameters.DrawBatch.DrawText(font, line, target, TextAlign & TextAlign.Horz, TextColor.Value * opacity, spacing, 0, scale);
target.Y += height;
}
}
protected override void Draw(ref UiViewDrawParameters parameters)
{
float zoom = (float)_zoom.Value / 100f;
int unitSize = Tools.Tool.UnitToPixels(zoom);
int startX = CurrentPosition.X / unitSize;
int startY = CurrentPosition.Y / unitSize;
Rectangle bounds = ScreenBounds;
startX = startX * unitSize - CurrentPosition.X + bounds.X;
startY = startY * unitSize - CurrentPosition.Y + bounds.Y + 1;
int size = (int)Math.Ceiling(UiUnit.Unit * 3);
int right = bounds.Right + size;
int bottom = bounds.Bottom + size;
AdvancedDrawBatch batch = parameters.DrawBatch;
batch.PushClip(bounds);
Color color = Color.White * 0.25f;
for (int x = startX; x < right; x += unitSize)
{
for (int y = startY; y < bottom; y += unitSize)
{
batch.DrawLine(new Point(x - size, y), new Point(x + size - 1, y), color);
batch.DrawLine(new Point(x, y - size), new Point(x, y + size - 1), color);
}
}
DrawCurrentLayer(ref parameters);
if (MousePosition.HasValue)
{
Point pos = CurrentPosition;
pos.X -= bounds.X;
pos.Y -= bounds.Y;
Tools.Tool.Current.Draw(parameters.DrawBatch, pos, MousePosition.Value, zoom);
}
batch.PopClip();
}
protected override void Draw(ref UiViewDrawParameters parameters)
{
Texture2D image = _image.Value;
float scale = Scale;
Vector2 textureCoord = Vector2.One;
Vector2 size = Vector2.Zero;
Color color = _color.Value * parameters.Opacity;
if (_vertical)
{
size.X = (float)Math.Ceiling(scale * image.Width);
size.Y = scale * image.Height;
textureCoord.Y = Bounds.Height / size.Y;
size.Y = Bounds.Height;
}
else
{
size.Y = (float)Math.Ceiling(scale * image.Height);
size.X = scale * image.Width;
textureCoord.X = Bounds.Width / size.X;
size.X = Bounds.Width;
}
Vector2 p1 = new Vector2(ScreenBounds.X, (int)(ScreenBounds.Center.Y - size.Y / 2));
Vector2 p2 = new Vector2(ScreenBounds.Right, p1.Y + size.Y);
parameters.DrawBatch.BeginPrimitive(PrimitiveType.TriangleStrip, image);
SamplerState oldState = parameters.DrawBatch.SamplerState;
parameters.DrawBatch.SamplerState = SamplerState.LinearWrap;
parameters.DrawBatch.PushVertex(new Vector2(p1.X, p1.Y), color, new Vector2(0, 0));
parameters.DrawBatch.PushVertex(new Vector2(p2.X, p1.Y), color, new Vector2(textureCoord.X, 0));
parameters.DrawBatch.PushVertex(new Vector2(p1.X, p2.Y), color, new Vector2(0, textureCoord.Y));
parameters.DrawBatch.PushVertex(new Vector2(p2.X, p2.Y), color, new Vector2(textureCoord.X, textureCoord.Y));
parameters.DrawBatch.Flush();
parameters.DrawBatch.SamplerState = oldState;
}
protected override void Draw(ref UiViewDrawParameters parameters)
{
float opacity = parameters.Opacity;
if (opacity == 0)
{
return;
}
Color color = _color != null ? _color.Value : Color.White;
float scale = _scaleByUnit ? (float)UiUnit.Unit : 1;
if (color.A > 0)
{
parameters.DrawBatch.DrawNinePatchRect(_image, ScreenBounds, color * opacity, scale * _scale);
}
}
protected override void Draw(ref UiViewDrawParameters parameters)
{
float opacity = parameters.Opacity;
if (opacity == 0)
{
return;
}
Rectangle screen = ScreenBounds;
Rectangle thumb = ThumbRect;
if (thumb != screen || _alwaysVisible)
{
var batch = parameters.DrawBatch;
var drawInfo = new DrawButtonInfo();
drawInfo.Text = null;
drawInfo.ButtonState = _touchId != 0 ? ButtonState.Pushed : ButtonState.None;
if (thumb == screen)
{
drawInfo.ButtonState = ButtonState.Disabled;
}
drawInfo.Target = screen;
drawInfo.Opacity = opacity;
drawInfo.EllapsedTime = parameters.EllapsedTime;
for (int idx = 0; idx < _trackDrawables.Count; ++idx)
{
var drawable = _trackDrawables[idx];
drawable.Draw(batch, drawInfo);
}
drawInfo.Target = thumb;
for (int idx = 0; idx < _thumbDrawables.Count; ++idx)
{
var drawable = _thumbDrawables[idx];
drawable.Draw(batch, drawInfo);
}
}
}
protected override void Draw(ref Parameters.UiViewDrawParameters parameters)
{
float opacity = parameters.Opacity;
if (opacity == 0)
{
return;
}
DrawBackground(ref parameters);
UiViewDrawParameters drawParams = parameters;
drawParams.Opacity = opacity;
if (_clipChildren || _expandedValue < 1)
{
parameters.DrawBatch.PushClip(ScreenBounds);
}
Rectangle bound = new Rectangle(0, 0, Bounds.Width, Bounds.Height);
for (int idx = 0; idx < _children.Count; ++idx)
{
var child = _children[idx];
Rectangle childBounds = child.Bounds;
if (childBounds.X < bound.Width && childBounds.Y < bound.Height &&
childBounds.Right >= 0 && childBounds.Bottom >= 0)
{
child.ViewDraw(ref drawParams);
}
}
if (_clipChildren || _expandedValue < 1)
{
parameters.DrawBatch.PopClip();
}
}
protected override void Draw(ref Parameters.UiViewDrawParameters parameters)
{
float opacity = parameters.Opacity;
if (opacity == 0)
{
return;
}
DrawBackground(ref parameters);
UiViewDrawParameters drawParams = parameters;
drawParams.Opacity = opacity;
drawParams.Transition = 1 - DisplayVisibility;
drawParams.TransitionRectangle = ScreenBounds;
drawParams.TransitionMode = DisplayVisibility == 1 ? TransitionMode.None : (Visible ? TransitionMode.Show : TransitionMode.Hide);
for (int idx = 0; idx < _children.Count; ++idx)
{
_children[idx].ViewDraw(ref drawParams);
}
}
protected void DrawBackground(ref UiViewDrawParameters parameters)
{
float opacity = parameters.Opacity;
if (opacity == 0)
{
return;
}
Color backgroundColor = BackgroundColor * opacity;
if (backgroundColor.A > 0)
{
if (BackgroundDrawable != null)
{
BackgroundDrawable.Draw(parameters.DrawBatch, ScreenBounds, backgroundColor);
}
else
{
parameters.DrawBatch.DrawRectangle(ScreenBounds, backgroundColor);
}
}
}
protected override void Draw(ref UiViewDrawParameters parameters)
{
float opacity = parameters.Opacity;
if (opacity == 0)
{
return;
}
Color color = _color != null ? _color.Value : Color.White;
float scale = _scaleByUnit ? (float)UiUnit.Unit : 1;
if (color.A > 0)
{
Rectangle bounds = ScreenBounds;
bounds.Height = Math.Max(Bounds.Height, 1);
bounds.Width = Math.Max(Bounds.Width, 1);
parameters.DrawBatch.DrawNinePatchRect(_image, bounds, color * opacity, scale * _scale);
}
}
protected override void Draw(ref UiViewDrawParameters parameters)
{
float opacity = parameters.Opacity;
if (opacity == 0)
{
return;
}
DrawBackground(ref parameters);
UiViewDrawParameters drawParams = parameters;
drawParams.Opacity = opacity;
if (_clipChildren)
{
parameters.DrawBatch.PushClip(ScreenBounds);
}
Rectangle bounds = new Rectangle(0, 0, Bounds.Width, Bounds.Height);
for (int idx = 0; idx < _children.Count; ++idx)
{
var child = _children[idx];
if (bounds.Intersects(child.Bounds))
{
child.ViewDraw(ref drawParams);
}
}
if (_clipChildren)
{
parameters.DrawBatch.PopClip();
}
}
protected override void Draw(ref UiViewDrawParameters parameters)
{
if (Colors == null)
{
base.Draw(ref parameters);
return;
}
float opacity = parameters.Opacity;
if (opacity == 0 || TextColor.Value.A == 0)
{
return;
}
if (_fontFace == null)
{
_fontFace = FontManager.Instance.FindFont(FontName);
}
float scale;
UniversalFont font = _fontFace.Find(FontSize, out scale);
if (font.SitanaFont == null)
{
throw new Exception("Only Sitana fonts support UiColoredLabel.");
}
lock (Text)
{
lock (Colors)
{
parameters.DrawBatch.DrawText(font, Text.StringBuilder, ScreenBounds, TextAlign, Colors, opacity, (float)FontSpacing / 1000.0f, (float)LineHeight / 100.0f, scale);
}
}
}
protected override void Draw(ref UiViewDrawParameters parameters)
{
float opacity = parameters.Opacity;
if (opacity == 0)
{
return;
}
Color topColor = _topColor != null ? _topColor.Value : Color.Transparent;
Color bottomColor = _bottomColor != null ? _bottomColor.Value : Color.Transparent;
parameters.DrawBatch.BeginPrimitive(PrimitiveType.TriangleStrip, null);
Rectangle bounds = ScreenBounds;
parameters.DrawBatch.PushVertex(new Vector2(bounds.Left, bounds.Top), topColor * opacity);
parameters.DrawBatch.PushVertex(new Vector2(bounds.Left, bounds.Bottom), bottomColor * opacity);
parameters.DrawBatch.PushVertex(new Vector2(bounds.Right, bounds.Top), topColor * opacity);
parameters.DrawBatch.PushVertex(new Vector2(bounds.Right, bounds.Bottom), bottomColor * opacity);
parameters.DrawBatch.Flush();
}
protected override void Draw(ref UiViewDrawParameters parameters)
{
base.Draw(ref parameters);
int position = 0;
int startPosition = ScreenBounds.Top;
int separatorHeight = _separator != null?Math.Max(1, _separatorHeight.Compute(Bounds.Height)) : 0;
int rowHeight = _rowHeight.Compute(Bounds.Height);
Rectangle target = new Rectangle();
float startIndexF = _scrollingService.ScrollPositionY / (float)(rowHeight + separatorHeight);
int startIndex = (int)startIndexF;
startPosition -= (int)_scrollingService.ScrollPositionY % (rowHeight + separatorHeight);
if (_reversed)
{
startIndex = _items.Count - startIndex - 1;
}
Rectangle textTarget = new Rectangle();
int maxY = ScreenBounds.Bottom;
parameters.DrawBatch.PushClip(ScreenBounds);
target = ScreenBounds;
target.Y = startPosition;
target.Height = separatorHeight;
if (separatorHeight > 0)
{
for (int dataIndex = startIndex; dataIndex < _items.Count && dataIndex >= 0;)
{
_separator.Draw(parameters.DrawBatch, target, parameters.Opacity);
target.Y += rowHeight + separatorHeight;
if (target.Y > maxY)
{
break;
}
dataIndex += _reversed ? -1 : 1;
}
}
startPosition += separatorHeight;
for (int columnIndex = 0; columnIndex < _columns.Count; ++columnIndex)
{
var column = _columns[columnIndex];
int width = column.Width.Compute(Bounds.Width);
UniversalFont font = column.Font.Font;
float fontScale = column.Font.Scale;
float fontSpacing = column.Font.Spacing;
int lineHeight = column.LineHeight;
TextAlign textAlign = column.TextAlign;
target.X = position + column.TextMargin.Left + ScreenBounds.Left;
target.Width = width - column.TextMargin.Width;
target.Y = startPosition;
target.Height = rowHeight;
Margin textMargin = column.TextMargin;
int dataIndex = startIndex;
int count = _items.Count;
for (int idx = 0; idx < count; idx++)
{
textTarget.X = target.X;
textTarget.Width = target.Width;
textTarget.Y = target.Y + textMargin.Top;
textTarget.Height = target.Height - textMargin.Height;
if (dataIndex >= 0 && dataIndex < count)
{
QuickDataRow row = (QuickDataRow)(_items.ElementAt(dataIndex));
Color color = row.Colors[columnIndex].Value;
string text = row.Labels[columnIndex];
parameters.DrawBatch.DrawText(font, text, textTarget, textAlign, color, fontSpacing, lineHeight, fontScale);
}
target.Y += target.Height + separatorHeight;
if (target.Y > maxY)
{
break;
}
dataIndex += _reversed ? -1 : 1;
}
position += width;
}
parameters.DrawBatch.PopClip();
}
protected override void Draw(ref UiViewDrawParameters parameters)
{
base.Draw(ref parameters);
AdvancedDrawBatch batch = parameters.DrawBatch;
Rectangle bounds = ScreenBounds;
_selectedPosition = bounds.Center.Y + _selectedPositionOffset.Compute(bounds.Height);
int size = _elementHeight.Compute(bounds.Height) + _spacing.Compute();
int start = 0;
int center = _selectedPosition + (int)(_scroll * size);
Rectangle rect = bounds;
rect.Height = _elementHeight.Compute(bounds.Height);
while (center > bounds.Top - size / 2)
{
center -= size;
start--;
}
rect.Y = center - _elementHeight.Compute(bounds.Height) / 2;
DrawButtonInfo drawInfo = new DrawButtonInfo();
drawInfo.Icon = null;
drawInfo.Opacity = parameters.Opacity;
drawInfo.EllapsedTime = parameters.EllapsedTime;
drawInfo.Text = _captionText;
while (rect.Bottom <= bounds.Bottom + size)
{
ButtonState state = _touchId != 0 ? ButtonState.Pushed : ButtonState.None;
if (center == _selectedPosition && !_isScrolling && float.IsNaN(_scrollTo))
{
state |= ButtonState.Checked;
}
if (start == (int)((_scroll > 0 ? -0.5 : 0.5) - _scroll))
{
state |= ButtonState.Checked;
}
bool enabled = false;
_context.GetData(start, _captionText.StringBuilder, out enabled);
if (!enabled)
{
state |= ButtonState.Disabled;
state &= ~ButtonState.Pushed;
}
drawInfo.Target = rect;
drawInfo.ButtonState = state;
for (int idx = 0; idx < _drawables.Count; ++idx)
{
var drawable = _drawables[idx];
drawable.Draw(batch, drawInfo);
}
start++;
center += size;
rect.Y += size;
}
}
protected override void Draw(ref UiViewDrawParameters parameters)
{
base.Draw(ref parameters);
Rectangle bounds = ScreenBounds;
Rectangle parentBounds = Parent.ScreenBounds;
Point position = bounds.Location;
int unitSize = (int)Math.Ceiling(_zoom.Value * UiUnit.Unit);
int indexX = 0;
int indexY = 0;
while (parentBounds.X > position.X + unitSize)
{
position.X += unitSize;
indexX++;
}
while (parentBounds.Y > position.Y + unitSize)
{
position.Y += unitSize;
indexY++;
}
int width = _grid.Value.Width;
int height = _grid.Value.Height;
float maxCoordinateX = parentBounds.Right;
float maxCoordinateY = parentBounds.Bottom;
AdvancedDrawBatch drawBatch = parameters.DrawBatch;
AutomataGrid grid = _grid.Value;
Point originalPosition = position;
for(int idxX = indexX; idxX < width; ++idxX)
{
position.Y = originalPosition.Y;
for (int idxY = indexY; idxY < height; ++idxY)
{
if (position.Y > maxCoordinateY)
{
break;
}
int state = grid[idxX, idxY];
if(state > 0)
{
drawBatch.DrawRectangle(new Rectangle(position.X, position.Y, unitSize, unitSize), _colors[state]);
}
position.Y += unitSize;
}
if (position.X > maxCoordinateX)
{
break;
}
position.X += unitSize;
}
if (unitSize > 3)
{
Color gridColor = _gridColor.Value;
position = originalPosition;
for (int idxX = indexX; idxX < width; ++idxX)
{
position.Y = originalPosition.Y;
for (int idxY = indexY; idxY < height; ++idxY)
{
if (position.Y > maxCoordinateY)
{
break;
}
drawBatch.DrawPoint(position, gridColor);
position.Y += unitSize;
}
if (position.X > maxCoordinateX)
{
break;
}
position.X += unitSize;
}
}
}
protected override void Draw(ref UiViewDrawParameters parameters)
{
float opacity = parameters.Opacity;
if (opacity == 0)
{
return;
}
base.Draw(ref parameters);
Rectangle target = ScreenBounds;
Rectangle source = Rectangle.Empty;
float scale = Scale;
lock (_image)
{
Texture2D image = _image.Value;
if (image != null)
{
source = new Rectangle(0, 0, image.Width, image.Height);
double scaleX = scale;
double scaleY = scale;
switch (_stretch)
{
case Stretch.Uniform:
scaleX = scaleY = Math.Min((double)target.Width / (double)image.Width, (double)target.Height / (double)image.Height) * _scale;
scale = (float)scaleX;
break;
case Stretch.UniformToFill:
scaleX = scaleY = Math.Max((double)target.Width / (double)image.Width, (double)target.Height / (double)image.Height) * _scale;
scale = (float)scaleX;
break;
case Stretch.Fill:
scaleX = Scale * (double)target.Width / (double)image.Width;
scaleY = Scale * (double)target.Height / (double)image.Height;
scale = (float)Math.Min(scaleX, scaleY);
break;
}
Point pos = target.Center;
int width = (int)(Math.Ceiling(image.Width * scaleX));
int height = (int)(Math.Ceiling(image.Height * scaleY));
Rectangle targetRect = new Rectangle(pos.X - width / 2 - width % 2, pos.Y - height / 2 - height % 2, width, height);
target = GraphicsHelper.IntersectRectangle(targetRect, target);
int srcWidth = (int)((double)target.Width / scaleX);
int srcHeight = (int)((double)target.Height / scaleY);
pos = source.Center;
source = new Rectangle(pos.X - srcWidth / 2, pos.Y - srcHeight / 2, srcWidth, srcHeight);
}
Color color = _color != null ? _color.Value * opacity : Color.White;
if (_rotationSpeed == 0)
{
parameters.DrawBatch.DrawImage(image, target, source, color);
}
else
{
parameters.DrawBatch.DrawImage(image, target.Center.ToVector2(), null, color, _rotation, new Vector2(image.Width / 2, image.Height / 2), scale);
}
}
}
public void ViewDraw(ref UiViewDrawParameters parameters)
{
_isViewDisplayed = Visible && Math.Abs(parameters.Transition) < 0.000001;
if (DisplayVisibility == 0)
{
return;
}
TransitionEffect transitionEffect = null;
TransitionEffect transitionEffectShowHide = null;
switch (parameters.TransitionMode)
{
case TransitionMode.Show:
transitionEffect = _parentShowTransitionEffect;
break;
case TransitionMode.Hide:
transitionEffect = _parentHideTransitionEffect;
break;
case TransitionMode.None:
transitionEffectShowHide = DisplayVisibility == 1 ? null : (Visible ? _showTransitionEffect : _hideTransitionEffect);
break;
}
if (transitionEffect != null || transitionEffectShowHide != null)
{
UiViewDrawParameters drawParameters = parameters;
float opacity;
Matrix transform;
Matrix targetTransform = Matrix.Identity;
float targetOpacity = 1;
if (transitionEffect != null)
{
transitionEffect.Get(parameters.Transition, parameters.TransitionRectangle, ScreenBounds, out transform, out opacity);
targetOpacity *= opacity;
targetTransform *= transform;
}
if (transitionEffectShowHide != null)
{
transitionEffectShowHide.Get(1 - DisplayVisibility, Parent != null ? Parent.ScreenBounds : ScreenBounds, ScreenBounds, out transform, out opacity);
targetOpacity *= opacity;
targetTransform *= transform;
}
drawParameters.DrawBatch.PushTransform(targetTransform);
drawParameters.Opacity *= (float)Opacity.Value * targetOpacity;
Draw(ref drawParameters);
drawParameters.DrawBatch.PopTransform();
}
else
{
UiViewDrawParameters drawParameters = parameters;
drawParameters.Opacity *= DisplayVisibility * (float)Opacity.Value;
Draw(ref drawParameters);
}
}
protected override void Draw(ref Parameters.UiViewDrawParameters parameters)
{
float opacity = parameters.Opacity;
if (opacity == 0)
{
return;
}
DrawBackground(ref parameters);
if (_clipChildren)
{
parameters.DrawBatch.PushClip(ScreenBounds);
}
for (int idx = 0; idx < 2; ++idx)
{
UiView view = idx == 0 ? _previous : _current;
float transition = _transition;
if (idx == 0)
{
transition = 1 - transition;
}
if (view != null)
{
UiViewDrawParameters drawParams = parameters;
drawParams.Opacity = opacity;
TransitionEffect transitionEffect = FindTransition(idx == 0);
if (transitionEffect != null)
{
float opacity2;
Matrix transform;
drawParams.Transition = transition;
transitionEffect.Get(transition, ScreenBounds, view.ScreenBounds, out transform, out opacity2);
drawParams.Opacity *= opacity2;
drawParams.DrawBatch.PushTransform(transform);
view.ViewDraw(ref drawParams);
drawParams.DrawBatch.PopTransform();
}
else
{
view.ViewDraw(ref drawParams);
}
}
}
if (_clipChildren)
{
parameters.DrawBatch.PopClip();
}
if (_transition > 0)
{
AppMain.RedrawNextFrame();
}
}
protected virtual void Draw(ref UiViewDrawParameters parameters)
{
DrawBackground(ref parameters);
}
void DrawTiles(ref UiViewDrawParameters parameters, TiledLayer layer)
{
Rectangle bounds = ScreenBounds;
AdvancedDrawBatch batch = parameters.DrawBatch;
SamplerState oldSamplerState = batch.SamplerState;
batch.SamplerState = SamplerState.PointClamp;
int width = layer.Width;
int height = layer.Height;
float zoom = (float)_zoom.Value / 100f;
int unitSize = Tools.Tool.UnitToPixels(zoom);
int tileSize = Tools.Tool.UnitToPixels(1);
Rectangle target = new Rectangle(bounds.X - CurrentPosition.X, bounds.Y - CurrentPosition.Y, unitSize, unitSize);
Rectangle source = new Rectangle(0, 0, tileSize - 1, tileSize - 1);
Texture2D tileset = CurrentTemplate.Instance.Tileset(layer.Tileset).Item2;
int startY = target.Y;
int maxY = 0;
ushort[,] tiles = layer.Content;
for (int idxX = 0; idxX < width; ++idxX)
{
target.Y = startY;
if (target.Right >= bounds.X && target.X <= bounds.Right)
{
for (int idxY = 0; idxY < height; ++idxY)
{
if (target.Bottom >= bounds.Y && target.Y <= bounds.Bottom)
{
ushort tile = tiles[idxX, idxY];
if (tile != 0xffff)
{
source.X = (tile & 0xff) * tileSize;
source.Y = ((tile >> 8) & 0xff) * tileSize;
batch.DrawImage(tileset, target, source, Color.White * 0.5f);
}
}
target.Y += unitSize;
maxY = Math.Max(target.Y, maxY);
}
}
target.X += unitSize;
}
Color color = Color.White * 0.25f;
batch.DrawLine(new Point(target.X, bounds.Top), new Point(target.X, maxY), color);
batch.DrawLine(new Point(bounds.Left, maxY), new Point(target.X, maxY), color);
batch.SamplerState = oldSamplerState;
}
protected override void Draw(ref UiViewDrawParameters parameters)
{
float opacity = parameters.Opacity;
if (opacity == 0)
{
return;
}
base.Draw(ref parameters);
Rectangle target = ScreenBounds;
if (_height < target.Height)
{
switch (_textAlign & TextAlign.Vert)
{
case TextAlign.Middle:
target.Y = target.Center.Y - _height / 2;
break;
case TextAlign.Bottom:
target.Y = target.Bottom - _height;
break;
}
}
int startX = target.X;
int endY = target.Bottom;
int top = parameters.DrawBatch.ClipRect.Top;
int bottom = parameters.DrawBatch.ClipRect.Bottom;
_firstVisibleLine = -1;
for (int idx = 0; idx < _lines.Count; ++idx)
{
RichViewLine line = _lines[idx];
if (target.Y > bottom)
{
break;
}
target.Height = line.Height;
if (target.Y + line.Height >= top)
{
if (_firstVisibleLine < 0)
{
_firstVisibleLine = idx;
}
_lastVisibleLine = idx;
int lineOffset = OffsetFromWidthAndAlign(line.Width);
for (int ent = 0; ent < line.Entities.Count; ++ent)
{
RichViewEntity entity = line.Entities[ent];
float spacing = entity.FontSpacing;
float scale = entity.FontScale;
UniversalFont font = entity.Font;
int offset = 0;
if (font != null)
{
offset = line.BaseLine - (int)((font.BaseLine - 1) * scale);
}
target.X = startX + entity.Offset + lineOffset;
switch (entity.Type)
{
case EntityType.HorizontalLine:
{
Rectangle rect = new Rectangle(target.X, target.Y, Bounds.Width, _horizontalRulerHeight.Compute(0));
parameters.DrawBatch.DrawRectangle(rect, _colorRuler.Value * opacity);
}
break;
case EntityType.String:
{
Color textColor = _colorNormal.Value;
if (entity.Url != null)
{
textColor = _selected == entity ? _colorClickableActive.Value : _colorClickable.Value;
}
target.Y += offset;
parameters.DrawBatch.DrawText(font, entity.Text, target, TextAlign.Left, textColor * opacity, spacing, 0, scale);
target.Y -= offset;
}
break;
case EntityType.Image:
{
Point size = new Point((int)(entity.Image.Width * UiUnit.Unit), (int)(entity.Image.Height * UiUnit.Unit));
int maxWidth = Bounds.Width - entity.Offset;
if (size.X > maxWidth)
{
size.Y = maxWidth * size.Y / size.X;
size.X = maxWidth;
}
parameters.DrawBatch.DrawImage(entity.Image, target.Location, size, Point.Zero, (float)size.X / (float)entity.Image.Width, Color.White * opacity);
}
break;
}
}
}
target.Y += line.Height;
}
}
