private void DrawString(string text, SimpleFont font, DXMediaBrush brush, double pointX, double pointY, DXMediaBrush areaBrush) { SharpDX.DirectWrite.TextFormat textFormat = font.ToDirectWriteTextFormat(); SharpDX.DirectWrite.TextLayout textLayout = new SharpDX.DirectWrite.TextLayout(NinjaTrader.Core.Globals.DirectWriteFactory, text, textFormat, ChartPanel.X + ChartPanel.W, textFormat.FontSize); float newW = textLayout.Metrics.Width; float newH = textLayout.Metrics.Height; SharpDX.Vector2 TextPlotPoint = new System.Windows.Point(pointX - newW, pointY - textLayout.Metrics.Height / 2 - 1).ToVector2(); SharpDX.RectangleF PLBoundRect = new SharpDX.RectangleF((float)pointX - newW - 4, (float)pointY - textLayout.Metrics.Height / 2 - 1, newW + 6, newH + 2); SharpDX.Direct2D1.RoundedRectangle PLRoundedRect = new SharpDX.Direct2D1.RoundedRectangle(); PLRoundedRect.RadiusX = newW / 4; PLRoundedRect.RadiusY = newH / 4; PLRoundedRect.Rect = PLBoundRect; RenderTarget.FillRoundedRectangle(PLRoundedRect, areaBrush.DxBrush); RenderTarget.DrawTextLayout(TextPlotPoint, textLayout, brush.DxBrush, SharpDX.Direct2D1.DrawTextOptions.NoSnap); textLayout.Dispose(); textLayout = null; textFormat.Dispose(); textFormat = null; }
public override void OnRender(ChartControl chartControl, ChartScale chartScale) { base.OnRender(chartControl, chartScale); InitializeDrawingTools(); //Calculate where to draw the text. //Refer to parent class Lines.cs OnRender method for more information. ChartPanel panel = chartControl.ChartPanels[chartScale.PanelIndex]; double strokePixAdj = ((double)(Stroke.Width % 2)).ApproxCompare(0) == 0 ? 0.5d : 0d; Vector pixelAdjustVec = new Vector(strokePixAdj, strokePixAdj); Point endPoint = EndAnchor.GetPoint(chartControl, panel, chartScale); Point endPointAdjusted = endPoint + pixelAdjustVec; SharpDX.Vector2 endVec = endPointAdjusted.ToVector2(); //Calculate the current price. string text = (Text != "" ? Text : chartControl.Instrument.MasterInstrument.FormatPrice(chartScale.GetValueByY(endVec.Y), true)); //Set properties for rectangle to draw the object. TextLayout tl = new TextLayout(Core.Globals.DirectWriteFactory, text, cachedTextFormat, ChartPanel.W, ChartPanel.H); SharpDX.RectangleF rect = new SharpDX.RectangleF(); rect.X = (float)endVec.X; rect.Y = (float)endVec.Y - 6f; rect.Width = (float)-(tl.Metrics.Width); rect.Height = (float)-(tl.Metrics.Height); //Draw the text. using (SharpDX.Direct2D1.Brush myDxBrush = TextColor.ToDxBrush(RenderTarget)) { chartScale.GetValueByY(endVec.Y); RenderTarget.DrawText(string.Format("{0}", text), cachedTextFormat, rect, myDxBrush); } }
// MH: 5-25 Disabled for now, can add option // ReSharper disable once UnusedMember.Local private void RenderPriceZones(ChartControl chartControl, ChartScale chartScale) { // add 10 bars of padding so that the drawn region extends past the visual area of the chart // but handle possible out of range exception by checking to see we even have enough bars for the padding to begin with int startX = chartControl.GetXByBarIndex(ChartBars, ChartBars.FromIndex >= 10 ? ChartBars.FromIndex - 10 : ChartBars.FromIndex); int sessionBeginX = chartControl.GetXByTime(sessionIterator.ActualSessionBegin); if (startX > sessionBeginX) { return; } float highPriceY = chartScale.GetYByValue(trueRangeHigh); float highLowDifference = chartScale.GetYByValue(trueRangeLow) - chartScale.GetYByValue(trueRangeHigh); SharpDX.RectangleF midZone = new SharpDX.RectangleF(sessionBeginX, highPriceY, startX - sessionBeginX, highLowDifference); SharpDX.RectangleF lowZone = new SharpDX.RectangleF(sessionBeginX, highPriceY + midZone.Height, startX - sessionBeginX, highLowDifference); SharpDX.RectangleF highZone = new SharpDX.RectangleF(sessionBeginX, highPriceY - midZone.Height, startX - sessionBeginX, highLowDifference); RenderTarget.FillRectangle(lowZone, redBrush.ToDxBrush(RenderTarget)); RenderTarget.FillRectangle(highZone, greenBrush.ToDxBrush(RenderTarget)); RenderTarget.FillRectangle(midZone, blueBrush.ToDxBrush(RenderTarget)); }
private void drawRow(ChartControl chartControl, ChartScale chartScale, double value, int quantity) { //Calculate color of this row. Brush brushColor = NormalColor; if (value <= MaxId + ValueArea && value >= MaxId - ValueArea) { brushColor = ValueColor; } //Calculate cell properties double y1 = ((chartScale.GetYByValue(value) + chartScale.GetYByValue(value + 1)) / 2) + 1; double y2 = ((chartScale.GetYByValue(value) + chartScale.GetYByValue(value - 1)) / 2) - 1; SharpDX.RectangleF rect = new SharpDX.RectangleF(); rect.X = (float)chartControl.CanvasRight; rect.Y = (float)y1; rect.Width = (float)((chartControl.CanvasLeft - chartControl.CanvasRight) * Math.Log(quantity) / Math.Log(Max)); rect.Height = (float)Math.Abs(y1 - y2); //Draw the row. using (SharpDX.Direct2D1.Brush rowBrush = brushColor.ToDxBrush(RenderTarget)) { RenderTarget.FillRectangle(rect, rowBrush); //RenderTarget.FillRectangle(rect, rowBrush); } if (rect.Height > this.MinimumTextHeight) { RenderTarget.DrawText(string.Format("{0}", quantity), textFormat, rect, TextColor.ToDxBrush(RenderTarget)); } }
private void RenderVolumeZones(ChartControl chartControl, ChartScale chartScale) { foreach (KeyValuePair <double, double> level in VolumeDictionary) { double price = level.Key; int volume = (int)level.Value; if (price > chartScale.MaxValue + TickSize || price < chartScale.MinValue - (TickSize * 1)) { continue; } int priceLower = chartScale.GetYByValue(price); int priceUpper = chartScale.GetYByValue(price + TickSize); int barHeight = Math.Max(1, Math.Abs(priceUpper - priceLower) - 1); maxVolume = Math.Max(volume, maxVolume); if (maxVolume < 1) // don't divide by zero { continue; } int maxWidth = ((int)maxVolume / 300); int barWidth = volume / maxWidth; int barX = (chartControl.CanvasRight - barWidth); int barY = (priceLower - barHeight); SharpDX.RectangleF rect = new SharpDX.RectangleF(barX, barY, barWidth, barHeight); RenderTarget.FillRectangle(rect, VolumeZoneBrush(price).ToDxBrush(RenderTarget)); } }
/// <summary> /// Draw the layer. /// </summary> /// <param name="renderTime">Time since last render.</param> /// <remarks>include base.Render(renderTime); in overloads to preserve updating RenderTime field.</remarks> public override void Render(RenderTime renderTime) { base.Render(renderTime); if (MM_Repository.OverallDisplay.MapTiles == MM_MapTile.enumMapType.None) { return; } var tx = Surface.RenderTarget2D.Transform; Surface.RenderTarget2D.Transform = SharpDX.Matrix3x2.Identity; BaseMapTileProxy backgroundTile; Point topLeftTile = MM_Coordinates.XYToTile(Surface.Coordinates.TopLeftXY); Point bottomRightTile = MM_Coordinates.XYToTile(Surface.Coordinates.BottomRightXY); Point topLeftTileShift = new Point(Surface.Coordinates.TopLeftXY.X % MM_Repository.OverallDisplay.MapTileSize.Width, Surface.Coordinates.TopLeftXY.Y % MM_Repository.OverallDisplay.MapTileSize.Height); int extraRadius = 4; SharpDX.RectangleF tileSourceRect = new SharpDX.RectangleF(0, 0, MM_Repository.OverallDisplay.MapTileSize.Width, MM_Repository.OverallDisplay.MapTileSize.Height); if (MM_Repository.OverallDisplay.MapTiles != MM_MapTile.enumMapType.None) { int startX = topLeftTile.X - extraRadius; int endX = bottomRightTile.X + extraRadius; int startY = topLeftTile.Y - extraRadius; int endY = bottomRightTile.Y + extraRadius; foreach (var thisTile in Spiral(topLeftTile, bottomRightTile, extraRadius)) { TileCoordinates tileCoord = new TileCoordinates(MM_Repository.OverallDisplay.MapTiles, thisTile, (int)Surface.Coordinates.ZoomLevel); if (TryGetTile(tileCoord, out backgroundTile)) { if (!backgroundTile.IsReady) { continue; } var targetRect = new SharpDX.RectangleF(((thisTile.X - topLeftTile.X) * MM_Repository.OverallDisplay.MapTileSize.Width) - topLeftTileShift.X, ((thisTile.Y - topLeftTile.Y) * MM_Repository.OverallDisplay.MapTileSize.Height) - topLeftTileShift.Y, MM_Repository.OverallDisplay.MapTileSize.Width, MM_Repository.OverallDisplay.MapTileSize.Height); Surface.RenderTarget2D.DrawBitmap(backgroundTile.Bitmap, targetRect, MM_Repository.OverallDisplay.MapTransparency, BitmapInterpolationMode.NearestNeighbor, tileSourceRect); } } //for (Point thisTile = new Point(topLeftTile.X - extraRadius, topLeftTile.Y - extraRadius); thisTile.X <= bottomRightTile.X + extraRadius; thisTile.X++, thisTile.Y = topLeftTile.Y) //{ // for (; thisTile.Y <= bottomRightTile.Y + extraRadius; thisTile.Y++) // { // TileCoordinates tileCoord = new TileCoordinates(MM_Repository.OverallDisplay.MapTiles, thisTile, (int)Surface.Coordinates.ZoomLevel); // if (TryGetTile(tileCoord, out backgroundTile)) // { // if (!backgroundTile.IsReady) continue; // // var targetRect = new SharpDX.RectangleF(((thisTile.X - topLeftTile.X) * MM_Repository.OverallDisplay.MapTileSize.Width) - topLeftTileShift.X, ((thisTile.Y - topLeftTile.Y) * MM_Repository.OverallDisplay.MapTileSize.Height) - topLeftTileShift.Y, MM_Repository.OverallDisplay.MapTileSize.Width, MM_Repository.OverallDisplay.MapTileSize.Height); // Surface.RenderTarget2D.DrawBitmap(backgroundTile.Bitmap, targetRect, MM_Repository.OverallDisplay.MapTransparency, BitmapInterpolationMode.NearestNeighbor, tileSourceRect); // } // } //} } Surface.RenderTarget2D.Transform = tx; }
static void SHDXOverlay_BeforeDrawingEvent(object sender, ExternalUtilsCSharp.UI.Overlay <SharpDXRenderer, SharpDX.Color, SharpDX.Vector2, TextFormat> .OverlayEventArgs e) { if (ranksBmp == null) { System.Drawing.Bitmap bmp = (System.Drawing.Bitmap)Resources.ResourceManager.GetObject("uc_exclusive"); try { ranksBmp = SDXBitmapFromSysBitmap(e.Overlay.Renderer.Device, bmp); } catch { } } else { SharpDX.RectangleF source = new SharpDX.RectangleF(0, 0, ranksBmp.PixelSize.Width, ranksBmp.PixelSize.Height); float mul = 1f + 0.2f * (float)Math.Sin(DateTime.Now.TimeOfDay.TotalSeconds * 0.5f); SharpDX.RectangleF dest = new SharpDX.RectangleF(e.Overlay.Width / 2f - source.Width / 2f * mul, e.Overlay.Height - source.Height * 2f * mul, source.Width * mul, source.Height * mul); e.Overlay.Renderer.Device.DrawBitmap(ranksBmp, dest, 0.9f, BitmapInterpolationMode.Linear, source); } if (ConfigUtils.GetValue <bool>("aimEnabled") && ConfigUtils.GetValue <bool>("aimDrawFov")) { float fov = ConfigUtils.GetValue <float>("aimFov"); SharpDX.Color foreColor = new SharpDX.Color(0.2f, 0.2f, 0.2f, 0.8f); SharpDX.Color backColor = new SharpDX.Color(0.8f, 0.8f, 0.8f, 0.9f); SharpDX.Vector2 size = new SharpDX.Vector2(e.Overlay.Width / 90f * fov); SharpDX.Vector2 center = new SharpDX.Vector2(e.Overlay.Width / 2f, e.Overlay.Height / 2f); e.Overlay.Renderer.DrawEllipse(foreColor, center, size, true, 3f); e.Overlay.Renderer.DrawEllipse(backColor, center, size, true); } }
public override SharpDX.RectangleF getRenderBounds() { if (shouldBoundsUpdate) { shouldBoundsUpdate = false; float maxY = Single.MinValue; float maxX = Single.MinValue; float minY = Single.MaxValue; float minX = Single.MaxValue; for (int i = 0; i < children.Count; i++) { SharpDX.RectangleF bounds = children[i].getRenderBounds(); if (maxY < bounds.Bottom) { maxY = bounds.Bottom; } if (minY > bounds.Top) { minY = bounds.Top; } if (maxX < bounds.Right) { maxX = bounds.Right; } if (minX > bounds.Left) { minX = bounds.Left; } } _width = maxX - minX; _height = maxY - minY; boundsCache = new SharpDX.RectangleF(minX, minY, maxX, maxY); } return(boundsCache); }
private void DrawText(ChartControl chartControl) { if (Font == null || string.IsNullOrEmpty(DisplayText)) { return; } Rect outLineRect = GetCurrentRect(layoutRect, outlinePadding); // this will add padding to layoutRect for us SharpDX.RectangleF outlineRectDx = new SharpDX.RectangleF((float)outLineRect.X, (float)outLineRect.Y, (float)outLineRect.Width, (float)outLineRect.Height); textBrushDevice.RenderTarget = RenderTarget; areaBrushDevice.RenderTarget = RenderTarget; OutlineStroke.RenderTarget = RenderTarget; SharpDX.Direct2D1.Brush tmpBrush; if (AreaBrush != null) { SolidColorBrush tmpOb = areaBrushDevice.Brush as SolidColorBrush; SolidColorBrush tmpNb = AreaBrush as SolidColorBrush; // if brush not set, set brush. else if brush set and changed, change brush. if not SolidColorBrush always change brush if (tmpNb == null || tmpOb == null || tmpOb.Color != tmpNb.Color || Math.Abs(tmpOb.Opacity - tmpNb.Opacity) > 0.1) { Brush brushCopy = AreaBrush.Clone(); brushCopy.Opacity = areaOpacity / 100d; areaBrushDevice.Brush = brushCopy; } areaBrushDevice.RenderTarget = RenderTarget; tmpBrush = IsInHitTest ? chartControl.SelectionBrush : areaBrushDevice.BrushDX; RenderTarget.FillRectangle(outlineRectDx, tmpBrush); } else { areaBrushDevice.RenderTarget = null; } if (OutlineStroke.StrokeStyle != null && (OutlineStroke.Brush != null || !OutlineStroke.Brush.IsTransparent())) { tmpBrush = IsInHitTest ? chartControl.SelectionBrush : OutlineStroke.BrushDX; if (tmpBrush != null) { RenderTarget.DrawRectangle(outlineRectDx, tmpBrush, OutlineStroke.Width, OutlineStroke.StrokeStyle); } } textBrushDevice.RenderTarget = RenderTarget; SolidColorBrush tmpOtb = textBrushDevice.Brush as SolidColorBrush; SolidColorBrush tmpNtb = TextBrush as SolidColorBrush; // if brush not set, set brush. else if brush set and changed, change brush. if not SolidColorBrush always change brush if (tmpNtb == null || tmpOtb == null || tmpOtb.Color != tmpNtb.Color || Math.Abs(tmpOtb.Opacity - tmpNtb.Opacity) > 0.1) { textBrushDevice.Brush = TextBrush; } // when drawing the actual text layout, add padding again, we dont want text right on the edges of our outline rect tmpBrush = IsInHitTest ? chartControl.SelectionBrush : textBrushDevice.BrushDX; RenderTarget.DrawTextLayout(new SharpDX.Vector2(outlineRectDx.X + outlinePadding, outlineRectDx.Y + outlinePadding), cachedTextLayout, tmpBrush, SharpDX.Direct2D1.DrawTextOptions.NoSnap); }
private bool CheckAdvansedFilter(int currentTab, RectangleF position, Entity itemClass) { foreach (var item in _filterItems) { if (!itemClass.Path.Contains(item.Type)) { continue; } var modsComponent = itemClass.GetComponent <Mods>(); if (item.ItemRarity < 4 && modsComponent != null && modsComponent.ItemRarity != (ItemRarity)item.ItemRarity) { return(false); } if (item.Tab != currentTab) { return(true); } if (!CheckIngoredCell(position)) { continue; } position.X += GameController.Window.GetWindowRectangle().X; position.Y += GameController.Window.GetWindowRectangle().Y; MouseClickCtrl(position.Center); return(true); } return(false); }
public override void OnRender(ChartControl chartControl, ChartScale chartScale) { LineColor.RenderTarget = RenderTarget; // first of all, turn on anti-aliasing to smooth out our line RenderTarget.AntialiasMode = SharpDX.Direct2D1.AntialiasMode.PerPrimitive; ChartPanel panel = chartControl.ChartPanels[chartScale.PanelIndex]; // draw a line from start measure point to end measure point. Point lineStartPoint = StartAnchor.GetPoint(chartControl, panel, chartScale); Point lineEndPoint = EndAnchor.GetPoint(chartControl, panel, chartScale); // align to full pixel to avoid unneeded aliasing double strokePixAdjust = (LineColor.Width % 2).ApproxCompare(0) == 0 ? 0.5d : 0d; Vector strokePixAdjustVec = new Vector(strokePixAdjust, strokePixAdjust); SharpDX.Vector2 endVec = (lineEndPoint + strokePixAdjustVec).ToVector2(); SharpDX.Direct2D1.Brush tmpBrush = IsInHitTest ? chartControl.SelectionBrush : LineColor.BrushDX; RenderTarget.DrawLine((lineStartPoint + strokePixAdjustVec).ToVector2(), endVec, tmpBrush, LineColor.Width, LineColor.StrokeStyle); if (ShouldDrawText) { UpdateTextLayout(chartControl, ChartPanel, chartScale); textDeviceBrush.RenderTarget = RenderTarget; // Text rec uses same settings as mini data box textBackgroundDeviceBrush.Brush = Application.Current.FindResource("ChartControl.DataBoxBackground") as Brush; textBackgroundDeviceBrush.RenderTarget = RenderTarget; Brush borderBrush = Application.Current.FindResource("BorderThinBrush") as Brush; object thicknessResource = Application.Current.FindResource("BorderThinThickness"); double thickness = thicknessResource as double? ?? 1; Stroke textBorderStroke = new Stroke(borderBrush ?? LineColor.Brush, DashStyleHelper.Solid, Convert.ToSingle(thickness)) { RenderTarget = RenderTarget }; Point textEndPoint = TextAnchor.GetPoint(chartControl, panel, chartScale); SharpDX.Vector2 textEndVec = (textEndPoint + strokePixAdjustVec).ToVector2(); RenderTarget.DrawLine(endVec, textEndVec, LineColor.BrushDX, LineColor.Width, LineColor.StrokeStyle); float rectPixAdjust = (float)(strokePixAdjust / 2f); SharpDX.RectangleF rect = new SharpDX.RectangleF((float)(textEndPoint.X - textLayout.MaxWidth - textMargin + rectPixAdjust), (float)(textEndPoint.Y - textLayout.MaxHeight - textMargin + rectPixAdjust), textLayout.MaxWidth + textMargin * 2f, textLayout.MaxHeight + textMargin); if (textBackgroundDeviceBrush.BrushDX != null && !IsInHitTest) { RenderTarget.FillRectangle(rect, textBackgroundDeviceBrush.BrushDX); } RenderTarget.DrawRectangle(rect, textBorderStroke.BrushDX, textBorderStroke.Width, textBorderStroke.StrokeStyle); if (textDeviceBrush.BrushDX != null && !IsInHitTest) { RenderTarget.DrawTextLayout(new SharpDX.Vector2((float)(rect.X + textMargin + strokePixAdjust), (float)(rect.Y + textMargin + strokePixAdjust)), textLayout, textDeviceBrush.BrushDX); } } }
protected GraphicsPath CalculateTransformedPath(GraphicsPath path, SharpDX.RectangleF baseRect) { GraphicsPath result = path; using (Matrix m = new Matrix()) { RectangleF bounds = result.GetBounds(); _fillDisabled = bounds.Width < StrokeThickness || bounds.Height < StrokeThickness; if (Width > 0) { baseRect.Width = (float)Width; } if (Height > 0) { baseRect.Height = (float)Height; } float scaleW; float scaleH; if (Stretch == Stretch.Fill) { scaleW = baseRect.Width / bounds.Width; scaleH = baseRect.Height / bounds.Height; m.Translate(-bounds.X, -bounds.Y, MatrixOrder.Append); } else if (Stretch == Stretch.Uniform) { scaleW = Math.Min(baseRect.Width / bounds.Width, baseRect.Height / bounds.Height); scaleH = scaleW; m.Translate(-bounds.X, -bounds.Y, MatrixOrder.Append); } else if (Stretch == Stretch.UniformToFill) { scaleW = Math.Max(baseRect.Width / bounds.Width, baseRect.Height / bounds.Height); scaleH = scaleW; m.Translate(-bounds.X, -bounds.Y, MatrixOrder.Append); } else { // Stretch == Stretch.None scaleW = 1; scaleH = 1; } // In case bounds.Width or bounds.Height or baseRect.Width or baseRect.Height were 0 if (scaleW == 0 || float.IsNaN(scaleW) || float.IsInfinity(scaleW)) { scaleW = 1; } if (scaleH == 0 || float.IsNaN(scaleH) || float.IsInfinity(scaleH)) { scaleH = 1; } m.Scale(scaleW, scaleH, MatrixOrder.Append); m.Translate(baseRect.X, baseRect.Y, MatrixOrder.Append); result.Transform(m); result.Flatten(); } return(result); }
public bool Intersects(SharpDX.RectangleF rect) { var testRect = new SharpDX.RectangleF(Owner.Transform.Translation.X - OriginX, Owner.Transform.Translation.Y - OriginY, BaseWidth, BaseHeight); bool contains = false; rect.Contains(ref testRect, out contains); bool intersects = rect.Intersects(testRect); return contains || intersects; }
public bool Intersects(SharpDX.RectangleF rect) { var testRect = new SharpDX.RectangleF(Owner.Transform.Translation.X - OriginX, Owner.Transform.Translation.Y - OriginY, BaseWidth, BaseHeight); bool contains = false; rect.Contains(ref testRect, out contains); bool intersects = rect.Intersects(testRect); return(contains || intersects); }
public RectangleF DrawBoxOnMap(SharpDX.Vector2 screenPos, float size, Color color) { var sizeScaled = size * _scale; var rectangleF = new RectangleF(screenPos.X - sizeScaled / 2, screenPos.Y - sizeScaled / 2, sizeScaled, sizeScaled); _graphics.DrawBox( rectangleF, color); return(rectangleF); }
/// <summary> /// Draws a plugin image to screen. /// </summary> /// <param name="rec"></param> /// <param name="fileName">The full path including file, fx. C:\\image\\Carl.png</param> /// <returns></returns> private bool DrawImage(string fileName, RectangleF rec) { try { //Graphics.DrawPluginImage(fileName, rec); } catch { return(false); } return(true); }
private float DrawItemBar(ISnoItem[] itemsToDisplay, float barY) { var uiInv = Hud.Inventory.InventoryMainUiElement; var rect = new SharpDX.RectangleF(uiInv.Rectangle.Left - 1, barY, uiInv.Rectangle.Width + 2, _materialBackgroundImage.Height * uiInv.Rectangle.Width / _materialBackgroundImage.Width); _materialBackgroundImage.Draw(rect.X, rect.Y, rect.Width, rect.Height); var itemCountList = new int[itemsToDisplay.Length]; foreach (var item in Hud.Inventory.GetItemsInStash()) { for (int j = 0; j < itemsToDisplay.Length; j++) { if (item.SnoItem == itemsToDisplay[j]) { itemCountList[j] += (int)item.Quantity; } } } foreach (var item in Hud.Inventory.GetItemsInInventory()) { for (int j = 0; j < itemsToDisplay.Length; j++) { if (item.SnoItem == itemsToDisplay[j]) { itemCountList[j] += (int)item.Quantity; } } } var w = rect.Width / (itemsToDisplay.Length + 1); var h = rect.Height * 0.85f; var y = rect.Top + (rect.Height - h) / 2; for (int i = 0; i < itemsToDisplay.Length; i++) { var snoItem = itemsToDisplay[i]; var texture = Hud.Texture.GetItemTexture(snoItem); if (texture != null) { var x = w / 2 + rect.Left + i * w; texture.Draw(x + w - h, y, h, h, 1); var layout = MaterialCountFont.GetTextLayout(ValueToString(itemCountList[i], ValueFormat.NormalNumberNoDecimal)); MaterialCountFont.DrawText(layout, x + w - h * 1.2f - layout.Metrics.Width, y + (h - layout.Metrics.Height) / 2); } } return(rect.Height); }
private bool CheckIngoredCell(RectangleF position) { var invPoint = _inventoryZone; float wCell = invPoint.Width / 12; float hCell = invPoint.Height / 5; int x = (int)((1f + position.X - invPoint.X) / wCell); int y = (int)((1f + position.Y - invPoint.Y) / hCell); if (x < 0 || y < 0 || x > 13 || y > 6) { return(false); } return(_invArr[y, x] == 0); }
public bool isButtonPressed(SharpDX.RectangleF buttonRect) { if (Control.MouseButtons == MouseButtons.Left) { var prevMousePos = Mouse.GetCursorPosition(); if (buttonRect.Contains(Mouse.GetCursorPosition() - windowOffset)) { return(true); } Mouse.moveMouse(prevMousePos); } return(false); }
private void DrawString(string text, SimpleFont font, string brushName, double pointX, double pointY, string areaBrushName) { SharpDX.DirectWrite.TextFormat textFormat = font.ToDirectWriteTextFormat(); SharpDX.Vector2 TextPlotPoint = new System.Windows.Point(pointX, pointY).ToVector2(); SharpDX.DirectWrite.TextLayout textLayout = new SharpDX.DirectWrite.TextLayout(NinjaTrader.Core.Globals.DirectWriteFactory, text, textFormat, ChartPanel.X + ChartPanel.W, textFormat.FontSize); float newW = textLayout.Metrics.Width; float newH = textLayout.Metrics.Height; SharpDX.RectangleF PLBoundRect = new SharpDX.RectangleF((float)pointX + 2, (float)pointY, newW + 5, newH + 2); RenderTarget.FillRectangle(PLBoundRect, dxmBrushes[areaBrushName].DxBrush); RenderTarget.DrawTextLayout(TextPlotPoint, textLayout, dxmBrushes[brushName].DxBrush, SharpDX.Direct2D1.DrawTextOptions.NoSnap); textLayout.Dispose(); textFormat.Dispose(); }
private RectSide LineIntersectsRect(Point p1, Point p2, SharpDX.RectangleF r) { if (LineIntersectsLine(p1, p2, new Point(r.X, r.Y), new Point(r.X + r.Width, r.Y)) && p1.Y > r.Y) { return(RectSide.Top); } if (LineIntersectsLine(p1, p2, new Point(r.X + r.Width, r.Y), new Point(r.X + r.Width, r.Y + r.Height)) && p1.X < r.X + r.Width) { return(RectSide.Right); } if (LineIntersectsLine(p1, p2, new Point(r.X + r.Width, r.Y + r.Height), new Point(r.X, r.Y + r.Height)) && p1.Y < r.Y + r.Height) { return(RectSide.Bottom); } if (LineIntersectsLine(p1, p2, new Point(r.X, r.Y + r.Height), new Point(r.X, r.Y))) { return(RectSide.Left); } return(RectSide.None); }
private float DrawItemBar(ISnoItem[] itemsToDisplay, float barY) { var uiInv = Hud.Inventory.InventoryMainUiElement; var rect = new SharpDX.RectangleF(uiInv.Rectangle.Left - 1, barY, uiInv.Rectangle.Width + 2, _materialBackgroundImage.Height * uiInv.Rectangle.Width / _materialBackgroundImage.Width); _materialBackgroundImage.Draw(rect.X, rect.Y, rect.Width, rect.Height); var itemCountList = new long[itemsToDisplay.Length]; for (int j = 0; j < itemsToDisplay.Length; j++) { itemCountList[j] = GetItemCount(itemsToDisplay[j]); } var w = rect.Width / (itemsToDisplay.Length + 1); var h = rect.Height * 0.85f; var y = rect.Top + (rect.Height - h) / 2; for (int i = 0; i < itemsToDisplay.Length; i++) { var snoItem = itemsToDisplay[i]; var texture = Hud.Texture.GetItemTexture(snoItem); if (texture != null) { var x = w / 2 + rect.Left + i * w; texture.Draw(x + w - h, y, h, h, 1); var layout = MaterialCountFont.GetTextLayout(ValueToString(itemCountList[i], ValueFormat.NormalNumberNoDecimal)); MaterialCountFont.DrawText(layout, x + w - h * 1.2f - layout.Metrics.Width, y + (h - layout.Metrics.Height) / 2); if (Hud.Window.CursorInsideRect(x + w - h * 1.2f - layout.Metrics.Width, y, h * 1.2f + layout.Metrics.Width, h)) { Hud.Render.SetHint(snoItem.NameLocalized); } } } return(rect.Height); }
public void Draw(RectangleF windowDrawFrame) { var bmSizeWidth = _bmSize.Width; var bmSizeHeight = _bmSize.Height; var scaleX = windowDrawFrame.Width / bmSizeWidth; var scaleY = windowDrawFrame.Height / bmSizeHeight; _scale = Math.Min(scaleX, scaleY); var width = bmSizeWidth * _scale; var height = bmSizeHeight * _scale; _imageDrawFrame = new RectangleF(windowDrawFrame.X, windowDrawFrame.Y, width, height); const int lines = 42; var stepY = _imageDrawFrame.Height / lines; for (var i = 1; i < lines; i++) { var drawPosY = _imageDrawFrame.Y + i * stepY; _graphics.DrawLine(new Vector2(_imageDrawFrame.X, drawPosY), new Vector2(_imageDrawFrame.Right, drawPosY), 1, Color.Gray); } var stepX = _imageDrawFrame.Width / lines; for (var i = 1; i < lines; i++) { var drawPosX = _imageDrawFrame.X + i * stepX; _graphics.DrawLine(new Vector2(drawPosX, _imageDrawFrame.Y), new Vector2(drawPosX, _imageDrawFrame.Bottom), 1, Color.Gray); } _graphics.DrawImage(Path.GetFileName(_bgImg), _imageDrawFrame, Color.White); }
protected override void OnRender(ChartControl chartControl, ChartScale chartScale) { for (int index = ChartBars.FromIndex; index <= ChartBars.ToIndex; index++) { // gets the pixel coordinate of the bar index passed to the method - X axis float xStart = chartControl.GetXByBarIndex(ChartBars, index); // gets the pixel coordinate of the price value passed to the method - Y axis float yStart = chartScale.GetYByValue(High.GetValueAt(index) + 2 * TickSize); float width = (float)chartControl.BarWidth * 4; // construct the rectangleF struct to describe the position and size the drawing SharpDX.RectangleF rect = new SharpDX.RectangleF(xStart, yStart, width, width); // // define the brush used in the rectangle SharpDX.Direct2D1.SolidColorBrush customDXBrush = new SharpDX.Direct2D1.SolidColorBrush(RenderTarget, SharpDX.Color.Blue); SharpDX.Direct2D1.SolidColorBrush outlineBrush = new SharpDX.Direct2D1.SolidColorBrush(RenderTarget, SharpDX.Color.Black); // The RenderTarget consists of two commands related to Rectangles. // The FillRectangle() method is used to "Paint" the area of a Rectangle // execute the render target fill rectangle with desired values RenderTarget.FillRectangle(rect, customDXBrush); // and DrawRectangle() is used to "Paint" the outline of a Rectangle RenderTarget.DrawRectangle(rect, outlineBrush, 2); //Added WH 6/5/2017 // always dispose of a brush when finished customDXBrush.Dispose(); outlineBrush.Dispose(); } base.OnRender(chartControl, chartScale); }
protected override void OnRender(ChartControl chartControl, ChartScale chartScale) { if (IsInHitTest) { return; } int lastBar = ChartBars.ToIndex; int firstBar = ChartBars.FromIndex; double highPrice = 0; double lowPrice = double.MaxValue; SharpDX.Direct2D1.Brush brushDown = BarDownBrush.ToDxBrush(RenderTarget); SharpDX.Direct2D1.Brush lineBrush = LineBrush.ToDxBrush(RenderTarget); SharpDX.Direct2D1.Brush brushUp = BarUpBrush.ToDxBrush(RenderTarget); brushDown.Opacity = (float)(Opacity / 100.0); brushUp.Opacity = (float)(Opacity / 100.0); for (int idx = firstBar; idx <= lastBar && idx >= 0; idx++) { highPrice = Math.Max(highPrice, Bars.GetHigh(idx)); lowPrice = Math.Min(lowPrice, Bars.GetLow(idx)); } int volumeBarCount = BarCount; double priceRange = highPrice - lowPrice; double priceBoxSize = priceRange / volumeBarCount; double volumeMax = 0; // Pass 1: Fill all VolumeInfo structures with appropriate data for (int i = 0; i < volumeBarCount; i++) { double priceUpper = lowPrice + priceBoxSize * (i + 1); double priceLower = lowPrice + priceBoxSize * i; double priceVolumeUp = 0; double priceVolumeDown = 0; for (int idx = firstBar; idx <= lastBar; idx++) { double checkPrice; PriceSeries series = (Inputs[0] as PriceSeries); switch (series.PriceType) { case PriceType.Open: checkPrice = Bars.GetOpen(idx); break; case PriceType.Close: checkPrice = Bars.GetClose(idx); break; case PriceType.High: checkPrice = Bars.GetHigh(idx); break; case PriceType.Low: checkPrice = Bars.GetLow(idx); break; case PriceType.Median: checkPrice = (Bars.GetHigh(idx) + Bars.GetLow(idx)) / 2; break; case PriceType.Typical: checkPrice = (Bars.GetHigh(idx) + Bars.GetLow(idx) + Bars.GetClose(idx)) / 3; break; case PriceType.Weighted: checkPrice = (Bars.GetHigh(idx) + Bars.GetLow(idx) + 2 * Bars.GetClose(idx)) / 4; break; default: checkPrice = Bars.GetClose(idx); break; } if (checkPrice >= priceLower && checkPrice < priceUpper) { if (Bars.GetOpen(idx) < Bars.GetClose(idx)) { priceVolumeUp += Bars.GetVolume(idx); } else { priceVolumeDown += Bars.GetVolume(idx); } } } volumeInfo[i].up = priceVolumeUp; volumeInfo[i].down = priceVolumeDown; volumeInfo[i].total = priceVolumeUp + priceVolumeDown; volumeMax = Math.Max(volumeMax, volumeInfo[i].total); } // Pass 2: Paint the volume bars for (int i = 0; i < Math.Min(volumeBarCount, lastBar - firstBar + 1); i++) { double priceUpper = lowPrice + priceBoxSize * (i + 1); double priceLower = lowPrice + priceBoxSize * i; int yUpper = Convert.ToInt32(chartScale.GetYByValue(priceUpper)) + BarSpacing; int yLower = Convert.ToInt32(chartScale.GetYByValue(priceLower)); int barWidthUp = (int)((chartScale.Height / 2) * (volumeInfo[i].up / volumeMax)); int barWidthDown = (int)((chartScale.Height / 2) * (volumeInfo[i].down / volumeMax)); SharpDX.RectangleF rect = new SharpDX.RectangleF(ChartPanel.X, yUpper, barWidthUp, Math.Abs(yUpper - yLower)); RenderTarget.FillRectangle(rect, brushUp); RenderTarget.DrawRectangle(rect, brushUp); SharpDX.RectangleF rect2 = new SharpDX.RectangleF(ChartPanel.X + barWidthUp, yUpper, barWidthDown, Math.Abs(yUpper - yLower)); RenderTarget.DrawRectangle(rect2, brushDown); RenderTarget.FillRectangle(rect2, brushDown); if (DrawLines) { RenderTarget.DrawLine(new SharpDX.Vector2(ChartPanel.X, yLower), new SharpDX.Vector2(ChartPanel.X + ChartPanel.W, yLower), lineBrush); if (i == volumeBarCount - 1) { RenderTarget.DrawLine(new SharpDX.Vector2(ChartPanel.X, yUpper), new SharpDX.Vector2(ChartPanel.X + ChartPanel.W, yUpper), lineBrush); } } } lineBrush.Dispose(); brushDown.Dispose(); brushUp.Dispose(); }
public override void OnRender(ChartControl chartControl, ChartScale chartScale) { //Allow user to change ZOrder when manually drawn on chart if (!hasSetZOrder && !StartAnchor.IsNinjaScriptDrawn) { ZOrderType = DrawingToolZOrder.Normal; ZOrder = ChartPanel.ChartObjects.Min(z => z.ZOrder) - 1; hasSetZOrder = true; } RenderTarget.AntialiasMode = SharpDX.Direct2D1.AntialiasMode.PerPrimitive; OutlineStroke.RenderTarget = RenderTarget; ChartPanel chartPanel = chartControl.ChartPanels[PanelIndex]; // recenter region anchors to always be onscreen/centered double middleX = chartPanel.X + chartPanel.W / 2d; double middleY = chartPanel.Y + chartPanel.H / 2d; if (Mode == RegionHighlightMode.Price) { StartAnchor.UpdateXFromPoint(new Point(middleX, 0), chartControl, chartScale); EndAnchor.UpdateXFromPoint(new Point(middleX, 0), chartControl, chartScale); } else { StartAnchor.UpdateYFromDevicePoint(new Point(0, middleY), chartScale); EndAnchor.UpdateYFromDevicePoint(new Point(0, middleY), chartScale); } Point startPoint = StartAnchor.GetPoint(chartControl, chartPanel, chartScale); Point endPoint = EndAnchor.GetPoint(chartControl, chartPanel, chartScale); double width = endPoint.X - startPoint.X; AnchorLineStroke.RenderTarget = RenderTarget; OutlineStroke.RenderTarget = RenderTarget; if (!IsInHitTest && AreaBrush != null) { if (areaBrushDevice.Brush == null) { Brush brushCopy = areaBrush.Clone(); brushCopy.Opacity = areaOpacity / 100d; areaBrushDevice.Brush = brushCopy; } areaBrushDevice.RenderTarget = RenderTarget; } else { areaBrushDevice.RenderTarget = null; areaBrushDevice.Brush = null; } // align to full pixel to avoid unneeded aliasing float strokePixAdjust = Math.Abs(OutlineStroke.Width % 2d).ApproxCompare(0) == 0 ? 0.5f : 0f; SharpDX.RectangleF rect = Mode == RegionHighlightMode.Time ? new SharpDX.RectangleF((float)startPoint.X + strokePixAdjust, ChartPanel.Y - OutlineStroke.Width + strokePixAdjust, (float)width, chartPanel.Y + chartPanel.H + OutlineStroke.Width * 2) : new SharpDX.RectangleF(chartPanel.X - OutlineStroke.Width + strokePixAdjust, (float)startPoint.Y + strokePixAdjust, chartPanel.X + chartPanel.W + OutlineStroke.Width * 2, (float)(endPoint.Y - startPoint.Y)); if (!IsInHitTest && areaBrushDevice.BrushDX != null) { RenderTarget.FillRectangle(rect, areaBrushDevice.BrushDX); } SharpDX.Direct2D1.Brush tmpBrush = IsInHitTest ? chartControl.SelectionBrush : OutlineStroke.BrushDX; RenderTarget.DrawRectangle(rect, tmpBrush, OutlineStroke.Width, OutlineStroke.StrokeStyle); if (IsSelected) { tmpBrush = IsInHitTest ? chartControl.SelectionBrush : AnchorLineStroke.BrushDX; RenderTarget.DrawLine(startPoint.ToVector2(), endPoint.ToVector2(), tmpBrush, AnchorLineStroke.Width, AnchorLineStroke.StrokeStyle); } }
protected GraphicsPath CreateRectanglePath(RectangleF rect) { return GraphicsPathHelper.CreateRoundedRectPath(rect, (float) RadiusX, (float) RadiusY); }
public override void PaintWorld(WorldLayer layer) { if (layer != WorldLayer.Ground) { return; } var groundRect = Hud.Window.GroundRectangle; var padding = Hud.Window.Size.Height * Padding; var screenBorderPadding = Hud.Window.Size.Height * ScreenBorderPadding; foreach (var kvp in _registeredLabels) { var coord = kvp.Key; var list = kvp.Value; var tw = 0.0f; var sc = coord.ToScreenCoordinate(true, true); var maxH = 0.0f; foreach (var regLabel in list) { var layout = regLabel.Decorator.TextFont.GetTextLayout(regLabel.Text); var w = layout.Metrics.Width + padding * 6; tw += w; if (layout.Metrics.Height > maxH) { maxH = layout.Metrics.Height; } } var forceOnScreen = list.Any(regLabel => regLabel.Decorator.ForceOnScreen); var x = sc.X - tw / 2; if (forceOnScreen) { x = Math.Max(screenBorderPadding, Math.Min(x, groundRect.Width - screenBorderPadding - tw)); } foreach (var regLabel in list) { var layout = regLabel.Decorator.TextFont.GetTextLayout(regLabel.Text); var w = layout.Metrics.Width + padding * 6; var h = layout.Metrics.Height + padding * 2; var y = regLabel.Decorator.CenterBaseLine ? sc.Y - layout.Metrics.Height / 2 : sc.Y + (maxH - layout.Metrics.Height) / 2; if (forceOnScreen) { y = Math.Max(screenBorderPadding, Math.Min(y, groundRect.Bottom - screenBorderPadding - h)); } var rect = new SharpDX.RectangleF(x + regLabel.Decorator.OffsetX, y + regLabel.Decorator.OffsetY - padding, w, h); if (regLabel.Decorator.BackgroundTexture1 != null) { regLabel.Decorator.BackgroundTexture1.Draw(rect, regLabel.Decorator.BackgroundTextureOpacity1); } if (regLabel.Decorator.BackgroundTexture2 != null) { regLabel.Decorator.BackgroundTexture2.Draw(rect, regLabel.Decorator.BackgroundTextureOpacity2); } if (regLabel.Decorator.BackgroundBrush != null) { regLabel.Decorator.BackgroundBrush.DrawRectangle(rect); } regLabel.Decorator.TextFont.DrawText(layout, x + regLabel.Decorator.OffsetX + padding * 3, y + regLabel.Decorator.OffsetY); if (regLabel.Decorator.BorderBrush != null) { regLabel.Decorator.BorderBrush.DrawRectangle(rect); } x += w; } } _registeredLabels.Clear(); }
static void Main() { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); RenderForm form = new RenderForm("Kinect simple pilot sample"); RenderDevice device = new RenderDevice(SharpDX.Direct3D11.DeviceCreationFlags.BgraSupport); RenderContext context = new RenderContext(device); DX11SwapChain swapChain = DX11SwapChain.FromHandle(device, form.Handle); //Allow to draw using direct2d on top of swapchain var context2d = new SharpDX.Direct2D1.DeviceContext(swapChain.Texture.QueryInterface<SharpDX.DXGI.Surface>()); //Call release on texture since queryinterface does an addref Marshal.Release(swapChain.Texture.NativePointer); var textFormat = new SharpDX.DirectWrite.TextFormat(device.DWriteFactory, "Arial", 16.0f); var blackBrush = new SharpDX.Direct2D1.SolidColorBrush(context2d, SharpDX.Color.Black); var whiteBrush = new SharpDX.Direct2D1.SolidColorBrush(context2d, SharpDX.Color.White); KinectSensor sensor = KinectSensor.GetDefault(); sensor.Open(); bool doQuit = false; KinectSensorColorRGBAFrameProvider provider = new KinectSensorColorRGBAFrameProvider(sensor); DynamicColorRGBATextureProcessor colorProcessor = new DynamicColorRGBATextureProcessor(provider, device); KinectPilotProcessor pilot = KinectPilotProcessor.Default; KinectSensorBodyFrameProvider bodyFrameProvider = new KinectSensorBodyFrameProvider(sensor); bodyFrameProvider.FrameReceived += (sender, args) => { var body = args.FrameData.TrackedOnly().ClosestBodies().FirstOrDefault(); if (body != null) { pilot.Process(body.GetJointTable()); } }; form.KeyDown += (sender, args) => { if (args.KeyCode == Keys.Escape) { doQuit = true; } }; RenderLoop.Run(form, () => { if (doQuit) { form.Dispose(); return; } colorProcessor.Update(context); context.RenderTargetStack.Push(swapChain); device.Primitives.ApplyFullTri(context, colorProcessor.Texture.ShaderView); device.Primitives.FullScreenTriangle.Draw(context); context.RenderTargetStack.Pop(); context2d.BeginDraw(); var rect = new SharpDX.RectangleF(0, 0, 200, 130); context2d.FillRectangle(rect, blackBrush); context2d.DrawText("Elevation: " + pilot.Elevation, textFormat, rect, whiteBrush); rect.Top += 30; context2d.DrawText("Steering Y: " + pilot.SteeringY, textFormat, rect, whiteBrush); rect.Top += 30; context2d.DrawText("Steering Z: " + pilot.SterringZ, textFormat, rect, whiteBrush); rect.Top += 30; context2d.DrawText("Push: " + pilot.Push, textFormat, rect, whiteBrush); context2d.EndDraw(); swapChain.Present(0, SharpDX.DXGI.PresentFlags.None); }); swapChain.Dispose(); context.Dispose(); device.Dispose(); colorProcessor.Dispose(); provider.Dispose(); sensor.Close(); }
private void DrawTextBox(bool Snap, string displayText, double x, double y, SharpDX.Direct2D1.Brush brush, SharpDX.Direct2D1.Brush bgBrush, Stroke stroke, float rotate) { const int padding = 4; // Text has changed, need to update cached TextLayout if (displayText != lastText) { needsLayoutUpdate = true; } lastText = displayText; // Update cachedTextLayout if (needsLayoutUpdate || cachedTextLayout == null) { SharpDX.DirectWrite.TextFormat textFormat = Font.ToDirectWriteTextFormat(); cachedTextLayout = new SharpDX.DirectWrite.TextLayout(NinjaTrader.Core.Globals.DirectWriteFactory, displayText, textFormat, ChartPanel.X + ChartPanel.W, textFormat.FontSize); textFormat.Dispose(); needsLayoutUpdate = false; } // Snap TextBox coordinates to ChartPanel when out of bounds if (Snap) { if (rotate == 1.5708f) { y = Math.Max(ChartPanel.Y + cachedTextLayout.Metrics.Width + 2 * padding, y); } else { y = Math.Min(ChartPanel.H - padding, y); y = Math.Max(ChartPanel.Y + cachedTextLayout.Metrics.Height + padding, y); x = Math.Max(ChartPanel.X + cachedTextLayout.Metrics.Width + 2 * padding, x); } } // Apply rotation RenderTarget.Transform = SharpDX.Matrix3x2.Rotation(rotate, new SharpDX.Vector2((float)x, (float)y)); // Add padding to TextPlotPoint SharpDX.Vector2 TextPlotPoint = new System.Windows.Point(x - cachedTextLayout.Metrics.Width - padding / 2, y - cachedTextLayout.Metrics.Height).ToVector2(); // Draw the TextBox if (displayText.Length > 0) { SharpDX.RectangleF PLBoundRect = new SharpDX.RectangleF((float)x - cachedTextLayout.Metrics.Width - padding, (float)y - cachedTextLayout.Metrics.Height - padding / 2, cachedTextLayout.Metrics.Width + padding, cachedTextLayout.Metrics.Height + padding); SharpDX.Direct2D1.RoundedRectangle PLRoundedRect = new SharpDX.Direct2D1.RoundedRectangle() { Rect = PLBoundRect, RadiusX = cachedTextLayout.FontSize / 4, RadiusY = cachedTextLayout.FontSize / 4 }; RenderTarget.FillRoundedRectangle(PLRoundedRect, bgBrush); RenderTarget.DrawRoundedRectangle(PLRoundedRect, stroke.BrushDX, stroke.Width, stroke.StrokeStyle); // Draw the TextLayout RenderTarget.DrawTextLayout(TextPlotPoint, cachedTextLayout, brush, SharpDX.Direct2D1.DrawTextOptions.NoSnap); } // Restore rotation RenderTarget.Transform = SharpDX.Matrix3x2.Identity; }
protected GraphicsPath CreateRectanglePath(RectangleF rect) { return(GraphicsPathHelper.CreateRoundedRectPath(rect, (float)RadiusX, (float)RadiusY)); }
// drawZones // private void drawZones(ChartControl chartControl, ChartScale chartScale) { if (hideActiveZones && hideBrokenZones) { return; } if (Zones.Count == 0) { return; } SharpDX.Direct2D1.AntialiasMode oldAntialiasMode = RenderTarget.AntialiasMode; RenderTarget.AntialiasMode = SharpDX.Direct2D1.AntialiasMode.Aliased; SharpDX.Direct2D1.Brush demandBrush = demandColor.ToDxBrush(RenderTarget); SharpDX.Direct2D1.Brush supplyBrush = supplyColor.ToDxBrush(RenderTarget); int x1 = 0; int x2 = 0; int y1 = 0; int y2 = 0; int wd = (int)(chartControl.BarWidth / 2.0) + (int)(chartControl.BarMarginLeft / 2.0); for (int i = 0; i < Zones.Count; i++) { if (Zones[i].a == true && hideActiveZones) { continue; } if (Zones[i].a == false && hideBrokenZones) { continue; } if (barIndex == 0) { x1 = ChartControl.GetXByBarIndex(ChartBars, Zones[i].b); x2 = (Zones[i].a == false) ? ChartControl.GetXByBarIndex(ChartBars, Zones[i].e) : (int)(ChartControl.GetXByBarIndex(ChartBars, ChartBars.ToIndex) + wd); x2 = (Zones[i].a == true && extendZones) ? chartControl.CanvasRight: x2; } else { x1 = ChartControl.GetXByBarIndex(ChartBars, findBar(Zones[i])); //x1 = ChartControl.GetXByBarIndex(ChartBars, BarsArray[0].GetBar(BarsArray[1].GetTime(Zones[i].b))); x2 = (Zones[i].a == false) ? ChartControl.GetXByBarIndex(ChartBars, ChartBars.GetBarIdxByTime(chartControl, BarsArray[1].GetTime(Zones[i].e))) : (int)(ChartControl.GetXByBarIndex(ChartBars, ChartBars.ToIndex) + wd); x2 = (Zones[i].a == true && extendZones) ? chartControl.CanvasRight: x2; } if (x2 < x1) { continue; } y1 = chartScale.GetYByValue(Zones[i].h); y2 = chartScale.GetYByValue(Zones[i].l); // area SharpDX.RectangleF rect = new SharpDX.RectangleF(); rect.X = (float)x1; rect.Y = (float)y1; rect.Width = (float)Math.Abs(x2 - x1); rect.Height = (float)Math.Abs(y1 - y2) - 1; if (Zones[i].a == true) { demandBrush.Opacity = activeAreaOpacity; supplyBrush.Opacity = activeAreaOpacity; } else { demandBrush.Opacity = brokenAreaOpacity; supplyBrush.Opacity = brokenAreaOpacity; } if (Zones[i].t == "d") { RenderTarget.FillRectangle(rect, demandBrush); } if (Zones[i].t == "s") { RenderTarget.FillRectangle(rect, supplyBrush); } // line one if (Zones[i].a == true) { demandBrush.Opacity = activeLineOpacity; supplyBrush.Opacity = activeLineOpacity; } else { demandBrush.Opacity = brokenLineOpacity; supplyBrush.Opacity = brokenLineOpacity; } SharpDX.Vector2 pOne = new SharpDX.Vector2(); SharpDX.Vector2 pTwo = new SharpDX.Vector2(); pOne.X = (float)x1; pOne.Y = (float)y1; pTwo.X = (float)x2; pTwo.Y = (float)y1; if (Zones[i].t == "d") { RenderTarget.DrawLine(pOne, pTwo, demandBrush, lineWidth); } if (Zones[i].t == "s") { RenderTarget.DrawLine(pOne, pTwo, supplyBrush, lineWidth); } // line two pOne.X = (float)x1; pOne.Y = (float)y2; pTwo.X = (float)x2; pTwo.Y = (float)y2; if (Zones[i].t == "d") { RenderTarget.DrawLine(pOne, pTwo, demandBrush, lineWidth); } if (Zones[i].t == "s") { RenderTarget.DrawLine(pOne, pTwo, supplyBrush, lineWidth); } } RenderTarget.AntialiasMode = oldAntialiasMode; // --- demandBrush.Dispose(); supplyBrush.Dispose(); }
public override void GetTexture(SharpDX.Size2F surfaceSize, out DrawingSurfaceSynchronizedTexture synchronizedTexture, out SharpDX.RectangleF textureSubRectangle) { if (_synchronizedTexture == null) { _synchronizedTexture = _host.CreateSynchronizedTexture(_controller.GetTexture()); } // Set output parameters. _textureSubRectangle.Left = 0.0f; _textureSubRectangle.Top = 0.0f; _textureSubRectangle.Right = surfaceSize.Width; _textureSubRectangle.Bottom = surfaceSize.Height; //HOW DO YOU DO A Microsoft::WRL::ComPtr<T> CopyTo ????? //m_synchronizedTexture.CopyTo(synchronizedTexture); synchronizedTexture = _synchronizedTexture; textureSubRectangle = _textureSubRectangle; //something is going wrong here as the second time thru the BeginDraw consumes //the call and controlnever returns back to this method, thus GetTexture //(the call after begindraw) never fires again... ?????? synchronizedTexture.BeginDraw(); _controller.GetTexture(surfaceSize, synchronizedTexture, textureSubRectangle); synchronizedTexture.EndDraw(); }
public override void AlignedPanelAddPotentialFocusNeighbors(RectangleF? startingRect, ICollection<FrameworkElement> outElements, bool linesBeforeAndAfter) { if (ItemProvider == null) { base.AlignedPanelAddPotentialFocusNeighbors(startingRect, outElements, linesBeforeAndAfter); return; } if (!IsVisible) return; if (Focusable) outElements.Add(this); IList<FrameworkElement> arrangedItemsCopy; lock (Children.SyncRoot) { arrangedItemsCopy = new List<FrameworkElement>(_arrangedItems.Skip(_arrangedLines[0].StartIndex).Take(_arrangedLines[_arrangedLines.Count - 1].EndIndex + 1)); } int numLinesBeforeAndAfter = linesBeforeAndAfter ? NUM_ADD_MORE_FOCUS_LINES : 0; AddFocusedElementRange(arrangedItemsCopy, startingRect, _actualFirstVisibleLineIndex, _actualLastVisibleLineIndex, numLinesBeforeAndAfter, numLinesBeforeAndAfter, outElements); }
protected override void MakeChildVisible(UIElement element, ref RectangleF elementBounds) { IItemProvider itemProvider = ItemProvider; if (itemProvider == null) { base.MakeChildVisible(element, ref elementBounds); return; } if (_doScroll) { int lineIndex = 0; IList<FrameworkElement> arrangedItemsCopy; lock (Children.SyncRoot) { arrangedItemsCopy = new List<FrameworkElement>(_arrangedItems); } IList<LineMeasurement> lines = new List<LineMeasurement>(_arrangedLines); foreach (LineMeasurement line in lines) { for (int childIndex = line.StartIndex; childIndex <= line.EndIndex; childIndex++) { FrameworkElement currentChild = arrangedItemsCopy[childIndex]; if (InVisualPath(currentChild, element)) { int oldFirstVisibleLine = _actualFirstVisibleLineIndex; int oldLastVisibleLine = _actualLastVisibleLineIndex; bool first; if (lineIndex < oldFirstVisibleLine) first = true; else if (lineIndex <= oldLastVisibleLine) // Already visible break; else first = false; SetScrollIndex(lineIndex, first); // Adjust the scrolled element's bounds; Calculate the difference between positions of childen at old/new child indices float extendsInOrientationDirection = SumActualLineExtendsInNonOrientationDirection(lines, first ? oldFirstVisibleLine : oldLastVisibleLine, lineIndex); if (Orientation == Orientation.Horizontal) elementBounds.X -= extendsInOrientationDirection; else elementBounds.Y -= extendsInOrientationDirection; break; } } lineIndex++; } } }