public TileGfxPage(int x, int y, int width, int height, int page_index, Screens.TileGfxScreen.PageClickHandler onTileGfxPageHandler)
{
Area = new Rectangle(x, y, width, height);
m_PageIndex = page_index;
RenderRule.SetSize(width, height);
m_OnClickHandler += onTileGfxPageHandler;
}
private void Rectangle_PreviewMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
Brush brush = (((System.Windows.Shapes.Rectangle)e.Source).Fill);
int id = -1;
for (int i = 0; i < list.Count; i++)
{
if (brush == list[i].brush)
{
id = i;
}
}
if (id != -1)
{
RenderRule rule = list[id].rule;
SymbolSelector form = new SymbolSelector(rule);
if (form.ShowDialog() == true)
{
list[id].brush = form.brush;
list[id].rule = form.rule;
dataGrid.Items.Refresh();
}
}
//int id = Convert.ToInt32(((System.Windows.Shapes.Rectangle)e.Source).Name);
}
protected internal override void MouseMove(InputEventMouse e)
{
if (e.Button != MouseButton.None)
{
RenderRule.Select(e.Position);
}
}
private void refreshEntireMap()
{
try
{
m_RenderingMap = true;
int w = m_Map.WidthInSuperChunks;
int h = m_Map.HeightInSuperChunks;
RenderRule.TextureDimension = w * 2 * 2;
for (int i = 0; i < w * h; i++)
{
for (int j = 0; j < 4; j++)
{
RenderRule.WriteChunk((i % w) * 2 + (j % 2), (i / w) * 2 + (j / 2),
State.Data.Chunks[m_Map.GetSuperChunk(i % w, (i / w)).Chunks[j]],
State.Data.TileSets[State.SelectedTileset],
State.Data.TileGfx);
if (m_Cancel)
{
m_RenderingMap = false;
return;
}
}
}
}
catch
{
m_RenderingMap = false;
return;
}
m_RenderingMap = false;
}
protected internal override void OnLayout()
{
if (IsScrollOverride)
{
RenderRule.BuildBars(m_ScrollAreaOverride.Value);
}
else
{
// Pixel size of panel to contain child widgets
Rectangle outerArea;
Point scroll;
BuildContainerRenderArea(out outerArea, out scroll); // scroll isn't used. Scroll should always be positive.
RenderRule.BuildBars(outerArea);
if (Children != null)
{
foreach (Widget widget in Children)
{
widget.ScreenArea = new Rectangle(
widget.Area.X + InputArea.X - (int)(RenderRule.Horizontal.ChildOffset),
widget.Area.Y + InputArea.Y - (int)(RenderRule.Vertical.ChildOffset),
widget.Area.Width,
widget.Area.Height);
widget.ClipArea = RenderRule.SafeArea;
}
}
}
ClipArea = RenderRule.SafeArea;
}
/*####################################################################*/
/* Events */
/*####################################################################*/
protected internal override void MouseClick(MouseEventArgs e)
{
if (IsToggled)
{
_selectedItem = RenderRule.GetItem(e.Location);
if (_selectedItem.HasValue)
{
if (_dropDownItems[_selectedItem.Value].OnClick != null)
{
_dropDownItems[_selectedItem.Value].OnClick(this);
}
Label = _dropDownItems[_selectedItem.Value].Item.Item2;
if (OnSelectionChanged != null)
{
OnSelectionChanged(this);
}
}
}
IsToggled = !IsToggled;
if (!IsToggled)
{
RenderRule.Mode = IsHover
? ComboBoxRenderRule.RenderMode.Hover
: ComboBoxRenderRule.RenderMode.Default;
}
else
{
RenderRule.Mode = ComboBoxRenderRule.RenderMode.Pressed;
}
}
protected internal override void KeyDown(InputEventKeyboard e)
{
lock (RenderRule)
{
if (RenderRule.Length != 0)
{
switch (e.KeyCode)
{
case WinKeys.Left:
RenderRule.TextCursor--;
RenderRule.SelectedChar = null;
break;
case WinKeys.Right:
RenderRule.TextCursor++;
RenderRule.SelectedChar = null;
break;
case WinKeys.Up:
RenderRule.CursorUp();
RenderRule.SelectedChar = null;
break;
case WinKeys.Down:
RenderRule.CursorDown();
RenderRule.SelectedChar = null;
break;
case WinKeys.Home:
RenderRule.CursorHome();
RenderRule.SelectedChar = null;
break;
case WinKeys.End:
RenderRule.CursorEnd();
RenderRule.SelectedChar = null;
break;
case WinKeys.PageUp:
RenderRule.TextCursor = 0;
RenderRule.SelectedChar = null;
break;
case WinKeys.PageDown:
RenderRule.TextCursor = RenderRule.Length;
RenderRule.SelectedChar = null;
break;
case WinKeys.Delete:
RenderRule.Delete();
RenderRule.BakeText();
RenderRule.SelectedChar = null;
break;
}
}
}
ResetTimer();
}
private void paintRule(Graphics g, RenderRule rule, float cur_y)
{
Symbolizer geosym = rule.geometrysymbolizer;
//switch (geosym.sign)
//{
// case SymbolizerType.POINT:
// pointsymbolizer pointsymbolizer = (pointsymbolizer)geosym;
// Brush brush = new SolidBrush(pointsymbolizer.color);
// Pen pen = new Pen(brush);
// PointF screenPointF = new PointF(position.X, cur_y);
// switch (pointsymbolizer.pointstyle)
// {
// case PointStyle.CIRCLE_FILL:
// PointStylePainter.PaintFillCircle(g, brush, screenPointF, pointsymbolizer.size);
// break;
// case PointStyle.CIRCLE_HOLLOW:
// PointStylePainter.PaintHollowCircle(g, pen, screenPointF, pointsymbolizer.size);
// break;
// case PointStyle.CIRCLE_POINT:
// PointStylePainter.PaintCircle_Point(g, pen, brush, screenPointF, pointsymbolizer.size);
// break;
// case PointStyle.CIRCLE_RECT:
// PointStylePainter.PaintCircle_Rect(g, pen, screenPointF, pointsymbolizer.size);
// break;
// case PointStyle.RECT_FILL:
// PointStylePainter.PaintFillRect(g, brush, screenPointF, pointsymbolizer.size);
// break;
// case PointStyle.RECT_HOLLOW:
// PointStylePainter.PaintHollowRect(g, pen, screenPointF, pointsymbolizer.size);
// break;
// case PointStyle.TRIANGLE:
// PointStylePainter.PaintFillTriangle(g, brush, screenPointF, pointsymbolizer.size);
// break;
// }
// brush.Dispose();
// pen.Dispose();
// if(rule.filter!=null) g.DrawString(rule.filter.GetDescription(), SystemFonts.DefaultFont, Brushes.Black, new PointF(position.X + 2 * pointsymbolizer.size * 2 + 10, cur_y));
// cur_y += (2 * pointsymbolizer.size + 5);
// break;
// case SymbolizerType.LINE:
// linesymbolizer lsymbolizer = (linesymbolizer)geosym;
// Pen lpen = new Pen(lsymbolizer.color, lsymbolizer.width);
// lpen.DashStyle = lsymbolizer.linestyle;
// g.DrawLine(lpen, position.X, cur_y, position.X + 30, cur_y);
// if (rule.filter != null) g.DrawString(rule.filter.GetDescription(), SystemFonts.DefaultFont, Brushes.Black, new PointF(position.X + 35, cur_y));
// cur_y += (20);
// break;
// case SymbolizerType.POLYGON:
// polygonsymbolizer symbolizer = (polygonsymbolizer)geosym;
// Pen ppen = new Pen(symbolizer.strokecolor, symbolizer.strokewidth);
// Brush pbrush = new SolidBrush(symbolizer.fillcolor);
// g.DrawRectangle(ppen, position.X, cur_y, 30, 15);
// g.FillRectangle(pbrush, position.X, cur_y, 30, 15);
// if (rule.filter != null) g.DrawString(rule.filter.GetDescription(), SystemFonts.DefaultFont, Brushes.Black, new PointF(position.X + 35, cur_y));
// cur_y += (20);
// break;
//}
}
protected internal override void OnLayout()
{
if (Area != Parent.InputArea)
{
var a = Parent.InputArea;
Area = new Rectangle(0, 0, a.Width, a.Height);
}
RenderRule.BakeText();
}
protected internal override void MouseClick(InputEventMouse e)
{
MenuElement element = RenderRule.ElementFromMouseCoordinates();
if (element != null && element.Action != null)
{
element.Action(this);
}
}
public PaletteFourColor(int x, int y, int width, int height, int color_index, int palette_index, int palette_subindex, WidgetEvent onClick)
{
Area = new Rectangle(x, y, width, height);
RenderRule.SetSize(width, height);
ColorIndex = color_index;
m_PaletteIndex = palette_index;
m_PaletteSubIndex = palette_subindex;
m_OnClick += onClick;
}
protected internal override void MouseUp(InputEventMouse e)
{
_isPressed = false;
lock (RenderRule) {
RenderRule.SetTextCursor(
new Point(
e.Position.X - RenderRule.Area.X,
e.Position.Y - RenderRule.Area.Y));
}
}
protected internal override void MouseUp(MouseEventArgs e)
{
_isPressed = false;
lock (RenderRule) {
RenderRule.SetTextCursor(
new Point(
e.Location.X - RenderRule.Area.X,
e.Location.Y - RenderRule.Area.Y));
}
}
/// <summary>
/// Creates a new textbox that automatically fills the parent widget.
/// </summary>
/// <param name="buffer">Padding between the textbox and the parent widget.</param>
/// <param name="maxChars"></param>
public TextBox(int buffer, short maxChars)
{
RenderRule.RecreateStringData(maxChars);
Padding = buffer;
_cursorTimer = new Timer(500);
_cursorTimer.Elapsed += delegate {
RenderRule.CursorVisible = !RenderRule.CursorVisible;
};
}
public TileGfxTile(int x, int y, int pixelscale, int tile_x, int tile_y,
Screens.TileGfxScreen.TileClickHandler onClick, Screens.TileGfxScreen.TileClickHandler onMove)
{
m_PixelScale = pixelscale;
Area = new Rectangle(x, y, 8 * m_PixelScale, 8 * m_PixelScale);
RenderRule.SetSize(8 * m_PixelScale, 8 * m_PixelScale);
m_TileX = tile_x;
m_TileY = tile_y;
m_OnClick += onClick;
m_OnMove += onMove;
}
// ================================================================================
// Input
// ================================================================================
protected internal override void MouseClick(InputEventMouse e)
{
if (e.Button == MouseButton.Left)
{
int index = RenderRule.ItemAtPosition(new Point(e.Position.X, e.Position.Y));
if (index >= 0 && index < m_Items.Count)
{
SelectedIndex = index;
}
}
}
public PolygonSymbolSelector(RenderRule rule)
{
InitializeComponent();
this.rule = rule;
comboBox.ItemsSource = list;
polygonsymbolizer polygonsymbolizer = (polygonsymbolizer)rule.geometrysymbolizer;
textBox.Text = polygonsymbolizer.strokewidth.ToString();
outlineColor.Fill = new SolidColorBrush((Color)polygonsymbolizer.strokecolor);
solidColor.Fill = new SolidColorBrush((Color)polygonsymbolizer.fillcolor);
comboBox.SelectedIndex = (int)polygonsymbolizer.polygonstyle - 1;
}
public PointSymbolSelector(RenderRule rule)
{
InitializeComponent();
comboBox.ItemsSource = pointstyle;
this.rule = rule;
pointsymbolizer pointsymbolizer = (pointsymbolizer)rule.geometrysymbolizer;
textBox.Text = pointsymbolizer.size.ToString();
outlineColor.Visibility = Visibility.Collapsed;
outlineLabel.Visibility = Visibility.Collapsed;
solidColor.Fill = new SolidColorBrush((Color)pointsymbolizer.color);
SetPointStyle(pointsymbolizer.pointstyle);
}
protected internal override void MouseMove(MouseEventArgs e)
{
if (!_isPressed)
{
return;
}
lock (RenderRule) {
RenderRule.SetTextCursor(
new Point(
e.Location.X - RenderRule.Area.X,
e.Location.Y - RenderRule.Area.Y));
}
}
public ChunkElement(int x, int y, int width, int height, WidgetMouseEvent onClick)
{
Area = new Rectangle(x, y, width, height);
RenderRule.SetSize(width, height);
OnClick += onClick;
m_Attributes = new byte[TilesTotal];
m_Tiles = new byte[TilesTotal][];
m_Textures = new Texture2D[TilesTotal][];
for (int i = 0; i < TilesTotal; i++)
{
m_Tiles[i] = new byte[4];
m_Textures[i] = new Texture2D[4];
}
}
public TilesetAllInOne(int x, int y, int width, int height, WidgetEvent onClick)
{
Area = new Rectangle(x, y, width, height);
RenderRule.SetSize(width, height);
OnClick += onClick;
m_Attributes = new byte[Data.TileSet.TilesPerSet];
m_Tiles = new byte[Data.TileSet.TilesPerSet][];
m_Textures = new Texture2D[Data.TileSet.TilesPerSet][];
for (int i = 0; i < Data.TileSet.TilesPerSet; i++)
{
m_Tiles[i] = new byte[4];
m_Textures[i] = new Texture2D[4];
}
}
protected internal override void MouseMove(MouseEventArgs e)
{
RenderRule.HighlightItem = -1;
if (!IsToggled)
{
return;
}
var number = RenderRule.GetItem(e.Location);
if (number.HasValue)
{
RenderRule.HighlightItem = number.Value;
}
}
private void Resize()
{
var size = RenderRule.Font.MeasureString(RenderRule.Label);
if (RenderRule.Image != null)
{
Area = new Rectangle(Area.X, Area.Y,
(int)size.X + Padding + RenderRule.Image.Width,
(size.Y > RenderRule.Image.Height) ? (int)size.Y : RenderRule.Image.Height);
}
else
{
Area = new Rectangle(Area.X, Area.Y, (int)size.X, (int)size.Y);
}
RenderRule.SetSize(Area.Width, Area.Height);
}
public MetaTile(int index, int x, int y, int width, int height, WidgetMouseEvent onClick, int tiles_width = 2, int tiles_height = 2)
{
m_TilesWidth = tiles_width;
m_TilesHeight = tiles_height;
int tilecount = tiles_width * tiles_height;
m_Tiles = new byte[tilecount];
m_Textures = new Texture2D[tilecount];
m_FlipH = new bool[tilecount];
m_FlipV = new bool[tilecount];
m_TileIndex = index;
Area = new Rectangle(x, y, width, height);
RenderRule.SetSize(width, height);
m_OnClick += onClick;
}
public SymbolSelector(RenderRule rule)
{
InitializeComponent();
this.rule = rule;
switch (rule.geometrysymbolizer.sign)
{
case SymbolizerType.POINT:
pointsymbolizer pointsymbolizer = (pointsymbolizer)rule.geometrysymbolizer;
textBox.Text = pointsymbolizer.size.ToString();
outlineColor.Visibility = Visibility.Collapsed;
outlineLabel.Visibility = Visibility.Collapsed;
solidColor.Fill = new SolidColorBrush((Color)pointsymbolizer.color);
break;
case SymbolizerType.LINE:
linesymbolizer linesymbolizer = (linesymbolizer)rule.geometrysymbolizer;
textBox.Text = linesymbolizer.width.ToString();
outlineColor.Visibility = Visibility.Collapsed;
outlineLabel.Visibility = Visibility.Collapsed;
solidColor.Fill = new SolidColorBrush((Color)linesymbolizer.color);
break;
case SymbolizerType.POLYGON:
polygonsymbolizer polygonsymbolizer = (polygonsymbolizer)rule.geometrysymbolizer;
textBox.Text = polygonsymbolizer.strokewidth.ToString();
outlineColor.Fill = new SolidColorBrush((Color)polygonsymbolizer.strokecolor);
solidColor.Fill = new SolidColorBrush((Color)polygonsymbolizer.fillcolor);
break;
case SymbolizerType.TEXT:
break;
}
//if (symbol.brush == null)
//{
// outlineColor.Visibility = Visibility.Collapsed;
// outlineLabel.Visibility = Visibility.Collapsed;
// solidColor.Fill = symbol.pen.Brush;
// return;
//}
//outlineColor.Fill = symbol.pen.Brush;
//solidColor.Fill = symbol.brush;
}
private void dataGrid_MouseDoubleClick(object sender, MouseButtonEventArgs e)
{
int id = dataGrid.SelectedIndex;
if (id != -1)
{
RenderRule rule = list[id].rule;
switch (rule.geometrysymbolizer.sign)
{
case SymbolizerType.POINT:
PointSymbolSelector form_point = new PointSymbolSelector(rule);
if (form_point.ShowDialog() == true)
{
list[id].brush = form_point.brush;
list[id].rule = form_point.rule;
dataGrid.Items.Refresh();
}
break;
case SymbolizerType.POLYGON:
PolygonSymbolSelector form_polygon = new PolygonSymbolSelector(rule);
if (form_polygon.ShowDialog() == true)
{
list[id].brush = form_polygon.brush;
list[id].rule = form_polygon.rule;
dataGrid.Items.Refresh();
}
break;
default:
SymbolSelector form = new SymbolSelector(rule);
if (form.ShowDialog() == true)
{
list[id].brush = form.brush;
list[id].rule = form.rule;
dataGrid.Items.Refresh();
}
break;
}
}
//int id = Convert.ToInt32(((System.Windows.Shapes.Rectangle)e.Source).Name);
}
internal override void Layout()
{
// Pixel size of panel to contain child widgets
var outerArea = BuildContainerRenderArea();
RenderRule.BuildBars(outerArea);
foreach (var widget in Children)
{
widget.AbsoluteArea = new Rectangle(
widget.Area.X + AbsoluteInputArea.X - (int)(RenderRule.Horizontal.ChildOffset),
widget.Area.Y + AbsoluteInputArea.Y - (int)(RenderRule.Vertical.ChildOffset),
widget.Area.Width,
widget.Area.Height);
widget.SissorArea = AbsoluteInputArea;
if (Parent != null)
{
widget.SissorArea = Rectangle.Intersect(widget.SissorArea, SissorArea);
}
}
base.Layout();
}
protected internal override void MouseUp(InputEventMouse e)
{
if (IsToggled)
{
int?value = RenderRule.GetItem(e.Position);
if (value.HasValue && value != _selectedItem)
{
_selectedItem = RenderRule.GetItem(e.Position);
if (_selectedItem.HasValue)
{
if (_dropDownItems[_selectedItem.Value].OnClick != null)
{
_dropDownItems[_selectedItem.Value].OnClick(this);
}
Icon = _dropDownItems[_selectedItem.Value].Item.Item1;
Label = _dropDownItems[_selectedItem.Value].Item.Item2;
if (OnSelectionChanged != null)
{
OnSelectionChanged(this);
}
}
}
}
}
private void paintMutiLinebyRule(Graphics g, Graphics text_g, Feature feature, RenderRule rule, RSTransform rstransform)
{
}
protected internal override void OnLayout()
{
Area = new Rectangle(0, 0, (Parent == null) ? Owner.ScreenBounds.Width : Parent.InputArea.Width, Height);
RenderRule.SetSize(Area.Width, Area.Height);
}
