public void OnMouseWheel()
{
if (_delayedStop != null)
{
_delayedStop.Publish(this, EventArgs.Empty);
}
}
private bool ProcessMouseButtonUpMessage(MouseButtonMessage buttonMessage)
{
if (_activeButton != buttonMessage.Shortcut.MouseButton)
{
return(true);
}
_activeButton = 0;
_clickCount = 0;
if (this.CaptureHandler != null)
{
if (StopHandler(this.CaptureHandler))
{
if (_capturedOnThisClick && !HasMoved(buttonMessage.Location) && buttonMessage.Shortcut.MouseButton == XMouseButtons.Right)
{
_delayedContextMenuRequestPublisher.Publish(this, new ItemEventArgs <Point>(buttonMessage.Location));
}
return(true);
}
//Trace.WriteLine(String.Format("Release capture {0}", this.CaptureHandler.GetType()));
ReleaseCapture(false);
return(true);
}
return(false);
}
private void OnAsyncProgressChanged(object sender, AsyncPixelDataProgressEventArgs e)
{
if (_delayedEventPublisher != null)
{
_delayedEventPublisher.Publish(sender, e);
}
}
private void ImageScrollBarScroll(object sender, ScrollEventArgs e)
{
PopupManager.CloseActivePopup();
Focus();
switch (e.ScrollEventType)
{
case ScrollEventType.ThumbTrack:
case ScrollEventType.ThumbPosition:
case ScrollEventType.SmallDecrement:
case ScrollEventType.SmallIncrement:
case ScrollEventType.Last:
case ScrollEventType.LargeIncrement:
case ScrollEventType.LargeDecrement:
case ScrollEventType.First:
_scrollbarEventPublisher.Publish(sender, new ScrollBarUpdateEventArgs {
ScrollbarPosition = (int)e.NewValue
});
// don't move the thumb, keep in sync with the server side.
// Update will be done via PropertyChange event
ImageScrollBar.Value = ServerEntity.TopLeftPresentationImageIndex;
break;
case ScrollEventType.EndScroll:
// ignore it
break;
}
}
private bool ProcessMouseButtonDownMessage(MouseButtonMessage buttonMessage)
{
this.CaptureMouseWheelHandler = null;
_lastMouseDownProcessedTicks = Environment.TickCount;
//don't allow multiple buttons, it's just cleaner and easier to manage behaviour.
if (_activeButton != 0)
{
_contextMenuEnabled = false;
return(true);
}
_activeButton = buttonMessage.Shortcut.MouseButton;
_clickCount = buttonMessage.ClickCount;
if (StartCaptureHandler(buttonMessage))
{
return(true);
}
_tile.Select();
_contextMenuEnabled = _clickCount == 1 && _buttonForContextMenu == buttonMessage.Shortcut.MouseButton;
if (_contextMenuEnabled && _buttonActionForContextMenu == MouseButtonMessage.ButtonActions.Down)
{
_delayedContextMenuRequestPublisher.TimeoutMilliseconds = _mouseHoldDownForContextMenuInMilliseconds;
_delayedContextMenuRequestPublisher.Publish(this, new ItemEventArgs <Point>(buttonMessage.Location));
}
_startMousePoint = buttonMessage.Location;
if (_tile.PresentationImage == null || !_tile.Enabled)
{
return(true);
}
//give unfocused graphics a chance to focus (in the case of going straight from context menu to a graphic).
FindHandlingGraphic(TrackHandler);
return(StartNewHandler(buttonMessage));
}
public void Render(UpdateOverlayCallback updateOverlayCallback)
{
if (_dynamicRenderEventPublisher != null)
{
_dynamicRenderEventPublisher.Publish(null, null);
Render(false, updateOverlayCallback);
}
else
{
Render(true, updateOverlayCallback);
}
}
private void OnTileImageDrawn()
{
if (_logPerformance)
{
if (HasCapture)
{
// Log the speed when stacking/window-leveling
if (_fpsPublisher == null)
{
_fpsPublisher = new DelayedEventPublisher <EventArgs>((s, ev) =>
{
PerformanceMonitor p =
PerformanceMonitor.
CurrentInstance;
double fps = p.AverageClientFps;
_eventMediator.PublishPerformance(new PerformanceData
{
ClientIp
=
ApplicationContext
.
Current
.
Parameters
.
LocalIPAddress,
Name
=
"CLIENT_STACKING_SPEED",
Value
=
fps
});
BrowserWindow.SetStatus(
String.Format(
"Stacking Speed: {0:0} fps",
fps));
}, 1000);
}
_fpsPublisher.Publish(this, EventArgs.Empty);
}
}
}
public void SetCaptureHandler(TileController tileController, IMouseWheelHandler captureMouseWheelHandler)
{
if (_captureTileController == tileController && _captureMouseWheelHandler == captureMouseWheelHandler)
{
return;
}
if (_captureMouseWheelHandler != null)
{
if (_delayedStop != null)
{
_delayedStop.Dispose();
_delayedStop = null;
}
EventsHelper.Fire(tileController._wheelCaptureChangingEvent, tileController, new ItemEventArgs <IMouseWheelHandler>(null));
_captureMouseWheelHandler.StopWheel();
_captureTileController._tile.ImageViewer.EventBroker.OnMouseWheelCaptureChanged(new MouseWheelCaptureChangedEventArgs(_captureTileController._tile, false));
}
_captureTileController = tileController;
_captureMouseWheelHandler = captureMouseWheelHandler;
if (_captureMouseWheelHandler == null)
{
//This is only needed when the capture mouse wheel handler is not null.
_captureTileController = null;
if (_delayedStop != null)
{
_delayedStop.Dispose();
_delayedStop = null;
}
return;
}
_delayedStop = new DelayedEventPublisher((s, e) => SetCaptureHandler(tileController, null), WheelStopDelayMilliseconds);
EventsHelper.Fire(tileController._wheelCaptureChangingEvent, tileController, new ItemEventArgs <IMouseWheelHandler>(_captureMouseWheelHandler));
_captureMouseWheelHandler.StartWheel();
_captureTileController._tile.ImageViewer.EventBroker.OnMouseWheelCaptureChanged(new MouseWheelCaptureChangedEventArgs(_captureTileController._tile, true));
_delayedStop.Publish(this, EventArgs.Empty);
}
private void OnImageDrawing(object sender, ImageDrawingEventArgs e)
{
if (_fusionDisplaySets.Count == 0)
{
return;
}
if ((e.PresentationImage is FusionPresentationImage))
{
return;
}
if (!(e.PresentationImage is IImageSopProvider) || !(e.PresentationImage is IVoiLutProvider))
{
return;
}
// only synchronize the VOI LUTs if the source LUT is linear - otherwise, leave it alone
var sourceVoiLut = ((IVoiLutProvider)e.PresentationImage).VoiLutManager.VoiLut as IVoiLutLinear;
if (sourceVoiLut == null)
{
return;
}
if (Equals(_previousWindowCenter, sourceVoiLut.WindowCenter) &&
Equals(_previousWindowWidth, sourceVoiLut.WindowWidth))
{
return;
}
_previousWindowCenter = sourceVoiLut.WindowCenter;
_previousWindowWidth = sourceVoiLut.WindowWidth;
_publisher.Publish(e.PresentationImage, EventArgs.Empty);
}
private void OnScreenRectangleChanged(object sender, EventArgs e)
{
_delayedEventPublisher.Publish(this, EventArgs.Empty);
}
private void OnSizeChanged(object sender, SizeChangedEventArgs e)
{
//Dispatcher.BeginInvoke(() => SetImageBoxesParentSize());
_resizePublisher.Publish(null,null);
}
private void PostSelectionChangedNotification()
{
_delayedSelectionChangedPublisher.Publish(this, EventArgs.Empty);
}
