/// <summary>
/// Updates the Renderer of a specific RenderSlice with a new width and new height.
/// Width and height are mixed up, because the bitmap is rendered in rotation of 90°.
/// </summary>
/// <param name="rs">Change the dimensions of this RenderSlice</param>
/// <param name="imageWidth">New image width in pixels (width is the unit or y axis)</param>
/// <param name="imageHeight">New image height in pixels (height is the time or x axis)</param>
public static void Renderer_Update(RenderSlice rs, int imageWidth, double imageHeight)
{
switch (rs.Renderer.ToString())
{
case "UnisensViewer.StreamRenderer":
((StreamRenderer)rs.Renderer).imageheight = (int)imageHeight;
((StreamRenderer)rs.Renderer).dirtyrect.Height = (int)imageHeight;
((StreamRenderer)rs.Renderer).imagewidth = imageWidth;
((StreamRenderer)rs.Renderer).dirtyrect.Width = imageWidth;
break;
case "UnisensViewer.EventStringRenderer":
((EventStringRenderer)rs.Renderer).imageheight = (int)imageHeight;
((EventStringRenderer)rs.Renderer).dirtyrect.Height = (int)imageHeight;
((EventStringRenderer)rs.Renderer).imagewidth = imageWidth;
((EventStringRenderer)rs.Renderer).dirtyrect.Width = imageWidth;
break;
case "UnisensViewer.EventValueRenderer":
((EventValueRenderer)rs.Renderer).imageheight = (int)imageHeight;
((EventValueRenderer)rs.Renderer).dirtyrect.Height = (int)imageHeight;
((EventValueRenderer)rs.Renderer).imagewidth = imageWidth;
((EventValueRenderer)rs.Renderer).dirtyrect.Width = imageWidth;
break;
}
}
private unsafe void Dropped(DragEventArgs e, RenderSlice rs)
{
ObservableCollection <RenderSlice> l = this.GetRenderSliceListFromDropPoint(e);
Renderer r = rs.Renderer;
double maxbreite = rs.ImageSource.Height;
int imageWidth;
if (l.Count > 0)
{
imageWidth = (int)l[0].ImageSource.Width;
}
else
{
imageWidth = 128;
}
RendererManager.Renderer_Update(rs, imageWidth, maxbreite);
RendererManager.RenderSlice_Update(rs, imageWidth, maxbreite);
rs.Scale = (float)(imageWidth / rs.Range);
this.MoveRenderSlice(rs, l);
XElement channel = rs.UnisensNode;
RendererManager.Render(rs.Renderer, channel);
}
/// <summary>
/// new Render in X-direchtion
/// </summary>
/// <param name="stackercontrol"></param>
/// <param name="imageHeight">New image height in pixels (height is the time or x axis</param>
public static void Drag(StackerControl stackercontrol, double imageHeight)
{
if (imageHeight < 20)
{
imageHeight = 20;
}
MaxBreite = imageHeight;
for (int i = 0; i < stackercontrol.renderSliceLists.Count; i++)
{
RenderSlice rs = null;
// modify all RenderSlice of the Renderers
for (int j = 0; j < stackercontrol.renderSliceLists[i].Count; j++)
{
// at adding a new RenderSlice in the rslist,
// the current RenderSlice is moved forward.
rs = stackercontrol.renderSliceLists[i][0];
int imageWidth = ((RasterRenderSlice)rs).ImageWidth;
Renderer_Update(rs, imageWidth, imageHeight);
RenderSlice_Update(rs, imageWidth, imageHeight);
// old RenderSlice replaced by new
Renderer r = rs.Renderer;
XElement channel = rs.UnisensNode;
stackercontrol.MoveRenderSlice(rs, stackercontrol.renderSliceLists[i]);
// paint signal again
RendererManager.Render(r, channel);
}
}
}
public void DropSignalEventValueEntry(XElement seventry, ObservableCollection <RenderSlice> rslist)
{
if (rslist == null)
{
// neuen stapel am ende erzeugen
rslist = new ObservableCollection <RenderSlice>();
this.renderSliceLists.Add(rslist);
}
// alle kanäle hinzufügen
Renderer r = RendererManager.GetRenderer(seventry);
if (r != null)
{
List <RenderSlice> l = new List <RenderSlice>();
for (int a = 0; a < r.Channels; ++a)
{
RenderSlice rs = r.GetRenderSlice(a);
this.AttachKillHandler(rs);
this.MoveRenderSlice(rs, rslist);
l.Add(rs);
}
RendererManager.AutoZoomGroupedByFiles(l);
}
if (rslist.Count == 0)
{
// ** beim erzeugen des renderers trat ein fehler auf, die eventuell oben erzeugte rsliste löschen
this.renderSliceLists.Remove(rslist);
}
}
private void RendersliceKill(object sender, EventArgs e)
{
RenderSlice rs = (RenderSlice)sender;
rs.Kill -= this.rskillhandler;
int numslices = 0;
// referenz auf das renderslice löschen
// falls überhaupt keine renderslices mehr aktiv, dann den ganzen renderer löschen
for (int a = 0, b = this.Channels; a < b; ++a)
{
if (this.RenderSlices[a] == rs)
{
this.RenderSlices[a] = null;
}
if (this.RenderSlices[a] != null)
{
++numslices;
}
}
if (numslices == 0)
{
this.Kill(this, null);
// Free Memory
this.Close();
}
}
private void AttachKillHandler(RenderSlice rs)
{
// nur bei neu erzeugten renderslices EINMAL reinhooken,
// d.h. bei renderslices, die noch in keiner liste sind.
// es ist nämlich möglich, dass man das xml-element nochmal reindragt!
rs.Kill -= this.killHandler;
rs.Kill += this.killHandler;
}
public unsafe void ItemsControl_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
{
int imageWidth = (int)itemscontrol_RenderSliceImages.ActualHeight;
ObservableCollection <RenderSlice> rslist = (ObservableCollection <RenderSlice>)itemscontrol_RenderSliceImages.DataContext;
RenderSlice rs = null;
bool width_changed = false;
if (imageWidth < 10)
{
imageWidth = 10;
}
if (rslist != null)
{
// check if the width is changed or a slice is closed, when the mouse is released.
if (imageWidth != ((RasterRenderSlice)rslist[0]).ImageWidth)
{
width_changed = true;
}
}
if (width_changed)
{
int i = 0;
while (i < rslist.Count)
{
// at adding a new RenderSlice in the rslist,
// the current RenderSlice is moved forward.
rs = rslist[0];
int deltaWidth = (int)(imageWidth - rs.ImageSource.Width);
int maxbreite = ((RasterRenderSlice)rs).ImageHeight;
// modify all RenderSlice of the Renderers
RendererManager.Renderer_Update(rs, imageWidth, maxbreite);
RendererManager.RenderSlice_Update(rs, imageWidth, maxbreite);
// Update Scale
rs.Scale = (float)(imageWidth / rs.Range);
//rs.ZoomInto(rs.Zoominfo.PhysicalMin, rs.Zoominfo.PhysicalMax);
Renderer r = rs.Renderer;
XElement channel = rs.UnisensNode;
// old RenderSlice replaced by new
this.MoveRenderSlice(rs, rslist);
// paint all signals again
RendererManager.Render(r, channel);
i++;
}
}
}
private void Image_MouseMove(object sender, MouseEventArgs e)
{
Image i = (Image)sender;
RenderSlice rs = (RenderSlice)i.DataContext;
// achtung image ist rotiert, also x<->y
Point p = e.GetPosition(i);
// zeit, die der mauscursor (1 pixel) überspannt
double time = RendererManager.Time + (RendererManager.TimeStretch * p.Y / i.ActualHeight); // hier ebenso ActualWidth<->ActualHeight
double time_end = time + (RendererManager.TimeStretch / i.ActualHeight); // 1 pixel breite
RaiseEvent(new UpdateStatusEventArgs(rs.GetSampleInfo(time, time_end)));
}
private void Button_Click_killsignal(object sender, RoutedEventArgs e)
{
try
{
Button b = (Button)sender;
RenderSlice r = (RenderSlice)b.DataContext;
r.RaiseKill();
}
catch (Exception ex)
{
Logger logger = LogManager.GetCurrentClassLogger();
logger.Error("Strange error. Clicked on kill signal that is no RenderSlice: " + ex.StackTrace);
}
}
private void ListBox_renderSliceStack_SelectionChanged(object sender, SelectionChangedEventArgs args)
{
// ausgewähltes signal in den vordergrund bringen
ListBox l = (ListBox)sender;
RenderSlice rs = l.SelectedItem as RenderSlice;
if (rs != null)
{
Grid grid = (Grid)LogicalTreeHelper.GetParent(l);
ItemsControl itemscontrol_rendersliceimages = (ItemsControl)grid.FindName("itemscontrol_rendersliceimages");
ContentPresenter cp = (ContentPresenter)itemscontrol_rendersliceimages.ItemContainerGenerator.ContainerFromItem(rs);
Panel.SetZIndex(cp, ++this.zindex);
}
else
{
l.SelectedIndex = 0;
}
}
private void RenderSlice_Kill(object sender, EventArgs e)
{
RenderSlice rs = (RenderSlice)sender;
// handler wieder löschen (sonst speicherleck)
rs.Kill -= this.killHandler;
foreach (ObservableCollection <RenderSlice> l in this.renderSliceLists)
{
if (l.Remove(rs))
{
if (l.Count == 0)
{
this.renderSliceLists.Remove(l);
}
break;
}
}
}
public void MoveRenderSlice(RenderSlice rs, ObservableCollection <RenderSlice> dest)
{
// in alter liste finden, dann entfernen
foreach (ObservableCollection <RenderSlice> l in this.renderSliceLists)
{
if (l.Remove(rs))
{
// wurde gefunden und entfernt.
// falls alte liste jetzt leer, löschen.
if (l.Count == 0 && l != dest)
{
this.renderSliceLists.Remove(l);
}
break;
}
}
dest.Add(rs);
}
private void DropChannel(XElement channel, ObservableCollection <RenderSlice> rslist)
{
Renderer r = RendererManager.GetRenderer(channel.Parent);
if (r != null)
{
List <RenderSlice> renderSliceList = new List <RenderSlice>();
int channelNum = MeasurementEntry.GetChannelNum(channel);
if (channelNum != -1)
{
RenderSlice renderSlice = r.GetRenderSlice(channelNum);
this.AttachKillHandler(renderSlice);
this.MoveRenderSlice(renderSlice, rslist);
renderSliceList.Add(renderSlice);
}
RendererManager.AutoZoomIndividual(renderSliceList);
}
}
/// <summary>
/// Updates a RenderSlice with a new width and new height.
/// Width and height are mixed up, because the bitmap is rendered in rotation of 90°.
/// This method changes all information of the RenderSlice.
/// </summary>
/// <param name="rs">Change the dimensions of this RenderSlice</param>
/// <param name="imageWidth">New image width in pixels (width is the unit or y axis)</param>
/// <param name="imageHeight">New image height in pixels (height is the time or x axis)</param>
public unsafe static void RenderSlice_Update(RenderSlice rs, int imageWidth, double imageHeight)
{
DrawingGroup drawinggroup = new DrawingGroup();
((RasterRenderSlice)rs).ImageHeight = (int)imageHeight;
((RasterRenderSlice)rs).ImageWidth = imageWidth;
((RasterRenderSlice)rs).WBmp = new WriteableBitmap(imageWidth, (int)imageHeight, 96, 96, PixelFormats.Pbgra32, null);
((RasterRenderSlice)rs).argb = (uint *)((RasterRenderSlice)rs).WBmp.BackBuffer;
((RasterRenderSlice)rs).strideUInt32 = ((RasterRenderSlice)rs).WBmp.BackBufferStride >> 2;
Rect rect = new Rect(0.0, 0.0, imageWidth, ((RasterRenderSlice)rs).ImageHeight);
ImageDrawing imagedrawing = new ImageDrawing(((RasterRenderSlice)rs).WBmp, rect);
MatrixTransform mt = new MatrixTransform(0.0, 1.0, -1.0, 0.0, imageWidth, 0);
mt.Freeze();
drawinggroup.Children.Add(imagedrawing);
switch (rs.Renderer.ToString())
{
case "UnisensViewer.EventStringRenderer":
((EventRenderSlice)rs).geometrygroup.Transform = mt;
drawinggroup.Children.Add(((EventRenderSlice)rs).geometrydrawing);
break;
case "UnisensViewer.EventValueRenderer":
((RasterRenderSlice)rs).geometrygroup.Transform = mt;
drawinggroup.Children.Add(((RasterRenderSlice)rs).geometrydrawing);
break;
default:
break;
}
drawinggroup.ClipGeometry = new RectangleGeometry(rect);
((RasterRenderSlice)rs).imagesource = new DrawingImage(drawinggroup);
}
public static void MergedZoomInto(RenderSlice rs)
{
ZoomInfo zi = new ZoomInfo(float.MaxValue, float.MinValue);
if (rs.Zoominfo.PhysicalMax > zi.PhysicalMax)
{
zi.PhysicalMax = rs.Zoominfo.PhysicalMax;
}
if (rs.Zoominfo.PhysicalMin < zi.PhysicalMin)
{
zi.PhysicalMin = rs.Zoominfo.PhysicalMin;
}
if (rs.Zoominfo.PhysicalMin != float.MaxValue)
{
// zoominfo nicht initialisiert / keine daten?
rs.ZoomInto(zi.PhysicalMin, zi.PhysicalMax);
}
else
{
rs.ZoomInto(0.0f, 0.0f);
}
}
public HoverRenderSliceEventArgs(RenderSlice renderslice)
: base(SignalViewerControl.HoverRenderSliceEvent)
{
this.renderslice = renderslice;
}
