public ImageBoxScrollbarView(ImageBox imageBox, ServerEventMediator eventMediator)
{
_eventMediator = eventMediator;
IsTabStop = true; // allow focus
ServerEntity = imageBox;
DataContext = imageBox;
InitializeComponent();
LayoutRoot.IsHitTestVisible = !imageBox.Tiles.Any(t => t.HasCapture);
_eventMediator.TileHasCaptureChanged += EventBrokerTileHasCaptureChanged;
ImageScrollBar.SetBinding(RangeBase.ValueProperty,
new Binding(TopLeftPresentationImageIndexPropertyName) {
Mode = BindingMode.OneTime
});
ImageScrollBar.Maximum = ServerEntity.ImageCount - ServerEntity.Tiles.Count;
ImageScrollBar.Visibility = ImageScrollBar.Maximum > 0 ? Visibility.Visible : Visibility.Collapsed;
ServerEntity.PropertyChanged += OnPropertyChanged;
_scrollbarEventPublisher =
new DelayedEventPublisher<ScrollBarUpdateEventArgs>(
(s, ev) => _eventMediator.DispatchMessage(new UpdatePropertyMessage
{
Identifier = Guid.NewGuid(),
PropertyName =
TopLeftPresentationImageIndexPropertyName,
TargetId = ServerEntity.Identifier,
Value = ev.ScrollbarPosition
}), 100);
}
/// <summary>
/// Clean up any resources being used.
/// </summary>
/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
protected override void Dispose(bool disposing)
{
if (disposing)
{
if (_parentForm != null)
{
_parentForm.Move -= OnParentMoved;
_parentForm = null;
}
if (_component != null)
{
_component.Closing -= OnComponentClosing;
_component = null;
}
if (_delayedEventPublisher != null)
{
_delayedEventPublisher.Dispose();
_delayedEventPublisher = null;
}
if (_physicalWorkspace != null)
{
_physicalWorkspace.Drawing -= OnPhysicalWorkspaceDrawing;
_physicalWorkspace.LayoutCompleted -= OnLayoutCompleted;
_physicalWorkspace.ScreenRectangleChanged -= OnScreenRectangleChanged;
_physicalWorkspace = null;
}
}
base.Dispose(disposing);
}
internal PrintImageViewerControl(PrintImageViewerComponent component)
{
_component = component;
InitializeComponent();
this.SetStyle(ControlStyles.AllPaintingInWmPaint, true);
_component.Closing += new EventHandler(OnComponentClosing);
_component.Drawing += new EventHandler(OnPhysicalWorkspaceDrawing);
_component.LayoutCompleted += new EventHandler(OnLayoutCompleted);
_component.ScreenRectangleChanged += new EventHandler(OnScreenRectangleChanged);
_delayedEventPublisher = new DelayedEventPublisher(OnRecalculateImageBoxes, 50);
#region ��ӡ������
printComponent = _component.DicomPrintComponent as DicomPrintComponent;
if (printComponent != null)
{
FilmSize fileSize = printComponent.DicomPrinterConfigurationEditorComponent.FilmSize.ToFilmSize();
FilmOrientation filmOrientation = printComponent.DicomPrinterConfigurationEditorComponent.FilmOrientation;
_component.Layout(fileSize, filmOrientation);
this.Load += Loaded;
}
#endregion
#region �˵�������
this.ToolbarModel = _component.ToolbarModel;
this.ContextMenuModel = component.ContextMenuModel;
#endregion
FilmCount.DataBindings.Add("Text", _component, "FilmCount", true, DataSourceUpdateMode.OnPropertyChanged);
ImageCount.DataBindings.Add("Text", _component, "ImageCount", true, DataSourceUpdateMode.OnPropertyChanged);
}
public void Destroy()
{
_destroyed = true;
if (_eventMediator != null)
{
_eventMediator.UnregisterEventHandler(ServerEntity.Identifier);
_eventMediator.TileHasCaptureChanged -= EventBrokerTileHasCaptureChanged;
_eventMediator = null;
}
if (_menu != null)
{
_menu.Dispose();
_menu = null;
}
if (_fpsPublisher != null)
{
_fpsPublisher.Dispose();
_fpsPublisher = null;
}
StopMouseMoveTimer();
}
public TableView()
{
SuppressSelectionChangedEvent = false;
InitializeComponent();
// if we allow the framework to generate columns, there seems to be a bug with
// setting the minimum column width > 100 pixels
// therefore, turn off the auto-generate and create the columns ourselves
_dataGridView.AutoGenerateColumns = false;
_rowHeight = this.DataGridView.RowTemplate.Height;
this.DataGridView.RowPrePaint += SetCustomBackground;
this.DataGridView.RowPostPaint += DisplayCellSubRows;
this.DataGridView.RowPostPaint += OutlineCell;
this.DataGridView.RowPostPaint += SetLinkColor;
// System.Component.DesignMode does not work in control constructors
if (LicenseManager.UsageMode != LicenseUsageMode.Designtime)
{
// Use a DelayedEventPublisher to make fixes for bugs 386 and 8032 a little clearer. Previously used a Timer directly
// to delay the events
_delayedSelectionChangedPublisher = new DelayedEventPublisher((sender, args) => NotifySelectionChanged(), 50);
}
try
{
var resolver = new ResourceResolver(typeof (TableView), false);
using (var s = resolver.OpenResource("checkmark.png"))
{
_checkmarkBitmap = new Bitmap(s);
}
}
catch (Exception) {}
}
public StudyView(ServerEventMediator eventMediator)
{
InitializeComponent();
_eventMediator = eventMediator;
_imageBoxViews = new List<ImageBoxView>();
SizeChanged += OnSizeChanged;
_resizePublisher = new DelayedEventPublisher<EventArgs>(ResizeEvent, 350);
}
public StudyView(ServerEventMediator eventMediator)
{
InitializeComponent();
_eventMediator = eventMediator;
_imageBoxViews = new List<ImageBoxView>();
SizeChanged += OnSizeChanged;
_resizePublisher = new DelayedEventPublisher<EventArgs>(ResizeEvent, 350);
}
public override void Initialize()
{
base.Initialize();
ImageViewer.EventBroker.ImageDrawing += OnImageDrawing;
ImageViewer.EventBroker.DisplaySetChanged += OnDisplaySetChanged;
_publisher = new DelayedEventPublisher((o, args) => UpdateFusion((IPresentationImage)o));
_synchronizationContext = SynchronizationContext.Current;
}
public void Dispose()
{
if (_scrollbarEventPublisher != null)
{
_scrollbarEventPublisher.Dispose();
_scrollbarEventPublisher = null;
}
_eventMediator.TileHasCaptureChanged -= EventBrokerTileHasCaptureChanged;
}
public override void Draw(DrawArgs drawArgs)
{
if (_delayedEventPublisher == null && SynchronizationContext.Current != null)
{
_delayedEventPublisher = new DelayedEventPublisher(OnDelayedProgressChanged, 1000, DelayedEventPublisherTriggerMode.Periodic);
}
var asyncFrame = Frame;
using (asyncFrame.AcquireLock())
{
if (!asyncFrame.IsAsyncLoaded)
{
if (!Visible) // if this is an off-screen draw, wait for data to be loaded
{
lock (_waitPixelData)
{
if (!asyncFrame.IsAsyncLoaded)
{
var completionHandler = new EventHandler((s, e) =>
{
lock (_waitPixelData)
{
Monitor.Pulse(_waitPixelData);
}
});
var onFrameAsyncLoaded = new AsyncPixelDataEventHandler(completionHandler);
var onFrameAsyncFaulted = new AsyncPixelDataFaultEventHandler(completionHandler);
asyncFrame.AsyncLoaded += onFrameAsyncLoaded;
asyncFrame.AsyncFaulted += onFrameAsyncFaulted;
asyncFrame.GetNormalizedPixelData();
// check the flag again, in case the event actually fired before we hooked up the handler
if (!asyncFrame.IsAsyncLoaded)
{
Monitor.Wait(_waitPixelData);
}
asyncFrame.AsyncLoaded -= onFrameAsyncLoaded;
asyncFrame.AsyncFaulted -= onFrameAsyncFaulted;
}
}
}
else if (!ApplicationGraphics.OfType <ProgressGraphic>().Any())
{
ProgressGraphic.Show(this, ApplicationGraphics, true, ProgressBarGraphicStyle.Continuous, false);
}
}
base.Draw(drawArgs);
}
}
/// <summary>
/// Constructor.
/// </summary>
public PrintTileController(PrintViewTile tile, IViewerShortcutManager shortcutManager)
{
Platform.CheckForNullReference(tile, "tile");
Platform.CheckForNullReference(shortcutManager, "shortcutManager");
_tile = tile;
_tile.ContextMenuRequested += ProcessExplicitContextMenuRequest;
_selectedOnThisClick = false;
_capturedOnThisClick = false;
_shortcutManager = shortcutManager;
_delayedContextMenuRequestPublisher = new DelayedEventPublisher(ProcessDelayedContextMenuRequest, 300);
}
/// <summary>
/// Constructor.
/// </summary>
public TileController(Tile tile, IViewerShortcutManager shortcutManager)
{
Platform.CheckForNullReference(tile, "tile");
Platform.CheckForNullReference(shortcutManager, "shortcutManager");
_tile = tile;
_tile.ContextMenuRequested += ProcessExplicitContextMenuRequest;
_selectedOnThisClick = false;
_capturedOnThisClick = false;
_shortcutManager = shortcutManager;
_contextMenuDelayInMilliseconds = InputManagementSettings.Default.ContextMenuDelay;
_delayedContextMenuRequestPublisher = new DelayedEventPublisher(ProcessDelayedContextMenuRequest, _contextMenuDelayInMilliseconds);
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
var asyncFrame = Frame;
asyncFrame.AsyncProgressChanged -= OnAsyncProgressChanged;
if (_delayedEventPublisher != null)
{
_delayedEventPublisher.Dispose();
_delayedEventPublisher = null;
}
}
base.Dispose(disposing);
}
public void Dispose()
{
if (_delayedContextMenuRequestPublisher == null)
{
return;
}
ReleaseCapture(true);
this.CaptureMouseWheelHandler = null;
_delayedContextMenuRequestPublisher.Dispose();
_tile.ContextMenuRequested -= ProcessExplicitContextMenuRequest;
_delayedContextMenuRequestPublisher = null;
}
protected override void Dispose(bool disposing)
{
_synchronizationContext = null;
if (_publisher != null)
{
_publisher.Dispose();
_publisher = null;
}
ImageViewer.EventBroker.DisplaySetChanged -= OnDisplaySetChanged;
ImageViewer.EventBroker.ImageDrawing -= OnImageDrawing;
base.Dispose(disposing);
}
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
if (_dynamicRenderEventPublisher != null)
{
_dynamicRenderEventPublisher.Cancel();
_dynamicRenderEventPublisher.Dispose();
_dynamicRenderEventPublisher = null;
}
if (_vtkRenderWindow != null)
{
_vtkRenderWindow.Dispose();
_vtkRenderWindow = null;
}
if (_vtkRenderer != null)
{
_vtkRenderer.Dispose();
_vtkRenderer = null;
}
if (_sceneGraphRoot != null)
{
_sceneGraphRoot.Dispose();
_sceneGraphRoot = null;
}
if (_imageBuffer != null)
{
_imageBuffer.Dispose();
_imageBuffer = null;
}
if (_overlayBuffer != null)
{
_overlayBuffer.Dispose();
_overlayBuffer = null;
}
if (_finalBuffer != null)
{
_finalBuffer.Dispose();
_finalBuffer = null;
}
}
}
public void Dispose(bool disposing)
{
if (!_disposed)
{
if (_resizePublisher != null)
{
if (disposing)
_resizePublisher.Dispose();
_resizePublisher = null;
}
SizeChanged -= OnSizeChanged;
DestroyImageBoxViews();
_disposed = true;
}
}
public void Dispose(bool disposing)
{
if (!_disposed)
{
if (_resizePublisher != null)
{
if (disposing)
_resizePublisher.Dispose();
_resizePublisher = null;
}
SizeChanged -= OnSizeChanged;
DestroyImageBoxViews();
_disposed = true;
}
}
public override void Start()
{
_delaySetFileStoreDirectory = new DelayedEventPublisher(RealSetFileStoreDirectory);
_activityMonitor = WorkItemActivityMonitor.Create();
_activityMonitor.IsConnectedChanged += ActivityMonitorOnIsConnectedChanged;
_configuration = StudyStore.GetConfiguration();
_fileStoreDirectory = _currentFileStoreDirectory = _configuration.FileStoreDirectory;
UpdateFileStoreDriveName();
MaximumUsedSpaceChanged();
_currentDeletionRule = _configuration.DefaultDeletionRule.Clone();
base.Start();
}
internal ImageViewerControl(ImageViewerComponent component)
{
_component = component;
_physicalWorkspace = _component.PhysicalWorkspace as PhysicalWorkspace;
InitializeComponent();
this.SetStyle(ControlStyles.AllPaintingInWmPaint, true);
this.BackColor = Color.Black;
_component.Closing += new EventHandler(OnComponentClosing);
_physicalWorkspace.Drawing += new EventHandler(OnPhysicalWorkspaceDrawing);
_physicalWorkspace.LayoutCompleted += new EventHandler(OnLayoutCompleted);
_physicalWorkspace.ScreenRectangleChanged += new EventHandler(OnScreenRectangleChanged);
_delayedEventPublisher = new DelayedEventPublisher(OnRecalculateImageBoxes, 50);
}
public override void Stop()
{
base.Stop();
if (_delaySetFileStoreDirectory != null)
{
_delaySetFileStoreDirectory.Cancel();
_delaySetFileStoreDirectory.Dispose();
_delaySetFileStoreDirectory = null;
}
if (_activityMonitor != null)
{
_activityMonitor.IsConnectedChanged -= ActivityMonitorOnIsConnectedChanged;
_activityMonitor.Dispose();
}
}
private void PerformDispose(bool disposing)
{
if (disposing)
{
// this is a managed wrapper so it should only be disposed on disposing
if (_homeLocation != null)
{
_homeLocation.Dispose();
_homeLocation = null;
}
if (_folderViewSelectionUpdatePublisher != null)
{
_folderViewSelectionUpdatePublisher.Dispose();
_folderViewSelectionUpdatePublisher = null;
}
}
}
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);
}
}
}
internal ImageViewerControl(ImageViewerComponent component)
{
_component = component;
_physicalWorkspace = (PhysicalWorkspace)_component.PhysicalWorkspace;
SuspendLayout();
Name = "ImageViewerControl";
ResumeLayout(false);
SetStyle(ControlStyles.AllPaintingInWmPaint, true);
base.BackColor = Color.Black;
_component.Closing += OnComponentClosing;
_physicalWorkspace.Drawing += OnPhysicalWorkspaceDrawing;
_physicalWorkspace.LayoutCompleted += OnLayoutCompleted;
_physicalWorkspace.ScreenRectangleChanged += OnScreenRectangleChanged;
_delayedEventPublisher = new DelayedEventPublisher(OnRecalculateImageBoxes, 50);
}
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);
}
public Win32VtkRenderingSurface(IntPtr windowId, bool offscreen)
{
_imageBuffer = new BitmapBuffer(PixelFormat.Format32bppRgb);
_overlayBuffer = new BitmapBuffer(PixelFormat.Format32bppArgb);
_finalBuffer = new BackBuffer();
_vtkRenderer = new vtkRenderer();
_vtkRenderer.SetBackground(0.0f, 0.0f, 0.0f);
_vtkRenderWindow = new vtkWin32OpenGLRenderWindow();
_vtkRenderWindow.OffScreenRenderingOn();
_vtkRenderWindow.DoubleBufferOff();
_vtkRenderWindow.EraseOn();
_vtkRenderWindow.SwapBuffersOff();
_vtkRenderWindow.SetDesiredUpdateRate(_dynamicFrameRate);
_vtkRenderWindow.AddRenderer(_vtkRenderer);
_dynamicRenderEventPublisher = !offscreen ? new DelayedEventPublisher((s, e) => Render(true, null)) : null;
WindowID = windowId;
}
public LocalImageExplorerControl(LocalImageExplorerComponent component)
{
_component = component;
_folderViewSelectionUpdatePublisher = new DelayedEventPublisher(OnFolderViewSelectionUpdatePublished);
InitializeComponent();
InitializeHistoryMenu();
InitializeIcons();
InitializeFocusList();
SetViewMode(Settings.Default.FolderViewMode, false);
SetHomeLocation(Settings.Default.HomeLocation);
_folderView.ExceptionRaised += OnFolderControlExceptionRaised;
_folderTree.ExceptionRaised += OnFolderControlExceptionRaised;
ResetFocus(); // reset focus must happen after explorer controls are initially populated
// Initialize menus here
ToolStripBuilder.BuildMenu(_folderViewContextMenu.Items, _component.ContextMenuModel.ChildNodes);
ToolStripBuilder.BuildMenu(_folderTreeContextMenu.Items, _component.ContextMenuModel.ChildNodes);
}
public ImageBoxScrollbarView(ImageBox imageBox, ServerEventMediator eventMediator)
{
_eventMediator = eventMediator;
IsTabStop = true; // allow focus
ServerEntity = imageBox;
DataContext = imageBox;
InitializeComponent();
LayoutRoot.IsHitTestVisible = !imageBox.Tiles.Any(t => t.HasCapture);
_eventMediator.TileHasCaptureChanged += EventBrokerTileHasCaptureChanged;
ImageScrollBar.SetBinding(RangeBase.ValueProperty,
new Binding(TopLeftPresentationImageIndexPropertyName)
{
Mode = BindingMode.OneTime
});
ImageScrollBar.Maximum = ServerEntity.ImageCount - ServerEntity.Tiles.Count;
ImageScrollBar.Visibility = ImageScrollBar.Maximum > 0 ? Visibility.Visible : Visibility.Collapsed;
ServerEntity.PropertyChanged += OnPropertyChanged;
_scrollbarEventPublisher =
new DelayedEventPublisher <ScrollBarUpdateEventArgs>(
(s, ev) => _eventMediator.DispatchMessage(new UpdatePropertyMessage
{
Identifier = Guid.NewGuid(),
PropertyName =
TopLeftPresentationImageIndexPropertyName,
TargetId = ServerEntity.Identifier,
Value = ev.ScrollbarPosition
}), 100);
}
internal MenuItemCoordinator(MenuBase menu)
{
Menu = menu;
_delayedEventPublisher = new DelayedEventPublisher<EventArgs>(SetExpandedItem, TimeSpan.FromMilliseconds(350));
}
public void Dispose()
{
if (_scrollbarEventPublisher != null)
{
_scrollbarEventPublisher.Dispose();
_scrollbarEventPublisher = null;
}
_eventMediator.TileHasCaptureChanged -= EventBrokerTileHasCaptureChanged;
}
