/// <summary>
/// Renders a MenuItem.
/// </summary>
protected virtual void RenderItem(MenuDropDown control, MenuItem item, PaintEventArgs e)
{
// Background
var background_color = item.Hovered || item.IsDropDownOpened ? Theme.ItemHighlightColor : Theme.LightTextColor;
e.Canvas.FillRectangle(item.Bounds, background_color);
// Image
if (item.Image != null)
{
var image_size = e.LogicalToDeviceUnits(16);
var image_bounds = DrawingExtensions.CenterSquare(item.Bounds, image_size);
var image_rect = new Rectangle(item.Bounds.Left + e.LogicalToDeviceUnits(6), image_bounds.Top, image_size, image_size);
e.Canvas.DrawBitmap(item.Image, image_rect, !item.Enabled);
}
// Text
var font_color = item.Enabled ? Theme.PrimaryTextColor : Theme.DisabledTextColor;
var font_size = e.LogicalToDeviceUnits(Theme.FontSize);
var bounds = item.Bounds;
bounds.X += e.LogicalToDeviceUnits(28);
e.Canvas.DrawText(item.Text, Theme.UIFont, font_size, bounds, font_color, ContentAlignment.MiddleLeft);
// Dropdown Arrow
if (item.HasItems)
{
var arrow_bounds = DrawingExtensions.CenterSquare(item.Bounds, 16);
var arrow_area = new Rectangle(item.Bounds.Right - e.LogicalToDeviceUnits(16) - 4, arrow_bounds.Top, 16, 16);
ControlPaint.DrawArrowGlyph(e, arrow_area, font_color, ArrowDirection.Right);
}
}
protected override void OnPaint(PaintEventArgs e)
{
base.OnPaint(e);
if (IsHovering)
{
e.Canvas.Clear(glyph == TitleBarButtonGlyph.Close ? Theme.FormCloseHighlightColor : Theme.HighlightColor);
}
var glyph_bounds = glyph == TitleBarButtonGlyph.Minimize ?
DrawingExtensions.CenterRectangle(DisplayRectangle, e.LogicalToDeviceUnits(new Size(BUTTON_PADDING, 1))) :
DrawingExtensions.CenterSquare(DisplayRectangle, e.LogicalToDeviceUnits(BUTTON_PADDING));
switch (glyph)
{
case TitleBarButtonGlyph.Close:
ControlPaint.DrawCloseGlyph(e, glyph_bounds);
break;
case TitleBarButtonGlyph.Minimize:
ControlPaint.DrawMinimizeGlyph(e, glyph_bounds);
break;
case TitleBarButtonGlyph.Maximize:
ControlPaint.DrawMaximizeGlyph(e, glyph_bounds);
break;
}
}
/// <summary>
/// Renders a ListViewItem.
/// </summary>
protected virtual void RenderItem(ListView control, ListViewItem item, PaintEventArgs e)
{
if (item.Selected)
{
e.Canvas.FillRectangle(item.Bounds, Theme.ItemHighlightColor);
}
var image_size = e.LogicalToDeviceUnits(32);
var image_area = new Rectangle(item.Bounds.Left, item.Bounds.Top, item.Bounds.Width, item.Bounds.Width);
var image_bounds = DrawingExtensions.CenterSquare(image_area, image_size);
image_bounds.Y = item.Bounds.Top + e.LogicalToDeviceUnits(3);
if (item.Image != null)
{
e.Canvas.DrawBitmap(item.Image, image_bounds);
}
if (!string.IsNullOrWhiteSpace(item.Text))
{
var font_size = e.LogicalToDeviceUnits(Theme.ItemFontSize);
e.Canvas.Save();
e.Canvas.Clip(item.Bounds);
var text_bounds = new Rectangle(item.Bounds.Left, image_bounds.Bottom + e.LogicalToDeviceUnits(3), item.Bounds.Width, item.Bounds.Bottom - image_bounds.Bottom - e.LogicalToDeviceUnits(3));
e.Canvas.DrawText(item.Text, Theme.UIFont, font_size, text_bounds, Theme.PrimaryTextColor, ContentAlignment.MiddleCenter);
e.Canvas.Restore();
}
}
/// <summary>
/// Insert an item which is known to be contained in the tree rooted at
/// the given QuadNode root. Lower levels of the tree will be created
/// if necessary to hold the item.
/// </summary>
private void InsertContained(Node <TItem> tree, Rectangle itemEnv, TItem item)
{
if (!DrawingExtensions.Contains(tree.Envelope, itemEnv))
{
throw new Exception();
}
/*
* Do NOT create a new quad for zero-area envelopes - this would lead
* to infinite recursion. Instead, use a heuristic of simply returning
* the smallest existing quad containing the query
*/
var itemEnvX = itemEnv.X;
var itemEnvR = itemEnvX + itemEnv.Width;
var itemEnvY = itemEnv.Y;
var itemEnvB = itemEnvY + itemEnv.Height;
var isZeroX = DoubleBits.IsZeroWidth(itemEnvX, itemEnvR);
var isZeroY = DoubleBits.IsZeroWidth(itemEnvY, itemEnvB);
NodeBase <TItem> node;
if (isZeroX || isZeroY)
{
node = tree.Find(itemEnv);
}
else
{
node = tree.GetNode(itemEnv);
}
node.AddItem(item);
}
/// <summary>
/// Insert an item into the quadtree this is the root of.
/// </summary>
public virtual void Add(Rectangle itemEnv, TItem item)
{
var index = GetSubnodeIndex(itemEnv, origin);
// if index is none, itemEnv must cross the X or Y axis.
if (index == none)
{
AddItem(item);
return;
}
/*
* the item must be contained in one quadrant, so insert it into the
* tree for that quadrant (which may not yet exist)
*/
var node = Subnodes[index];
/*
* If the subquad doesn't exist or this item is not contained in it,
* have to expand the tree upward to contain the item.
*/
if (node == null || !DrawingExtensions.Contains(node.Envelope, itemEnv))
{
var largerNode = Node <TItem> .Create(node, itemEnv);
largerNode.QuadItems = this.QuadItems;
Subnodes[index] = largerNode;
}
/*
* At this point we have a subquad which exists and must contain
* contains the env for the item. Insert the item into the tree.
*/
InsertContained(Subnodes[index], itemEnv, item);
}
private void DrawUserInterface()
{
var mainSplitBasicBoxes = GetMainSplitBasicBoxes();
var messageToDriverBasicBoxes = GetMessageToDriverBasicBoxes();
var carFaultsBasicBoxes = GetCarFaultsBasicBoxes();
var topPosition = 0;
var leftPosition = 1;
CheckIfConsoleSizeChanged();
RefreshConsoleIfEventTriggered();
if (mainSplitBasicBoxes.Any())
{
topPosition = DrawingExtensions.DrawBasicBoxes(leftPosition, topPosition + 2, mainSplitBasicBoxes,
Color.Orange, Color.Aqua);
}
if (messageToDriverBasicBoxes.Any())
{
topPosition = DrawingExtensions.DrawBasicBoxes(leftPosition, topPosition + 2, messageToDriverBasicBoxes,
Color.Blue, Color.Aqua);
}
if (carFaultsBasicBoxes.Any())
{
DrawingExtensions.DrawBasicBoxes(leftPosition, topPosition + 2, carFaultsBasicBoxes, Color.Blue,
Color.Aqua);
}
}
/// <summary>
/// Renders a MenuItem.
/// </summary>
protected virtual void RenderItem(Ribbon control, RibbonTabPage tabPage, RibbonItemGroup group, MenuItem item, PaintEventArgs e)
{
var canvas = e.Canvas;
var padding = e.LogicalToDeviceUnits(item.Padding);
var background_color = item.Selected ? Theme.ItemSelectedColor : item.Hovered ? Theme.ItemHighlightColor : Theme.NeutralGray;
canvas.FillRectangle(item.Bounds, background_color);
var image_area_bounds = new Rectangle(item.Bounds.Left + padding.Left, item.Bounds.Top + padding.Top, item.Bounds.Width - padding.Horizontal, e.LogicalToDeviceUnits(MINIMUM_ITEM_SIZE));
var final_image_bounds = DrawingExtensions.CenterSquare(image_area_bounds, e.LogicalToDeviceUnits(IMAGE_SIZE));
if (item.Image != null)
{
canvas.DrawBitmap(item.Image, final_image_bounds, !item.Enabled);
}
if (!string.IsNullOrWhiteSpace(item.Text))
{
var font_size = e.LogicalToDeviceUnits(Theme.ItemFontSize);
canvas.Save();
canvas.Clip(item.Bounds);
var text_bounds = new Rectangle(item.Bounds.Left, image_area_bounds.Bottom, item.Bounds.Width, item.Bounds.Bottom - image_area_bounds.Bottom);
canvas.DrawText(item.Text, Theme.UIFont, font_size, text_bounds, item.Enabled ? Theme.PrimaryTextColor : Theme.DisabledTextColor, ContentAlignment.MiddleCenter);
canvas.Restore();
}
}
private void printCopyright()
{
using (var font = new Font(CopyrightFontName, CopyrightFontSize, FontStyle.Regular, GraphicsUnit.Pixel))
{
var copyrightSize = DrawingExtensions.MeasureString(CopyrightText, font);
var copyrightLeftMargin = (int)(_image.Width - (BingLogoRightMargin + copyrightSize.Width + 5));
printPoint(new Point(copyrightLeftMargin, _image.Height - 120), CopyrightText, (int)copyrightSize.Width + 20, CopyrightFontSize, null, isRtl: false, customFont: font);
}
}
public static void AddLargeIconToCache(string extension, byte[] imageContents)
{
string ext = extension.ToLower();
if (!m_cachedLargeIcons.ContainsKey(ext))
{
m_cachedLargeIcons.Add(ext, DrawingExtensions.ToBitmap(imageContents));
}
}
public static CircularCloudLayouter GetRandomLayouter(int canvasSideLength)
{
var halfLength = canvasSideLength / 2;
var fourthLength = canvasSideLength / 4;
var center = new Point(halfLength, halfLength);
var size = new Size(fourthLength, fourthLength);
return(new CircularCloudLayouter(
GetRandomPoint(DrawingExtensions.CreateRectangleWithCenter(center, size))));
}
public virtual Size GetObjectDimension(object value, IStyle style)
{
var result = new Size();
if (!DrawingExtensions.TryGetObjectDimension(value, style, out result))
{
return(Size.Zero);
}
return(result);
}
private void printPoint(
Point point, string dayText, int cellWidth, Color?fillColor = null,
bool isRtl = true, bool applyDarkerColor = false)
{
var pointX = point.X;
var pointY = point.Y;
var cellHeight = _cellHeight;
var textHeight = measureString(dayText).Height;
if (textHeight > cellHeight)
{
cellHeight = (int)textHeight + 20;
pointY -= cellHeight - _cellHeight;
}
var color = fillColor == null?
Color.FromArgb(alpha : 190, baseColor : _avgColor) :
Color.FromArgb(alpha: 110, baseColor: fillColor.Value);
if (applyDarkerColor)
{
color = color.ChangeColorBrightness(-0.12f);
}
var rectangle = new Rectangle(pointX, pointY, cellWidth, cellHeight);
DrawingExtensions.DrawRoundedRectangle(_graphics, rectangle, 15, new Pen(color)
{
Width = 1.1f
}, color);
var stringFormat = new StringFormat
{
LineAlignment = StringAlignment.Center,
Alignment = StringAlignment.Center,
FormatFlags = isRtl ? StringFormatFlags.DirectionRightToLeft : StringFormatFlags.NoClip
};
_graphics.TextRenderingHint = TextRenderingHint.AntiAlias;
var textColor = color.Brightness() < 140 ? Color.White : Color.Black;
using (var privateFontCollection = new PrivateFontCollection())
{
privateFontCollection.AddFontFile(getFontPath());
using (var fontFamily = privateFontCollection.Families[0])
{
using (var calendarFont = new Font(fontFamily, CalendarFontSize, FontStyle.Regular, GraphicsUnit.Pixel))
{
_graphics.DrawString(dayText, calendarFont, new SolidBrush(textColor), rectangle, stringFormat);
}
}
}
}
public static SpiralLayouter GetRandomLayouter(int canvasSideLength, ITagFactory factory)
{
var halfLength = canvasSideLength / 2;
var fourthLength = canvasSideLength / 4;
var center = new Point(halfLength, halfLength);
var size = new Size(fourthLength, fourthLength);
return(new SpiralLayouter(
GetRandomPoint(DrawingExtensions.CreateRectangleWithCenter(center, size)),
factory));
}
/// <summary>
/// Return a square envelope containing the argument envelope,
/// whose extent is a power of two and which is based at a power of 2.
/// </summary>
/// <param name="itemEnv"></param>
public virtual void ComputeKey(Rectangle itemEnv)
{
_level = ComputeQuadLevel(itemEnv);
_env = new Rectangle();
ComputeKey(_level, itemEnv);
// MD - would be nice to have a non-iterative form of this algorithm
while (!DrawingExtensions.Contains(_env, itemEnv))
{
_level += 1;
ComputeKey(_level, itemEnv);
}
}
/// <summary>
/// Gets the bounds of the item image.
/// </summary>
protected virtual Rectangle GetImageBounds(TreeView control, TreeViewItem item, PaintEventArgs e)
{
if (!control.ShowItemImages || item.Image is null)
{
return(Rectangle.Empty);
}
var left_index = control.ShowDropdownGlyph ? GetGlyphBounds(control, item).Right : GetIndentStart(control, item);
var image_area = new Rectangle(left_index, item.Bounds.Top, item.Bounds.Height, item.Bounds.Height);
return(DrawingExtensions.CenterSquare(image_area, e.LogicalToDeviceUnits(IMAGE_SIZE)));
}
/// <inheritdoc/>
protected override void Render(FormTitleBar control, PaintEventArgs e)
{
// Form icon
if (control.Image != null)
{
var icon_glyph_bounds = DrawingExtensions.CenterSquare(GetIconBounds(control), e.LogicalToDeviceUnits(FORM_ICON_SIZE));
e.Canvas.DrawBitmap(control.Image, icon_glyph_bounds);
}
// Form text
e.Canvas.DrawText(control.Text.Trim(), Theme.UIFont, e.LogicalToDeviceUnits(Theme.FontSize), GetTitleBounds(control), Theme.LightTextColor, ContentAlignment.MiddleCenter);
// Minimize button
if (control.AllowMinimize)
{
var minimize_button_bounds = GetMinimizeButtonBounds(control);
if (control.HoverElement == FormTitleBar.FormTitleBarElement.Minimize)
{
e.Canvas.FillRectangle(minimize_button_bounds, Theme.HighlightColor);
}
var min_glyph_bounds = DrawingExtensions.CenterRectangle(minimize_button_bounds, e.LogicalToDeviceUnits(new Size(BUTTON_PADDING, 1)));
ControlPaint.DrawMinimizeGlyph(e, min_glyph_bounds);
}
// Maximize button
if (control.AllowMaximize)
{
var maximize_button_bounds = GetMaximizeButtonBounds(control);
if (control.HoverElement == FormTitleBar.FormTitleBarElement.Maximize)
{
e.Canvas.FillRectangle(maximize_button_bounds, Theme.HighlightColor);
}
var max_glyph_bounds = DrawingExtensions.CenterSquare(maximize_button_bounds, e.LogicalToDeviceUnits(BUTTON_PADDING));
ControlPaint.DrawMaximizeGlyph(e, max_glyph_bounds);
}
// Close button
var close_button_bounds = GetCloseButtonBounds(control);
if (control.HoverElement == FormTitleBar.FormTitleBarElement.Close)
{
e.Canvas.FillRectangle(close_button_bounds, Theme.FormCloseHighlightColor);
}
var close_glyph_bounds = DrawingExtensions.CenterSquare(close_button_bounds, e.LogicalToDeviceUnits(BUTTON_PADDING));
ControlPaint.DrawCloseGlyph(e, close_glyph_bounds);
}
private void printCopyright()
{
SizeF copyrightSize;
using (var font = new Font(CopyrightFontName, CopyrightFontSize))
{
copyrightSize = DrawingExtensions.MeasureString(CopyrightText, font);
}
var copyrightLeftMargin = (int)(_image.Width - (BingLogoRightMargin + copyrightSize.Width + 5));
printPoint(new Point(copyrightLeftMargin, _image.Height - 120), CopyrightText, (int)copyrightSize.Width + 10, null, isRtl: false);
}
/// <summary>
/// Gets the bounds of the dropdown glyph.
/// </summary>
public virtual Rectangle GetGlyphBounds(TreeView control, TreeViewItem item)
{
if (!control.ShowDropdownGlyph)
{
return(Rectangle.Empty);
}
var glyph_area = new Rectangle(GetIndentStart(control, item), item.Bounds.Top, control.LogicalToDeviceUnits(GLYPH_SIZE), item.Bounds.Height);
var glyph_bounds = DrawingExtensions.CenterSquare(glyph_area, control.LogicalToDeviceUnits(GLYPH_SIZE));
glyph_bounds.Width = control.LogicalToDeviceUnits(GLYPH_SIZE);
return(glyph_bounds);
}
public virtual void InvalidateShapeOutline(IShape oldShape, IShape newShape)
{
if (oldShape != null)
{
int halfborder = GripSize + 1;
var a = oldShape.BoundsRect;
var b = newShape.BoundsRect;
if (a.IsEmpty && b.IsEmpty)
{
return;
}
var bigger = DrawingExtensions.Union(a, b);
bigger = Camera.FromSource(bigger);
bigger = bigger.NormalizedRectangle();
if (bigger.Width <= halfborder || bigger.Height <= halfborder)
{
bigger = bigger.Inflate(halfborder, halfborder);
Backend.QueueDraw(bigger);
Backend.Update();
}
else
{
bigger = bigger.Inflate(halfborder, halfborder);
var smaller = DrawingExtensions.Intersect(a, b);
smaller = Camera.FromSource(smaller);
smaller = smaller.NormalizedRectangle();
smaller = smaller.Inflate(-halfborder, -halfborder);
Backend.QueueDraw(
Rectangle.FromLTRB(bigger.Left, bigger.Top, bigger.Right, smaller.Top).NormalizedRectangle());
Backend.QueueDraw(
Rectangle.FromLTRB(bigger.Left, smaller.Bottom, bigger.Right, bigger.Bottom).NormalizedRectangle());
Backend.QueueDraw(
Rectangle.FromLTRB(bigger.Left, smaller.Top, smaller.Left, smaller.Bottom).NormalizedRectangle());
Backend.QueueDraw(
Rectangle.FromLTRB(smaller.Right, smaller.Top, bigger.Right, smaller.Bottom).NormalizedRectangle());
}
}
}
/// <param name="env"></param>
/// <returns></returns>
/// <summary>
///
/// </summary>
/// <param name="node"></param>
/// <param name="addEnv"></param>
/// <returns></returns>
public static Node <TItem> Create(Node <TItem> node, Rectangle addEnv)
{
var expandEnv = new Rectangle(addEnv.Location, addEnv.Size);
if (node != null)
{
expandEnv = DrawingExtensions.Union(expandEnv, node._envelope);
}
var largerNode = CreateNode(expandEnv);
if (node != null)
{
largerNode.QuadItems = node.QuadItems;
largerNode.InsertNode(node);
}
return(largerNode);
}
public virtual IEnumerable <IVisual> Query(Rectangle clipBounds, ZOrder zOrder)
{
IEnumerable <IVisual> search = GeoIndex.Query(clipBounds);
if (zOrder == ZOrder.EdgesFirst)
{
foreach (var visual in search)
{
if (visual is IVisualEdge)
{
if (DrawingExtensions.Intersects(clipBounds, visual.Shape.BoundsRect))
{
yield return(visual);
}
}
}
}
foreach (var visual in search)
{
if (!(visual is IVisualEdge))
{
if (DrawingExtensions.Intersects(clipBounds, visual.Shape.BoundsRect))
{
yield return(visual);
}
}
}
if (zOrder == ZOrder.NodesFirst)
{
foreach (var visual in search)
{
if (visual is IVisualEdge)
{
if (DrawingExtensions.Intersects(clipBounds, visual.Shape.BoundsRect))
{
yield return(visual);
}
}
}
}
}
public override void Render(IGraphScene <TItem, TEdge> data, IRenderEventArgs e)
{
var camera = this.Camera();
var clipBounds = camera.ToSource(e.Clipper.Bounds);
#if TraceRender
Trace.WriteLine($"\t{nameof(Render)}.{nameof(clipBounds)}:\t{clipBounds}");
//+"\toffset(g)"+new SizeS(g.Transform.OffsetX, g.Transform.OffsetY)
#endif
var focused = data.Focused;
var hovered = data.Hovered;
var layout = this.Layout();
ItemRenderer.Layout = this.Layout;
foreach (var item in data.ElementsIn(clipBounds, ZOrder.EdgesFirst))
{
bool rendered = true;
if (!item.Equals(focused) && !item.Equals(hovered))
{
ItemRenderer.Render(item, e);
#if countVisuals
if (rendered)
{
iItems++;
}
#endif
}
}
if (hovered != null && DrawingExtensions.Intersects(clipBounds, layout.GetShape(hovered).BoundsRect))
{
ItemRenderer.Render(hovered, e);
}
if (focused != null && layout.GetShape(focused) != null && DrawingExtensions.Intersects(clipBounds, layout.GetShape(focused).BoundsRect))
{
ItemRenderer.Render(focused, e);
}
}
public IStyleGroup CreateStyleGroup(string name, IStyle parentStyle, bool forEdge)
{
var styleGroup = new StyleGroup(name, parentStyle);
var defaultStyle = new Style(name + ".Default", styleGroup);
styleGroup.DefaultStyle = defaultStyle;
styles[defaultStyle.Name] = defaultStyle;
var selectedStyle = new Style(name + ".Selected", styleGroup);
styleGroup.SelectedStyle = selectedStyle;
styles[selectedStyle.Name] = selectedStyle;
var hoveredStyle = new Style(name + ".Hovered", styleGroup);
styleGroup.HoveredStyle = hoveredStyle;
styles[hoveredStyle.Name] = hoveredStyle;
if (!forEdge)
{
selectedStyle.FillColor = DrawingExtensions.FromArgb(200, this.ParentStyle.FillColor);
hoveredStyle.FillColor = DrawingExtensions.FromArgb(200, this.ParentStyle.FillColor);
}
else
{
defaultStyle.PaintData = false;
defaultStyle.Font = CreateFont(
this.ParentStyle.Font.Family,
this.ParentStyle.Font.Size - 2).WithStyle(FontStyle.Italic);
selectedStyle.LineWidth = styleGroup.DefaultStyle.LineWidth * 2;
selectedStyle.PaintData = true;
hoveredStyle.StrokeColor = DrawingExtensions.FromArgb(150, styleGroup.DefaultStyle.StrokeColor);
hoveredStyle.PaintData = true;
}
return(styleGroup);
}
public virtual Image ExportImage()
{
if (Data == null)
{
return(null);
}
var size = Data.Shape.Size + new Size(Layout.Border.Width, Layout.Border.Height);
var f = DrawingExtensions.DpiFactor(new Size(72, 72));
this.Viewport.ClipOrigin = Data.Shape.Location;
var clipRect = new Rectangle(0, 0, (int)size.Width, (int)size.Height);
// Create image
var result = new Bitmap((int)(size.Width * f.Width), (int)(size.Height * f.Height), PixelFormat.Format32bppArgb);
var g = Graphics.FromImage(result);
g.PageUnit = GraphicsUnit.Point;
Paint(g, clipRect);
return(result);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public virtual void InsertNode(Node <TItem> node)
{
if (!(_envelope == default(Rectangle) ||
DrawingExtensions.Contains(_envelope, node.Envelope)))
{
throw new Exception();
}
int index = GetSubnodeIndex(node._envelope, _centre);
if (node.level == level - 1)
{
Subnodes[index] = node;
}
else
{
// the quad is not a direct child, so make a new child quad to contain it
// and recursively insert the quad
var childNode = CreateSubnode(index);
childNode.InsertNode(node);
Subnodes[index] = childNode;
}
}
public Color ToColor(byte alpha)
{
return(DrawingExtensions.ColorFromHSL(alpha, this.Hue, this.Saturation, this.Luminance));
}
/// <summary>
/// Calculate new bounds during interactive moving or resizing
/// </summary>
/// <param name="subItem"></param>
/// <param name="mousePoint"></param>
protected void CalculateNewBounds(ChildItem subItem, Point mousePoint)
{
Rectangle originalBounds = this.BoundsDragOrigin.Value;
Rectangle draggedBounds = originalBounds;
Point begin = originalBounds.Location;
Point end = originalBounds.End();
bool ctrl = Control.ModifierKeys == Keys.Control;
switch (subItem.ItemType)
{
case ChildItemType.Area:
case ChildItemType.Border:
if (ctrl)
{
Point d = begin.Sub(mousePoint);
if (Math.Abs(d.X) >= Math.Abs(d.Y))
{
mousePoint = new Point(mousePoint.X, originalBounds.Y);
}
else
{
mousePoint = new Point(originalBounds.X, mousePoint.Y);
}
}
draggedBounds = new Rectangle(mousePoint, originalBounds.Size);
break;
case ChildItemType.TopLeft:
draggedBounds = DrawingExtensions.FromDim(mousePoint.X, end.X, mousePoint.Y, end.Y);
break;
case ChildItemType.Top:
draggedBounds = DrawingExtensions.FromDim(begin.X, end.X, mousePoint.Y, end.Y);
break;
case ChildItemType.TopRight:
draggedBounds = DrawingExtensions.FromDim(begin.X, mousePoint.X, mousePoint.Y, end.Y);
break;
case ChildItemType.Right:
draggedBounds = DrawingExtensions.FromDim(begin.X, mousePoint.X, begin.Y, end.Y);
break;
case ChildItemType.BottomRight:
draggedBounds = DrawingExtensions.FromDim(begin.X, mousePoint.X, begin.Y, mousePoint.Y);
break;
case ChildItemType.Bottom:
draggedBounds = DrawingExtensions.FromDim(begin.X, end.X, begin.Y, mousePoint.Y);
break;
case ChildItemType.BottomLeft:
draggedBounds = DrawingExtensions.FromDim(mousePoint.X, end.X, begin.Y, mousePoint.Y);
break;
case ChildItemType.Left:
draggedBounds = DrawingExtensions.FromDim(mousePoint.X, end.X, begin.Y, end.Y);
break;
}
this.SetBounds(draggedBounds, ProcessAction.PrepareInnerItems, EventSourceType.InteractiveChanging);
}
public Point CreateRectangleWithCenter(Point center, Size size)
{
return(DrawingExtensions.CreateRectangleWithCenter(center, size)
.Location);
}
private SizeF measureString(string text, int calendarFontSize)
{
var fontPath = getFontPath();
return(DrawingExtensions.MeasureString(text, calendarFontSize, FontStyle.Regular, fontPath));
}
public override IEnumerable <TItem> Query(Rectangle clipBounds)
{
return(GeoIndex.Query(clipBounds).Where(item => DrawingExtensions.Intersects(clipBounds, BoundsOf(item))));
}
