public override void Paint(Graphics g, IPaintContext context, IPlotArea layer, IGPlotItem previousPlotItem, IGPlotItem nextPlotItem)
{
if (null != _plotStyle)
{
_plotStyle.Paint(g, layer, _plotData);
}
}
public override void Paint(Graphics g, IPaintContext paintContext)
{
if (null == _cachedLayerSegment) // _privLayer should be set before in FixupInternalDataStructures
{
PaintErrorInvalidLayerType(g, paintContext);
return;
}
if (_background == null)
{
_axisStyle.Paint(g, paintContext, _cachedLayerSegment, _cachedLayerSegment.GetAxisStyleInformation);
}
else
{
// if we have a background, we paint in a dummy bitmap in order to measure all items
// the real painting is done later on after painting the background.
using (var bmp = new Bitmap(4, 4))
{
using (var gg = Graphics.FromImage(bmp))
{
_axisStyle.Paint(gg, paintContext, _cachedLayerSegment, _cachedLayerSegment.GetAxisStyleInformation);
}
}
}
_cachedPath = _axisStyle.AxisLineStyle.GetObjectPath(_cachedLayerSegment, true);
// calculate size information
RectangleD2D bounds1 = _cachedPath.GetBounds();
if (_axisStyle.AreMinorLabelsEnabled)
{
var path = _axisStyle.MinorLabelStyle.GetSelectionPath();
if (path.PointCount > 0)
{
_cachedPath.AddPath(path, false);
RectangleD2D bounds2 = path.GetBounds();
bounds1.ExpandToInclude(bounds2);
}
}
if (_axisStyle.AreMajorLabelsEnabled)
{
var path = _axisStyle.MajorLabelStyle.GetSelectionPath();
if (path.PointCount > 0)
{
_cachedPath.AddPath(path, false);
RectangleD2D bounds2 = path.GetBounds();
bounds1.ExpandToInclude(bounds2);
}
}
((ItemLocationDirectAutoSize)_location).SetSizeInAutoSizeMode(bounds1.Size, false); // size here is important only for selection, thus we set size silently
if (_background != null)
{
bounds1.Expand(_backgroundPadding);
_background.Draw(g, bounds1);
_axisStyle.Paint(g, paintContext, _cachedLayerSegment, _cachedLayerSegment.GetAxisStyleInformation);
}
}
public void Paint(Graphics g, IPaintContext paintContext, IPlotArea layer)
{
for (int i = 0; i < _axisStyles.Count; ++i)
{
_axisStyles[i].Paint(g, paintContext, layer);
}
}
public void PaintChild(IGraphicsContext3D g, IPaintContext paintContext, IPlotArea layer, PlotItemCollection coll, int indexOfChild)
{
var plotDataDict = paintContext.GetValueOrDefault <Dictionary <G3DPlotItem, Processed3DPlotData> >(this);
if (null == plotDataDict) // if initializing this dict was not successfull, then make a normal plot
{
coll[indexOfChild].Paint(g, paintContext, layer, indexOfChild == coll.Count - 1 ? null : coll[indexOfChild + 1], indexOfChild == 0 ? null : coll[indexOfChild - 1]);
return;
}
Processed3DPlotData prevPlotData = null;
Processed3DPlotData nextPlotData = null;
if ((indexOfChild + 1) < coll.Count && (coll[indexOfChild + 1] is G3DPlotItem))
{
prevPlotData = plotDataDict[coll[indexOfChild + 1] as G3DPlotItem];
}
if (indexOfChild > 0 && (coll[indexOfChild - 1] is G3DPlotItem))
{
nextPlotData = plotDataDict[coll[indexOfChild - 1] as G3DPlotItem];
}
if (coll[indexOfChild] is G3DPlotItem)
{
var gpi = coll[indexOfChild] as G3DPlotItem;
gpi.Paint(g, layer, plotDataDict[gpi], prevPlotData, nextPlotData);
}
else
{
coll[indexOfChild].Paint(g, paintContext, layer, null, null);
}
}
public static void Paint(System.Drawing.Graphics g, IPaintContext paintContext, IPlotArea layer, PlotItemCollection coll)
{
for (int i = coll.Count - 1; i >= 0; --i)
{
coll[i].Paint(g, paintContext, layer, i == coll.Count - 1 ? null : coll[i + 1], i == 0 ? null : coll[i - 1]);
}
}
public void Paint(Graphics g, IPaintContext paintContext, IPlotArea layer, Func <CSLineID, CSAxisInformation> GetAxisStyleInformation)
{
PaintLine(g, layer);
PaintMajorLabels(g, layer);
PaintMinorLabels(g, layer);
PaintTitle(g, paintContext, layer);
}
public void PaintTitle(Graphics g, IPaintContext paintContext, IPlotArea layer)
{
if (IsTitleEnabled)
{
_axisTitle.Paint(g, paintContext);
}
}
public void PaintChild(System.Drawing.Graphics g, IPaintContext paintContext, IPlotArea layer, PlotItemCollection coll, int i)
{
CachedPaintData paintData = paintContext.GetValue <CachedPaintData>(this);
if (_useClipping)
{
//g.SetClip(clippingColl[i], CombineMode.Replace);
g.Clip = paintData._clippingColl[i];
}
if (null == paintData._plotDataColl[i])
{
coll[i].Paint(g, paintContext, layer, i == coll.Count - 1 ? null : coll[i - 1], i == 0 ? null : coll[i - 1]);
}
else
{
var layerwrapper = new TransformedLayerWrapper(layer, paintData._xincColl[i], paintData._yincColl[i]);
((G2DPlotItem)coll[i]).Paint(g, layerwrapper, paintData._plotDataColl[i], i == coll.Count - 1 ? null : paintData._plotDataColl[i + 1], i == 0 ? null : paintData._plotDataColl[i - 1]);
}
// The clipping region is no longer needed, so we can dispose it
if (_useClipping)
{
if (i == 0)
{
g.Clip = paintData._clippingColl[0]; // restore the original clipping region
}
else
{
paintData._clippingColl[i].Dispose(); // for i!=0 dispose the clipping region
}
}
}
public static void Paint(System.Drawing.Graphics g, IPaintContext paintContext, IPlotArea layer, PlotItemCollection coll)
{
for (int i = coll.Count - 1; i >= 0; --i)
{
coll[i].Paint(g, paintContext, layer, i == coll.Count - 1 ? null : coll[i + 1], i == 0 ? null : coll[i - 1]);
}
}
public override void Paint(Graphics g, IPaintContext paintContext)
{
System.Drawing.Drawing2D.GraphicsState gs = g.Save();
TransformGraphics(g);
// Modification of StringFormat is necessary to avoid
// too big spaces between successive words
var strfmt = (StringFormat)StringFormat.GenericTypographic.Clone();
strfmt.FormatFlags |= StringFormatFlags.MeasureTrailingSpaces;
strfmt.LineAlignment = StringAlignment.Near;
strfmt.Alignment = StringAlignment.Near;
// next statement is necessary to have a consistent string length both
// on 0 degree rotated text and rotated text
// without this statement, the text is fitted to the pixel grid, which
// leads to "steps" during scaling
g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAlias;
if (AutoSize)
{
var mySize = g.MeasureString(_text, GdiFontManager.ToGdi(_font));
Width = mySize.Width;
Height = mySize.Height;
g.DrawString(_text, GdiFontManager.ToGdi(_font), new SolidBrush(_color), 0, 0, strfmt);
}
else
{
var rect = new RectangleF(0, 0, (float)Width, (float)Height);
g.DrawString(_text, GdiFontManager.ToGdi(_font), new SolidBrush(_color), rect, strfmt);
}
g.Restore(gs);
}
public override void Paint(IGraphicsContext3D g, IPaintContext context)
{
var gs = g.SaveGraphicsState();
g.PrependTransform(_transformation);
g.DrawLine(_linePen, Bounds.Location, Bounds.LocationPlusSize);
g.RestoreGraphicsState(gs);
}
public void PaintPreprocessing(IPaintContext paintContext, IPlotArea layer, PlotItemCollection coll)
{
if (!CanUseStyle(layer, coll, out var plotDataDict))
{
return;
}
else
{
paintContext.AddValue(this, plotDataDict);
}
AltaxoVariant[] vSumArray = null;
foreach (IGPlotItem pi in coll)
{
if (pi is G3DPlotItem)
{
var gpi = pi as G3DPlotItem;
var pdata = plotDataDict[gpi];
vSumArray = AbsoluteStackTransform.AddUp(vSumArray, pdata);
}
}
// now plot the data - the summed up y is in yArray
AltaxoVariant[] vArray = null;
Processed3DPlotData previousItemData = null;
foreach (IGPlotItem pi in coll)
{
if (pi is G3DPlotItem)
{
var gpi = pi as G3DPlotItem;
var pdata = plotDataDict[gpi];
vArray = AbsoluteStackTransform.AddUp(vArray, pdata);
var localArray = new AltaxoVariant[vArray.Length];
int j = -1;
foreach (int originalIndex in pdata.RangeList.OriginalRowIndices())
{
j++;
AltaxoVariant v = 100 * vArray[j] / vSumArray[j];
localArray[j] = v;
var rel = new Logical3D(
layer.XAxis.PhysicalVariantToNormal(pdata.GetXPhysical(originalIndex)),
layer.YAxis.PhysicalVariantToNormal(pdata.GetYPhysical(originalIndex)),
layer.ZAxis.PhysicalVariantToNormal(v));
layer.CoordinateSystem.LogicalToLayerCoordinates(rel, out var pabs);
pdata.PlotPointsInAbsoluteLayerCoordinates[j] = pabs;
}
// we have also to exchange the accessor for the physical z value and replace it by our own one
pdata.ZPhysicalAccessor = new IndexedPhysicalValueAccessor(delegate(int i)
{ return(localArray[i]); });
pdata.PreviousItemData = previousItemData;
previousItemData = pdata;
}
}
}
public void PaintPreprocessing(IPaintContext paintContext, IPlotArea layer, PlotItemCollection coll)
{
if (!CanUseStyle(layer, coll, out var plotDataDict))
{
return;
}
else
{
paintContext.AddValue(this, plotDataDict);
}
AltaxoVariant[] vArray = null;
// First, add up all items since we start always with the last item
int idx = -1;
Processed3DPlotData previousItemData = null;
foreach (IGPlotItem pi in coll)
{
if (pi is G3DPlotItem)
{
idx++;
var gpi = pi as G3DPlotItem;
Processed3DPlotData pdata = plotDataDict[gpi];
if (null == pdata)
{
continue;
}
vArray = AddUp(vArray, pdata);
if (idx > 0) // this is not the first item
{
int j = -1;
foreach (int originalIndex in pdata.RangeList.OriginalRowIndices())
{
j++;
var rel = new Logical3D(
layer.XAxis.PhysicalVariantToNormal(pdata.GetXPhysical(originalIndex)),
layer.YAxis.PhysicalVariantToNormal(pdata.GetYPhysical(originalIndex)),
layer.ZAxis.PhysicalVariantToNormal(vArray[j]));
layer.CoordinateSystem.LogicalToLayerCoordinates(rel, out var pabs);
pdata.PlotPointsInAbsoluteLayerCoordinates[j] = pabs;
}
}
// we have also to exchange the accessor for the physical y value and replace it by our own one
var localArray = (AltaxoVariant[])vArray.Clone();
var localArrayHolder = new LocalArrayHolder(localArray, pdata);
pdata.ZPhysicalAccessor = localArrayHolder.GetPhysical;
pdata.PreviousItemData = previousItemData;
previousItemData = pdata;
}
}
}
/// <summary>
/// Initialize a new instance <see cref="ListBoxItemDrawingEventArgs"/>
/// </summary>
public ListBoxItemDrawingEventArgs(T item, Color background, Color foreground,
Rect drawingArea, ColumnHeader <T> header, IPaintContext context)
{
Handled = false;
Item = item;
Background = background;
Foreground = foreground;
DrawingArea = drawingArea;
Header = header;
Context = context;
}
public override void Paint(Graphics g, IPaintContext context, IPlotArea layer, IGPlotItem prevPlotItem, IGPlotItem nextPlotItem)
{
Processed2DPlotData pdata = GetRangesAndPoints(layer);
if (pdata != null)
{
Paint(g, layer, pdata,
(prevPlotItem is G2DPlotItem) ? ((G2DPlotItem)prevPlotItem).GetPlotData(layer) : null,
(nextPlotItem is G2DPlotItem) ? ((G2DPlotItem)nextPlotItem).GetPlotData(layer) : null
);
}
}
/// <summary>
/// Paint the shape group in the graphic context.
/// </summary>
/// <param name="g">Graphic context.</param>
/// <param name="paintContext">The paint context.</param>
public override void Paint(Graphics g, IPaintContext paintContext)
{
GraphicsState gs = g.Save();
TransformGraphics(g);
foreach (GraphicBase graphics in _groupedObjects)
{
graphics.Paint(g, paintContext);
}
g.Restore(gs);
}
private void MeasureGlyphs(Graphics g, FontCache cache, IPaintContext paintContext)
{
var mc = new MeasureContext
{
FontCache = cache,
LinkedObject = Altaxo.Main.AbsoluteDocumentPath.GetRootNodeImplementing <HostLayer>(this),
TabStop = Glyph.MeasureString(g, "MMMM", _font).X
};
if (null != _rootNode)
{
_rootNode.Measure(g, mc, 0);
}
}
public override void Paint(Graphics g, IPaintContext paintContext)
{
GraphicsState gs = g.Save();
TransformGraphics(g);
Image myImage = GetImage();
if (null != myImage)
{
var bounds = Bounds;
g.DrawImage(myImage, (float)bounds.X, (float)bounds.Y, (float)bounds.Width, (float)bounds.Height);
}
g.Restore(gs);
}
public void PaintPreprocessing(IPaintContext context)
{
var coordTransStyle = _plotGroupStyles.CoordinateTransformingStyle;
if (null != coordTransStyle)
{
var layer = Altaxo.Main.AbsoluteDocumentPath.GetRootNodeImplementing <IPlotArea>(this);
coordTransStyle.PaintPreprocessing(context, layer, this);
}
else
{
foreach (var pi in _plotItems)
{
pi.PaintPreprocessing(context);
}
}
}
public override void Paint(Graphics g, IPaintContext context)
{
GraphicsState gs = g.Save();
TransformGraphics(g);
Image img = _imageProxy == null ? null : _imageProxy.GetImage();
if (null != img)
{
var bounds = Bounds;
g.DrawImage(img, (float)bounds.X, (float)bounds.Y, (float)bounds.Width, (float)bounds.Height);
}
g.Restore(gs);
}
public void Paint(IGraphicsContext3D g, IPaintContext context, Graph3D.IPlotArea layer, IGPlotItem previousPlotItem, IGPlotItem nextPlotItem)
{
var coordinateTransformingStyle = _plotGroupStyles.CoordinateTransformingStyle;
for (int i = 0; i < _plotItems.Count; ++i)
{
if (null != coordinateTransformingStyle)
{
coordinateTransformingStyle.PaintChild(g, context, layer, this, i);
}
else
{
var previousItem = i == 0 ? null : _plotItems[i - 1];
var nextItem = i == _plotItems.Count - 1 ? null : _plotItems[i + 1];
_plotItems[i].Paint(g, context, layer, previousItem, nextItem);
}
}
}
public override void Paint(Graphics g, IPaintContext context)
{
GraphicsState gs = g.Save();
TransformGraphics(g);
var bounds = Bounds;
var boundsF = (RectangleF)bounds;
if (Brush.IsVisible)
{
Brush.SetEnvironment(boundsF, BrushX.GetEffectiveMaximumResolution(g, Math.Max(ScaleX, ScaleY)));
g.FillEllipse(Brush, boundsF);
}
Pen.SetEnvironment(boundsF, BrushX.GetEffectiveMaximumResolution(g, Math.Max(ScaleX, ScaleY)));
g.DrawEllipse(Pen, boundsF);
g.Restore(gs);
}
public override void Paint(Graphics g, IPaintContext paintContext)
{
GraphicsState gs = g.Save();
TransformGraphics(g);
var bounds = Bounds;
var path = InternalGetPath(bounds.LeftTop);
Pen.SetEnvironment((RectangleF)bounds, BrushX.GetEffectiveMaximumResolution(g, Math.Max(ScaleX, ScaleY)));
g.DrawPath(Pen, path);
if (_outlinePen != null && _outlinePen.IsVisible)
{
path.Widen(Pen);
OutlinePen.SetEnvironment((RectangleF)bounds, BrushX.GetEffectiveMaximumResolution(g, Math.Max(ScaleX, ScaleY)));
g.DrawPath(OutlinePen, path);
}
g.Restore(gs);
}
public override void Paint(IGraphicsContext3D g, IPaintContext context)
{
throw new NotImplementedException();
/*
* GraphicsState gs = g.Save();
* TransformGraphics(g);
*
* Image img = _imageProxy == null ? null : _imageProxy.GetImage();
*
* if (null != img)
* {
* var bounds = this.Bounds;
*
* g.DrawImage(img, (float)bounds.X, (float)bounds.Y, (float)bounds.Width, (float)bounds.Height);
* }
*
* g.Restore(gs);
*/
}
public override void Paint(IGraphicsContext3D g, IPaintContext context)
{
var buffers = g.GetPositionNormalIndexedTriangleBuffer(_material);
if (null != buffers.PositionNormalIndexedTriangleBuffer)
{
var buffer = buffers.PositionNormalIndexedTriangleBuffer;
var offs = buffer.VertexCount;
var sphere = new SolidIcoSphere(3); // gives a sphere with radius = 1
var bounds = Bounds;
double sx = Bounds.SizeX / 2;
double sy = Bounds.SizeY / 2;
double sz = Bounds.SizeZ / 2;
var dx = Bounds.X + sx;
var dy = Bounds.Y + sy;
var dz = Bounds.Z + sz;
var transformation = Matrix4x3.NewScalingShearingRotationDegreesTranslation(sx, sy, sz, 0, 0, 0, 0, 0, 0, dx, dy, dz);
transformation.AppendTransform(_transformation);
var normalTransform = transformation.GetTransposedInverseMatrix3x3();
foreach (var entry in sphere.VerticesAndNormalsForSphere)
{
var pt = transformation.Transform(entry.Item1);
var nm = normalTransform.Transform(entry.Item2).Normalized;
buffer.AddTriangleVertex(pt.X, pt.Y, pt.Z, nm.X, nm.Y, nm.Z);
}
foreach (var idx in sphere.TriangleIndicesForSphere)
{
buffer.AddTriangleIndices(idx.Item1 + offs, idx.Item2 + offs, idx.Item3 + offs);
}
}
}
public override void Paint(Graphics g, IPaintContext paintContext)
{
GraphicsState gs = g.Save();
TransformGraphics(g);
var bounds = Bounds;
Pen.SetEnvironment((RectangleF)bounds, BrushX.GetEffectiveMaximumResolution(g, Math.Max(ScaleX, ScaleY)));
g.DrawLine(Pen, (float)bounds.X, (float)bounds.Y, (float)bounds.Right, (float)bounds.Bottom);
if (_outlinePen != null && _outlinePen.IsVisible)
{
var p = new GraphicsPath();
p.AddLine((float)bounds.X, (float)bounds.Y, (float)bounds.Right, (float)bounds.Bottom);
p.Widen(Pen);
OutlinePen.SetEnvironment((RectangleF)bounds, BrushX.GetEffectiveMaximumResolution(g, Math.Max(ScaleX, ScaleY)));
g.DrawPath(OutlinePen, p);
}
g.Restore(gs);
}
public override void Paint(Graphics g, IPaintContext context)
{
GraphicsState gs = g.Save();
TransformGraphics(g);
var bounds = Bounds;
var path = InternalGetPath(bounds.LeftTop);
if (Brush.IsVisible)
{
Brush.SetEnvironment((RectangleF)bounds, BrushX.GetEffectiveMaximumResolution(g, Math.Max(ScaleX, ScaleY)));
g.FillPath(Brush, path);
}
if (Pen.IsVisible)
{
Pen.SetEnvironment((RectangleF)bounds, BrushX.GetEffectiveMaximumResolution(g, Math.Max(ScaleX, ScaleY)));
g.DrawPath(Pen, path);
}
g.Restore(gs);
}
public void Paint(Graphics g, IPaintContext paintContext, bool bForPreview)
{
//_isStructureInSync = false;
_isMeasureInSync = false; // Change: interpret text every time in order to update plot items and \ID
if (!this._isStructureInSync)
{
// this.Interpret(g);
this.InterpretText();
_isStructureInSync = true;
_isMeasureInSync = false;
}
using (FontCache fontCache = new FontCache())
{
if (!this._isMeasureInSync)
{
// this.MeasureStructure(g, obj);
this.MeasureGlyphs(g, fontCache, paintContext);
MeasureBackground(g, _rootNode.Width, _rootNode.Height);
_isMeasureInSync = true;
}
_cachedSymbolPositions.Clear();
System.Drawing.Drawing2D.GraphicsState gs = g.Save();
g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAlias;
var bounds = Bounds;
Matrix transformmatrix = new Matrix();
transformmatrix.Translate((float)_location.AbsolutePivotPositionX, (float)_location.AbsolutePivotPositionY);
transformmatrix.Rotate((float)(-Rotation));
transformmatrix.Shear((float)Shear, 0);
transformmatrix.Scale((float)ScaleX, (float)ScaleY);
transformmatrix.Translate((float)bounds.X, (float)bounds.Y);
if (!bForPreview)
{
TransformGraphics(g);
g.TranslateTransform((float)bounds.X, (float)bounds.Y);
}
// first of all paint the background
PaintBackground(g);
DrawContext dc = new DrawContext();
dc.FontCache = fontCache;
dc.bForPreview = bForPreview;
dc.LinkedObject = Altaxo.Main.AbsoluteDocumentPath.GetRootNodeImplementing<HostLayer>(this);
dc.transformMatrix = transformmatrix;
dc._cachedSymbolPositions = _cachedSymbolPositions;
DrawGlyphs(g, dc, _cachedTextOffset.X, _cachedTextOffset.Y);
g.Restore(gs);
}
}
private void MeasureGlyphs(Graphics g, FontCache cache, IPaintContext paintContext)
{
MeasureContext mc = new MeasureContext();
mc.FontCache = cache;
mc.LinkedObject = Altaxo.Main.AbsoluteDocumentPath.GetRootNodeImplementing<HostLayer>(this);
mc.TabStop = Glyph.MeasureString(g, "MMMM", _font).X;
if (null != _rootNode)
_rootNode.Measure(g, mc, 0);
}
public void PaintChild(System.Drawing.Graphics g, IPaintContext paintContext, IPlotArea layer, PlotItemCollection coll, int i)
{
CachedPaintData paintData = paintContext.GetValue<CachedPaintData>(this);
if (_useClipping)
{
//g.SetClip(clippingColl[i], CombineMode.Replace);
g.Clip = paintData._clippingColl[i];
}
if (null == paintData._plotDataColl[i])
{
coll[i].Paint(g, paintContext, layer, i == coll.Count - 1 ? null : coll[i - 1], i == 0 ? null : coll[i - 1]);
}
else
{
TransformedLayerWrapper layerwrapper = new TransformedLayerWrapper(layer, paintData._xincColl[i], paintData._yincColl[i]);
((G2DPlotItem)coll[i]).Paint(g, layerwrapper, paintData._plotDataColl[i], i == coll.Count - 1 ? null : paintData._plotDataColl[i + 1], i == 0 ? null : paintData._plotDataColl[i - 1]);
}
// The clipping region is no longer needed, so we can dispose it
if (_useClipping)
{
if (i == 0)
g.Clip = paintData._clippingColl[0]; // restore the original clipping region
else
paintData._clippingColl[i].Dispose(); // for i!=0 dispose the clipping region
}
}
public override void Paint(Graphics g, IPaintContext paintContext)
{
GraphicsState gs = g.Save();
TransformGraphics(g);
var bounds = Bounds;
Pen.SetEnvironment((RectangleF)bounds, BrushX.GetEffectiveMaximumResolution(g, Math.Max(ScaleX, ScaleY)));
g.DrawLine(Pen, (float)bounds.X, (float)bounds.Y, (float)bounds.Right, (float)bounds.Bottom);
if (_outlinePen != null && _outlinePen.IsVisible)
{
GraphicsPath p = new GraphicsPath();
p.AddLine((float)bounds.X, (float)bounds.Y, (float)bounds.Right, (float)bounds.Bottom);
p.Widen(Pen);
OutlinePen.SetEnvironment((RectangleF)bounds, BrushX.GetEffectiveMaximumResolution(g, Math.Max(ScaleX, ScaleY)));
g.DrawPath(OutlinePen, p);
}
g.Restore(gs);
}
public override void Paint(Graphics g, IPaintContext paintContext)
{
GraphicsState gs = g.Save();
TransformGraphics(g);
var bounds = this.Bounds;
var boundsF = (RectangleF)bounds;
if (Brush.IsVisible)
{
Brush.SetEnvironment(boundsF, BrushX.GetEffectiveMaximumResolution(g, Math.Max(ScaleX, ScaleY)));
g.FillRectangle(Brush, boundsF);
}
Pen.SetEnvironment(boundsF, BrushX.GetEffectiveMaximumResolution(g, Math.Max(ScaleX, ScaleY)));
g.DrawRectangle(Pen, (float)bounds.X, (float)bounds.Y, (float)bounds.Width, (float)bounds.Height);
g.Restore(gs);
}
public override void Paint(Graphics g, IPaintContext paintContext)
{
var layer = Altaxo.Main.AbsoluteDocumentPath.GetRootNodeImplementing<XYPlotLayer>(this);
if (null == layer)
{
PaintErrorInvalidLayerType(g, paintContext);
return;
}
Logical3D rBegin;
layer.CoordinateSystem.LayerToLogicalCoordinates(X, Y, out rBegin);
Logical3D rEnd = rBegin;
switch (_scaleSpanType)
{
case FloatingScaleSpanType.IsLogicalValue:
rEnd[_scaleNumber] = rBegin[_scaleNumber] + _scaleSpanValue;
break;
case FloatingScaleSpanType.IsPhysicalEndOrgDifference:
{
var physValue = layer.Scales[_scaleNumber].NormalToPhysicalVariant(rBegin[this._scaleNumber]);
physValue += _scaleSpanValue; // to be replaced by the scale span
var logValue = layer.Scales[_scaleNumber].PhysicalVariantToNormal(physValue);
rEnd[_scaleNumber] = logValue;
}
break;
case FloatingScaleSpanType.IsPhysicalEndOrgRatio:
{
var physValue = layer.Scales[_scaleNumber].NormalToPhysicalVariant(rBegin[this._scaleNumber]);
physValue *= _scaleSpanValue; // to be replaced by the scale span
var logValue = layer.Scales[_scaleNumber].PhysicalVariantToNormal(physValue);
rEnd[_scaleNumber] = logValue;
}
break;
}
// axis style
var csLineId = new CSLineID(_scaleNumber, rBegin);
if (_axisStyle.StyleID != csLineId)
{
var propertyContext = this.GetPropertyContext();
var axStyle = new AxisStyle(new CSLineID(_scaleNumber, rBegin), false, false, false, null, propertyContext);
axStyle.CopyWithoutIdFrom(_axisStyle);
_axisStyle = axStyle;
}
var privScale = new ScaleSegment(layer.Scales[_scaleNumber], rBegin[_scaleNumber], rEnd[_scaleNumber], _scaleSegmentType);
_tickSpacing.FinalProcessScaleBoundaries(privScale.OrgAsVariant, privScale.EndAsVariant, privScale);
privScale.TickSpacing = _tickSpacing;
var privLayer = new LayerSegment(layer, privScale, rBegin, rEnd, _scaleNumber);
if (_background == null)
{
_axisStyle.Paint(g, paintContext, privLayer, privLayer.GetAxisStyleInformation);
}
else
{
// if we have a background, we paint in a dummy bitmap in order to measure all items
// the real painting is done later on after painting the background.
using (var bmp = new Bitmap(4, 4))
{
using (Graphics gg = Graphics.FromImage(bmp))
{
_axisStyle.Paint(gg, paintContext, privLayer, privLayer.GetAxisStyleInformation);
}
}
}
_cachedPath = _axisStyle.AxisLineStyle.GetObjectPath(privLayer, true);
// calculate size information
RectangleD2D bounds1 = _cachedPath.GetBounds();
if (_axisStyle.AreMinorLabelsEnabled)
{
var path = _axisStyle.MinorLabelStyle.GetSelectionPath();
if (path.PointCount > 0)
{
_cachedPath.AddPath(path, false);
RectangleD2D bounds2 = path.GetBounds();
bounds1.ExpandToInclude(bounds2);
}
}
if (_axisStyle.AreMajorLabelsEnabled)
{
var path = _axisStyle.MajorLabelStyle.GetSelectionPath();
if (path.PointCount > 0)
{
_cachedPath.AddPath(path, false);
RectangleD2D bounds2 = path.GetBounds();
bounds1.ExpandToInclude(bounds2);
}
}
((ItemLocationDirectAutoSize)_location).SetSizeInAutoSizeMode(bounds1.Size);
//this._leftTop = bounds1.Location - this.GetPosition();
//throw new NotImplementedException("debug the previous statement");
if (_background != null)
{
bounds1.Expand(_backgroundPadding);
_background.Draw(g, bounds1);
_axisStyle.Paint(g, paintContext, privLayer, privLayer.GetAxisStyleInformation);
}
}
public override void Paint(IGraphicsContext3D g, IPaintContext context)
{
var gs = g.SaveGraphicsState();
g.PrependTransform(_transformation);
g.DrawLine(_linePen, Bounds.Location, Bounds.LocationPlusSize);
g.RestoreGraphicsState(gs);
}
public override void Paint(Graphics g, IPaintContext context)
{
GraphicsState gs = g.Save();
TransformGraphics(g);
var bounds = Bounds;
var boundsF = (RectangleF)bounds;
Pen.SetEnvironment(boundsF, BrushX.GetEffectiveMaximumResolution(g, Math.Max(ScaleX, ScaleY)));
var path = GetPath();
g.DrawPath(Pen, path);
if (_outlinePen != null && _outlinePen.IsVisible)
{
path.Widen(Pen);
_outlinePen.SetEnvironment(boundsF, BrushX.GetEffectiveMaximumResolution(g, Math.Max(ScaleX, ScaleY)));
g.DrawPath(_outlinePen, path);
}
g.Restore(gs);
}
public override void Paint(Graphics g, IPaintContext paintContext)
{
GraphicsState gs = g.Save();
TransformGraphics(g);
Image myImage = this.GetImage();
if (null != myImage)
{
var bounds = this.Bounds;
g.DrawImage(myImage, (float)bounds.X, (float)bounds.Y, (float)bounds.Width, (float)bounds.Height);
}
g.Restore(gs);
}
public override void Paint(IGraphicsContext3D g, IPaintContext context)
{
var buffers = g.GetPositionNormalIndexedTriangleBuffer(_material);
if (null != buffers.PositionNormalIndexedTriangleBuffer)
{
var buffer = buffers.PositionNormalIndexedTriangleBuffer;
var offs = buffer.VertexCount;
var sphere = new SolidIcoSphere(3); // gives a sphere with radius = 1
var bounds = this.Bounds;
double sx = this.Bounds.SizeX / 2;
double sy = this.Bounds.SizeY / 2;
double sz = this.Bounds.SizeZ / 2;
var dx = this.Bounds.X + sx;
var dy = this.Bounds.Y + sy;
var dz = this.Bounds.Z + sz;
var transformation = Matrix4x3.NewScalingShearingRotationDegreesTranslation(sx, sy, sz, 0, 0, 0, 0, 0, 0, dx, dy, dz);
transformation.AppendTransform(_transformation);
var normalTransform = transformation.GetTransposedInverseMatrix3x3();
foreach (var entry in sphere.VerticesAndNormalsForSphere)
{
var pt = transformation.Transform(entry.Item1);
var nm = normalTransform.Transform(entry.Item2).Normalized;
buffer.AddTriangleVertex(pt.X, pt.Y, pt.Z, nm.X, nm.Y, nm.Z);
}
foreach (var idx in sphere.TriangleIndicesForSphere)
{
buffer.AddTriangleIndices(idx.Item1 + offs, idx.Item2 + offs, idx.Item3 + offs);
}
}
}
public override void Paint(IGraphicsContext3D g, IPaintContext context)
{
throw new NotImplementedException();
/*
GraphicsState gs = g.Save();
TransformGraphics(g);
Image img = _imageProxy == null ? null : _imageProxy.GetImage();
if (null != img)
{
var bounds = this.Bounds;
g.DrawImage(img, (float)bounds.X, (float)bounds.Y, (float)bounds.Width, (float)bounds.Height);
}
g.Restore(gs);
*/
}
public void PaintChild(IGraphicsContext3D g, IPaintContext paintContext, IPlotArea layer, PlotItemCollection coll, int indexOfChild)
{
var plotDataDict = paintContext.GetValueOrDefault<Dictionary<G3DPlotItem, Processed3DPlotData>>(this);
if (null == plotDataDict) // if initializing this dict was not successfull, then make a normal plot
{
coll[indexOfChild].Paint(g, paintContext, layer, indexOfChild == coll.Count - 1 ? null : coll[indexOfChild + 1], indexOfChild == 0 ? null : coll[indexOfChild - 1]);
return;
}
Processed3DPlotData prevPlotData = null;
Processed3DPlotData nextPlotData = null;
if ((indexOfChild + 1) < coll.Count && (coll[indexOfChild + 1] is G3DPlotItem))
prevPlotData = plotDataDict[coll[indexOfChild + 1] as G3DPlotItem];
if (indexOfChild > 0 && (coll[indexOfChild - 1] is G3DPlotItem))
nextPlotData = plotDataDict[coll[indexOfChild - 1] as G3DPlotItem];
if (coll[indexOfChild] is G3DPlotItem)
{
var gpi = coll[indexOfChild] as G3DPlotItem;
gpi.Paint(g, layer, plotDataDict[gpi], prevPlotData, nextPlotData);
}
else
{
coll[indexOfChild].Paint(g, paintContext, layer, null, null);
}
}
public override void Paint(System.Drawing.Graphics g, IPaintContext paintContext)
{
if (null == _cachedArea)
return;
bool orientationIsVertical = IsOrientationVertical;
bool scaleIsReversed = IsScaleReversed;
int pixelH = orientationIsVertical ? _bitmapPixelsAcross : _bitmapPixelsAlong;
int pixelV = orientationIsVertical ? _bitmapPixelsAlong : _bitmapPixelsAcross;
if (null == _bitmap || _bitmap.Width != pixelH || _bitmap.Height != pixelV)
{
if (null != _bitmap)
_bitmap.Dispose();
_bitmap = new Bitmap(pixelH, pixelV, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
}
Data.AltaxoVariant porg;
Data.AltaxoVariant pend;
NumericalScale originalZScale;
Plot.IColorProvider colorProvider;
if (null != PlotItem)
{
porg = PlotItem.Style.Scale.OrgAsVariant;
pend = PlotItem.Style.Scale.EndAsVariant;
originalZScale = PlotItem.Style.Scale;
colorProvider = PlotItem.Style.ColorProvider;
}
else
{
porg = 0;
pend = 1;
originalZScale = new LinearScale();
colorProvider = new Plot.ColorProvider.ColorProviderBGRY();
}
var legendScale = (NumericalScale)ScaleWithTicks;
var legendTickSpacing = ScaleWithTicks.TickSpacing;
// Fill the bitmap
for (int i = 0; i < _bitmapPixelsAlong; i++)
{
double r = (scaleIsReversed ^ orientationIsVertical) ? 1 - i / (double)(_bitmapPixelsAlong - 1) : i / (double)(_bitmapPixelsAlong - 1);
double l = originalZScale.PhysicalToNormal(legendScale.NormalToPhysical(r));
var color = colorProvider.GetColor(l);
if (orientationIsVertical)
{
for (int j = 0; j < _bitmapPixelsAcross; j++)
_bitmap.SetPixel(j, i, color);
}
else
{
for (int j = 0; j < _bitmapPixelsAcross; j++)
_bitmap.SetPixel(i, j, color);
}
}
var graphicsState = g.Save();
TransformGraphics(g);
{
// Three tricks are neccessary to get the color legend (which is the bitmap) drawn smooth and uniformly:
// Everything other than this will result in distorted image, or soft (unsharp) edges
var graphicsState2 = g.Save(); // Of course, save the graphics state so we can make our tricks undone afterwards
g.InterpolationMode = InterpolationMode.Default; // Trick1: Set the interpolation mode, whatever it was before, back to default
g.PixelOffsetMode = PixelOffsetMode.Default; // Trick2: Set the PixelOffsetMode, whatever it was before, back to default
g.DrawImage(_bitmap,
new RectangleF(0, 0, (float)Size.X, (float)Size.Y),
new Rectangle(0, 0, pixelH - 1, pixelV - 1), GraphicsUnit.Pixel); // Trick3: Paint both in X and Y direction one pixel less than the source bitmap acually has, this prevents soft edges
g.Restore(graphicsState2); // make our tricks undone here
}
_axisStyles.Paint(g, paintContext, _cachedArea);
g.Restore(graphicsState);
}
public override void Paint(Graphics g, IPaintContext paintContext)
{
var path = GetPath();
var bounds = Bounds;
GraphicsState gs = g.Save();
TransformGraphics(g);
var boundsF = (RectangleF)bounds;
if (Brush.IsVisible)
{
Brush.SetEnvironment(boundsF, BrushX.GetEffectiveMaximumResolution(g, Math.Max(ScaleX, ScaleY)));
g.FillPath(Brush, path);
}
Pen.SetEnvironment(boundsF, BrushX.GetEffectiveMaximumResolution(g, Math.Max(ScaleX, ScaleY)));
g.DrawPath(Pen, path);
g.Restore(gs);
}
public void Paint(Graphics g, IPaintContext paintContext, IPlotArea layer)
{
Paint(g, paintContext, layer, layer.CoordinateSystem.GetAxisStyleInformation);
}
public void PaintPreprocessing(System.Drawing.Graphics g, IPaintContext paintContext, IPlotArea layer, PlotItemCollection coll)
{
var paintData = new CachedPaintData
{
_clippingColl = new System.Drawing.Region[coll.Count],
_plotDataColl = new Processed2DPlotData[coll.Count],
_xincColl = new double[coll.Count],
_yincColl = new double[coll.Count]
};
paintContext.AddValue(this, paintData);
// First prepare
int idx = -1;
Processed2DPlotData previousPlotData = null;
for (int i = 0; i < coll.Count; i++)
{
if (coll[i] is G2DPlotItem)
{
idx++;
double currxinc = paintData._xincColl[i] = idx * _xinc * _scaleXInc;
double curryinc = paintData._yincColl[i] = idx * _yinc * _scaleYInc;
var gpi = coll[i] as G2DPlotItem;
Processed2DPlotData plotdata = paintData._plotDataColl[i] = gpi.GetRangesAndPoints(layer);
plotdata.PreviousItemData = previousPlotData;
previousPlotData = plotdata;
int j = -1;
foreach (int rowIndex in plotdata.RangeList.OriginalRowIndices())
{
j++;
AltaxoVariant xx = plotdata.GetXPhysical(rowIndex) + currxinc;
AltaxoVariant yy = plotdata.GetYPhysical(rowIndex) + curryinc;
var rel = new Logical3D(layer.XAxis.PhysicalVariantToNormal(xx), layer.YAxis.PhysicalVariantToNormal(yy));
layer.CoordinateSystem.LogicalToLayerCoordinates(rel, out var xabs, out var yabs);
plotdata.PlotPointsInAbsoluteLayerCoordinates[j] = new System.Drawing.PointF((float)xabs, (float)yabs);
}
// if clipping is used, we must get a clipping region for every plot item
// and combine the regions from
if (_useClipping)
{
if (i == 0)
{
paintData._clippingColl[i] = g.Clip;
}
Plot.Styles.LinePlotStyle linestyle = null;
foreach (Plot.Styles.IG2DPlotStyle st in gpi.Style)
{
if (st is Plot.Styles.LinePlotStyle)
{
linestyle = st as Plot.Styles.LinePlotStyle;
break;
}
}
if (null != linestyle)
{
var path = new System.Drawing.Drawing2D.GraphicsPath();
linestyle.GetFillPath(path, layer, plotdata, CSPlaneID.Bottom);
if ((i + 1) < paintData._clippingColl.Length)
{
paintData._clippingColl[i + 1] = paintData._clippingColl[i].Clone();
paintData._clippingColl[i + 1].Exclude(path);
}
}
else
{
if ((i + 1) < paintData._clippingColl.Length)
{
paintData._clippingColl[i + 1] = paintData._clippingColl[i];
}
}
}
}
}
}
public override void PaintPreprocessing(IPaintContext context)
{
base.PaintPreprocessing(context);
_axisStyles.PaintPreprocessing(_cachedArea); // make sure the AxisStyles know about the size of the parent
}
public void Paint(Graphics g, IPaintContext paintContext, IPlotArea layer, Func<CSLineID, CSAxisInformation> GetAxisStyleInformation)
{
PaintLine(g, layer);
PaintMajorLabels(g, layer);
PaintMinorLabels(g, layer);
PaintTitle(g, paintContext, layer);
}
public override void Paint(Graphics g, IPaintContext context, IPlotArea layer, IGPlotItem previousPlotItem, IGPlotItem nextPlotItem)
{
if (null != this._plotStyle)
{
_plotStyle.Paint(g, layer, _plotData);
}
}
public override void Paint(Graphics g, IPaintContext context, IPlotArea layer, IGPlotItem prevPlotItem, IGPlotItem nextPlotItem)
{
Processed2DPlotData pdata = GetRangesAndPoints(layer);
if (pdata != null)
Paint(g, layer, pdata,
(prevPlotItem is G2DPlotItem) ? ((G2DPlotItem)prevPlotItem).GetPlotData(layer) : null,
(nextPlotItem is G2DPlotItem) ? ((G2DPlotItem)nextPlotItem).GetPlotData(layer) : null
);
}
public override void PaintPreprocessing(IPaintContext context)
{
base.PaintPreprocessing(context);
_axisStyles.PaintPreprocessing(_cachedArea); // make sure the AxisStyles know about the size of the parent
}
public override void Paint(Graphics g, IPaintContext paintContext)
{
throw new NotImplementedException();
}
public void PaintTitle(Graphics g, IPaintContext paintContext, IPlotArea layer)
{
if (IsTitleEnabled)
{
_axisTitle.Paint(g, paintContext);
}
}
public void PaintPreprocessing(System.Drawing.Graphics g, IPaintContext paintContext, IPlotArea layer, PlotItemCollection coll)
{
var paintData = new CachedPaintData
{
_clippingColl = new System.Drawing.Region[coll.Count],
_plotDataColl = new Processed2DPlotData[coll.Count],
_xincColl = new double[coll.Count],
_yincColl = new double[coll.Count]
};
paintContext.AddValue(this, paintData);
// First prepare
int idx = -1;
Processed2DPlotData previousPlotData = null;
for (int i = 0; i < coll.Count; i++)
{
if (coll[i] is G2DPlotItem)
{
idx++;
double currxinc = paintData._xincColl[i] = idx * _xinc * _scaleXInc;
double curryinc = paintData._yincColl[i] = idx * _yinc * _scaleYInc;
G2DPlotItem gpi = coll[i] as G2DPlotItem;
Processed2DPlotData plotdata = paintData._plotDataColl[i] = gpi.GetRangesAndPoints(layer);
plotdata.PreviousItemData = previousPlotData;
previousPlotData = plotdata;
int j = -1;
foreach (int rowIndex in plotdata.RangeList.OriginalRowIndices())
{
j++;
AltaxoVariant xx = plotdata.GetXPhysical(rowIndex) + currxinc;
AltaxoVariant yy = plotdata.GetYPhysical(rowIndex) + curryinc;
Logical3D rel = new Logical3D(layer.XAxis.PhysicalVariantToNormal(xx), layer.YAxis.PhysicalVariantToNormal(yy));
double xabs, yabs;
layer.CoordinateSystem.LogicalToLayerCoordinates(rel, out xabs, out yabs);
plotdata.PlotPointsInAbsoluteLayerCoordinates[j] = new System.Drawing.PointF((float)xabs, (float)yabs);
}
// if clipping is used, we must get a clipping region for every plot item
// and combine the regions from
if (_useClipping)
{
if (i == 0)
paintData._clippingColl[i] = g.Clip;
Plot.Styles.LinePlotStyle linestyle = null;
foreach (Plot.Styles.IG2DPlotStyle st in gpi.Style)
{
if (st is Plot.Styles.LinePlotStyle)
{
linestyle = st as Plot.Styles.LinePlotStyle;
break;
}
}
if (null != linestyle)
{
GraphicsPath path = new System.Drawing.Drawing2D.GraphicsPath();
linestyle.GetFillPath(path, layer, plotdata, CSPlaneID.Bottom);
if ((i + 1) < paintData._clippingColl.Length)
{
paintData._clippingColl[i + 1] = (Region)paintData._clippingColl[i].Clone();
paintData._clippingColl[i + 1].Exclude(path);
}
}
else
{
if ((i + 1) < paintData._clippingColl.Length)
paintData._clippingColl[i + 1] = paintData._clippingColl[i];
}
}
}
}
}
/// <summary> /// This paints the plot to the layer. /// </summary> /// <param name="g">The graphics context.</param> /// <param name="context">The painting context.</param> /// <param name="layer">The plot layer.</param> /// <param name="previousPlotItem">Previous plot item.</param> /// <param name="nextPlotItem">Next plot item.</param> /// <returns>A data object, which can be used by the next plot item for some styles (like fill style).</returns> public abstract void Paint(Graphics g, IPaintContext context, IPlotArea layer, IGPlotItem previousPlotItem, IGPlotItem nextPlotItem);
public override void Paint(Graphics g, IPaintContext paintContext)
{
Paint(g, paintContext, false);
}
/// <summary>
/// Called before painting takes place.
/// </summary>
/// <param name="context">The painting context.</param>
public virtual void PaintPreprocessing(IPaintContext context)
{
}
public void PaintPreprocessing(IPaintContext paintContext, IPlotArea layer, PlotItemCollection coll)
{
Dictionary<G3DPlotItem, Processed3DPlotData> plotDataDict = null;
if (!CanUseStyle(layer, coll, out plotDataDict))
{
return;
}
else
{
paintContext.AddValue(this, plotDataDict);
}
AltaxoVariant[] vArray = null;
// First, add up all items since we start always with the last item
int idx = -1;
Processed3DPlotData previousItemData = null;
foreach (IGPlotItem pi in coll)
{
if (pi is G3DPlotItem)
{
idx++;
G3DPlotItem gpi = pi as G3DPlotItem;
Processed3DPlotData pdata = plotDataDict[gpi];
vArray = AddUp(vArray, pdata);
if (idx > 0) // this is not the first item
{
int j = -1;
foreach (int originalIndex in pdata.RangeList.OriginalRowIndices())
{
j++;
Logical3D rel = new Logical3D(
layer.XAxis.PhysicalVariantToNormal(pdata.GetXPhysical(originalIndex)),
layer.YAxis.PhysicalVariantToNormal(pdata.GetYPhysical(originalIndex)),
layer.ZAxis.PhysicalVariantToNormal(vArray[j]));
PointD3D pabs;
layer.CoordinateSystem.LogicalToLayerCoordinates(rel, out pabs);
pdata.PlotPointsInAbsoluteLayerCoordinates[j] = pabs;
}
}
// we have also to exchange the accessor for the physical y value and replace it by our own one
AltaxoVariant[] localArray = (AltaxoVariant[])vArray.Clone();
LocalArrayHolder localArrayHolder = new LocalArrayHolder(localArray, pdata);
pdata.ZPhysicalAccessor = localArrayHolder.GetPhysical;
pdata.PreviousItemData = previousItemData;
previousItemData = pdata;
}
}
}
/// <summary>
/// Called before painting takes place.
/// </summary>
/// <param name="context">The painting context.</param>
public virtual void PaintPreprocessing(IPaintContext context)
{
}
/// <summary>
/// Paint the shape group in the graphic context.
/// </summary>
/// <param name="g">Graphic context.</param>
/// <param name="paintContext">The paint context.</param>
public override void Paint(Graphics g, IPaintContext paintContext)
{
GraphicsState gs = g.Save();
this.TransformGraphics(g);
foreach (GraphicBase graphics in _groupedObjects)
graphics.Paint(g, paintContext);
g.Restore(gs);
}
public override void Paint(Graphics g, IPaintContext paintContext)
{
System.Drawing.Drawing2D.GraphicsState gs = g.Save();
TransformGraphics(g);
// Modification of StringFormat is necessary to avoid
// too big spaces between successive words
StringFormat strfmt = (StringFormat)StringFormat.GenericTypographic.Clone();
strfmt.FormatFlags |= StringFormatFlags.MeasureTrailingSpaces;
strfmt.LineAlignment = StringAlignment.Near;
strfmt.Alignment = StringAlignment.Near;
// next statement is necessary to have a consistent string length both
// on 0 degree rotated text and rotated text
// without this statement, the text is fitted to the pixel grid, which
// leads to "steps" during scaling
g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAlias;
if (this.AutoSize)
{
var mySize = g.MeasureString(_text, GdiFontManager.ToGdi(_font));
this.Width = mySize.Width;
this.Height = mySize.Height;
g.DrawString(_text, GdiFontManager.ToGdi(_font), new SolidBrush(_color), 0, 0, strfmt);
}
else
{
System.Drawing.RectangleF rect = new RectangleF(0, 0, (float)this.Width, (float)this.Height);
g.DrawString(_text, GdiFontManager.ToGdi(_font), new SolidBrush(_color), rect, strfmt);
}
g.Restore(gs);
}
public override void Paint(System.Drawing.Graphics g, IPaintContext paintContext)
{
if (null == _cachedArea)
{
return;
}
bool orientationIsVertical = IsOrientationVertical;
bool scaleIsReversed = IsScaleReversed;
int pixelH = orientationIsVertical ? _bitmapPixelsAcross : _bitmapPixelsAlong;
int pixelV = orientationIsVertical ? _bitmapPixelsAlong : _bitmapPixelsAcross;
if (null == _bitmap || _bitmap.Width != pixelH || _bitmap.Height != pixelV)
{
if (null != _bitmap)
{
_bitmap.Dispose();
}
_bitmap = new Bitmap(pixelH, pixelV, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
}
Data.AltaxoVariant porg;
Data.AltaxoVariant pend;
NumericalScale originalZScale;
Plot.IColorProvider colorProvider;
if (null != PlotItem)
{
porg = PlotItem.Style.Scale.OrgAsVariant;
pend = PlotItem.Style.Scale.EndAsVariant;
originalZScale = PlotItem.Style.Scale;
colorProvider = PlotItem.Style.ColorProvider;
}
else
{
porg = 0;
pend = 1;
originalZScale = new LinearScale();
colorProvider = new Plot.ColorProvider.ColorProviderBGRY();
}
var legendScale = (NumericalScale)ScaleWithTicks;
var legendTickSpacing = ScaleWithTicks.TickSpacing;
// Fill the bitmap
for (int i = 0; i < _bitmapPixelsAlong; i++)
{
double r = (scaleIsReversed ^ orientationIsVertical) ? 1 - i / (double)(_bitmapPixelsAlong - 1) : i / (double)(_bitmapPixelsAlong - 1);
double l = originalZScale.PhysicalToNormal(legendScale.NormalToPhysical(r));
var color = colorProvider.GetColor(l);
if (orientationIsVertical)
{
for (int j = 0; j < _bitmapPixelsAcross; j++)
{
_bitmap.SetPixel(j, i, color);
}
}
else
{
for (int j = 0; j < _bitmapPixelsAcross; j++)
{
_bitmap.SetPixel(i, j, color);
}
}
}
var graphicsState = g.Save();
TransformGraphics(g);
{
// Three tricks are neccessary to get the color legend (which is the bitmap) drawn smooth and uniformly:
// Everything other than this will result in distorted image, or soft (unsharp) edges
var graphicsState2 = g.Save(); // Of course, save the graphics state so we can make our tricks undone afterwards
g.InterpolationMode = InterpolationMode.Default; // Trick1: Set the interpolation mode, whatever it was before, back to default
g.PixelOffsetMode = PixelOffsetMode.Default; // Trick2: Set the PixelOffsetMode, whatever it was before, back to default
g.DrawImage(_bitmap,
new RectangleF(0, 0, (float)Size.X, (float)Size.Y),
new Rectangle(0, 0, pixelH - 1, pixelV - 1), GraphicsUnit.Pixel); // Trick3: Paint both in X and Y direction one pixel less than the source bitmap acually has, this prevents soft edges
g.Restore(graphicsState2); // make our tricks undone here
}
_axisStyles.Paint(g, paintContext, _cachedArea);
g.Restore(graphicsState);
}
public void PaintPreprocessing(IPaintContext paintContext, IPlotArea layer, PlotItemCollection coll)
{
Dictionary<G3DPlotItem, Processed3DPlotData> plotDataDict = null;
if (!CanUseStyle(layer, coll, out plotDataDict))
{
return;
}
else
{
paintContext.AddValue(this, plotDataDict);
}
AltaxoVariant[] vSumArray = null;
foreach (IGPlotItem pi in coll)
{
if (pi is G3DPlotItem)
{
var gpi = pi as G3DPlotItem;
var pdata = plotDataDict[gpi];
vSumArray = AbsoluteStackTransform.AddUp(vSumArray, pdata);
}
}
// now plot the data - the summed up y is in yArray
AltaxoVariant[] vArray = null;
Processed3DPlotData previousItemData = null;
foreach (IGPlotItem pi in coll)
{
if (pi is G3DPlotItem)
{
var gpi = pi as G3DPlotItem;
var pdata = plotDataDict[gpi];
vArray = AbsoluteStackTransform.AddUp(vArray, pdata);
AltaxoVariant[] localArray = new AltaxoVariant[vArray.Length];
int j = -1;
foreach (int originalIndex in pdata.RangeList.OriginalRowIndices())
{
j++;
AltaxoVariant v = 100 * vArray[j] / vSumArray[j];
localArray[j] = v;
Logical3D rel = new Logical3D(
layer.XAxis.PhysicalVariantToNormal(pdata.GetXPhysical(originalIndex)),
layer.YAxis.PhysicalVariantToNormal(pdata.GetYPhysical(originalIndex)),
layer.ZAxis.PhysicalVariantToNormal(v));
PointD3D pabs;
layer.CoordinateSystem.LogicalToLayerCoordinates(rel, out pabs);
pdata.PlotPointsInAbsoluteLayerCoordinates[j] = pabs;
}
// we have also to exchange the accessor for the physical z value and replace it by our own one
pdata.ZPhysicalAccessor = new IndexedPhysicalValueAccessor(delegate (int i) { return localArray[i]; });
pdata.PreviousItemData = previousItemData;
previousItemData = pdata;
}
}
}
