public static void OnDragDropCommandInvalidated(DependencyObject target, DependencyPropertyChangedEventArgs e)
{
UIElement target1 = target as UIElement;
if (target1 == null)
{
return;
}
DragDropHelper dragDropHelper1 = (DragDropHelper)target1.GetValue(DragDropHelper.DragDropHelperProperty);
if (dragDropHelper1 == null)
{
IDragDropHandler handler = (IDragDropHandler)target1.GetValue(DragDropHelper.DragDropHandlerProperty);
if (handler == null)
{
return;
}
DragDropHelper dragDropHelper2 = new DragDropHelper(target1, handler);
target1.SetValue(DragDropHelper.DragDropHelperProperty, (object)dragDropHelper2);
}
else
{
IDragDropHandler handler = (IDragDropHandler)target1.GetValue(DragDropHelper.DragDropHandlerProperty);
if (handler == null)
{
return;
}
dragDropHelper1.UpdateHandler(handler);
}
}
public static QueryDropEffects QueryDrop(this IDragDropHandler dragDropHandler,
IEnumerable <IEntryModel> entries, IEntryModel dest, DragDropEffectsEx allowedEffects)
{
var dropHelper = dragDropHandler.GetDropHelper(dest);
return(dropHelper.QueryDrop(entries.Cast <IDraggable>(), allowedEffects));
}
public void UnRegisterDragDropHandler(object source, IDragDropHandler handler)
{
if (dragDropHandlers.Keys.Contains <object>(source))
{
dragDropHandlers.Remove(source);
}
}
private void InitialisePlatform()
{
#if UNITY_EDITOR_WIN || UNITY_STANDALONE_WIN
_dragDropHandler = new DragDropHandlerWindows();
#elif UNITY_WEBGL
_dragDropHandler = new DragDropHandlerWebGL();
#else
#error Drag & drop functionality is not supported for the target platform via this plugin.
#endif
}
/// <summary>
/// Registers a drag and drop handler.
/// </summary>
/// <param name="handler">The handler.</param>
public void RegisterHandler(IDragDropHandler handler)
{
foreach (string fileExt in handler.FileExtensions)
{
string ext = fileExt.ToUpper();
if (!_handlers.ContainsKey(ext))
_handlers[ext] = new List<IDragDropHandler>();
_handlers[ext].Add(handler);
}
}
private DragDropHelper(UIElement target, IDragDropHandler handler)
{
this.handler = handler;
target.AllowDrop = true;
this.dragBeginHelper = new DragBeginHelper(target, new DragBeginHelper.DragStartedHandler(handler.OnDragBegin));
target.Drop += new DragEventHandler(this.DragDropControl_Drop);
target.GiveFeedback += new GiveFeedbackEventHandler(this.DragSourceControl_GiveFeedback);
target.DragEnter += new DragEventHandler(this.DragDropControl_DragEnter);
target.DragLeave += new DragEventHandler(this.DragDropControl_DragLeave);
target.DragOver += new DragEventHandler(this.DragDropControl_DragOver);
target.QueryContinueDrag += new QueryContinueDragEventHandler(this.DragDropControl_QueryContinueDrag);
}
public static IEnumerable <IEntryModel> GetEntryModels(this IDragDropHandler dragDropHandler, IDataObject dataObject)
{
var dropHelper = dragDropHandler.GetDropHelper(null);
if (dropHelper is ISupportShellDrop)
{
return((dropHelper as ISupportShellDrop).QueryDropDraggables(dataObject).Cast <IEntryModel>());
}
else
{
return(new List <IEntryModel>());
}
}
/// <summary>
/// Registers a drag and drop handler.
/// </summary>
/// <param name="handler">The handler.</param>
public void RegisterHandler(IDragDropHandler handler)
{
foreach (string fileExt in handler.FileExtensions)
{
string ext = fileExt.ToUpper();
if (!_handlers.ContainsKey(ext))
{
_handlers[ext] = new List <IDragDropHandler>();
}
_handlers[ext].Add(handler);
}
}
public static IDataObject GetDataObject(this IDragDropHandler dragDropHandler, IEnumerable <IEntryModel> entries)
{
var dragHelper = dragDropHandler.GetDragHelper(entries);
if (dragHelper is ISupportShellDrag)
{
return((dragHelper as ISupportShellDrag).GetDataObject(entries.Cast <IDraggable>()));
}
else
{
return(new DataObject());
}
}
public static void OnDragCompleted(this IDragDropHandler dragDropHandler,
IEnumerable <IEntryModel> entries, IDataObject da, DragDropEffectsEx effect)
{
var dragHelper = dragDropHandler.GetDragHelper(entries);
if (dragHelper is ISupportShellDrag)
{
(dragHelper as ISupportShellDrag).OnDragCompleted(entries.Cast <IDraggable>(), da, effect);
}
else
{
dragHelper.OnDragCompleted(entries.Cast <IDraggable>(), effect);
}
}
public static DragDropEffectsEx OnDropCompleted(this IDragDropHandler dragDropHandler,
IEnumerable <IEntryModel> entries, IDataObject da, IEntryModel dest, DragDropEffectsEx allowedEffects)
{
var dropHelper = dragDropHandler.GetDropHelper(dest);
if (dropHelper is ISupportShellDrop)
{
return((dropHelper as ISupportShellDrop).Drop(entries.Cast <IDraggable>(), da, allowedEffects));
}
else
{
return(dropHelper.Drop(entries.Cast <IDraggable>(), allowedEffects));
}
}
public void OnDragLeave(IDataObject data)
{
if (!data.GetDataPresent(typeof(DragData)))
{
return;
}
DragData dragData = data.GetData(typeof(DragData)) as DragData;
IDragDropHandler handler = this.dragDropHandlers[dragData.Source];
if (handler == null)
{
return;
}
handler.OnDragLeave(dragData);
this.activeDragData = null;
}
private static void OnDropHandlerChanged(object sender, DependencyPropertyChangedEventArgs e)
{
UIElement element = (UIElement)sender;
IDragDropHandler handler = (IDragDropHandler)(e.NewValue);
// re-initialize the singleton (otherwise different items will have the same behavior).
_instance = new DragOnCanvasBehavior();
_instance.DropHandler = handler;
if (_instance.DropHandler != null)
{
element.MouseLeftButtonDown += _instance.ElementOnMouseLeftButtonDown;
}
//element.MouseLeftButtonDown +=
}
public bool OnDragEnter(IDataObject data)
{
if (!IsSceneLoaded)
{
return(false);
}
if (!data.GetDataPresent(typeof(DragData)))
{
return(false);
}
DragData dragData = data.GetData(typeof(DragData)) as DragData;
IDragDropHandler handler = this.dragDropHandlers[dragData.Source];
if (handler == null)
{
return(false);
}
this.activeDragData = dragData;
return(handler.OnDrageEnter(dragData));
}
public Presenter(
ILogSourcesManager logSources,
Preprocessing.IManager preprocessingsManager,
IView view,
LogViewer.IPresenterInternal viewerPresenter,
SearchResult.IPresenter searchResultPresenter,
SearchPanel.IPresenter searchPanelPresenter,
SourcesManager.IPresenter sourcesManagerPresenter,
MessagePropertiesDialog.IPresenter messagePropertiesDialogPresenter,
LoadedMessages.IPresenter loadedMessagesPresenter,
BookmarksManager.IPresenter bookmarksManagerPresenter,
IHeartBeatTimer heartBeatTimer,
ITabUsageTracker tabUsageTracker,
StatusReports.IPresenter statusReportFactory,
IDragDropHandler dragDropHandler,
IPresentersFacade presentersFacade,
IAutoUpdater autoUpdater,
Progress.IProgressAggregator progressAggregator,
IAlertPopup alerts,
SharingDialog.IPresenter sharingDialogPresenter,
IssueReportDialogPresenter.IPresenter issueReportDialogPresenter,
IShutdownSource shutdown,
IColorTheme theme,
IChangeNotification changeNotification,
ITraceSourceFactory traceSourceFactory
)
{
this.tracer = traceSourceFactory.CreateTraceSource("UI", "ui.main");
this.logSources = logSources;
this.preprocessingsManager = preprocessingsManager;
this.view = view;
this.tabUsageTracker = tabUsageTracker;
this.searchPanelPresenter = searchPanelPresenter;
this.searchResultPresenter = searchResultPresenter;
this.bookmarksManagerPresenter = bookmarksManagerPresenter;
this.viewerPresenter = viewerPresenter;
this.presentersFacade = presentersFacade;
this.dragDropHandler = dragDropHandler;
this.heartBeatTimer = heartBeatTimer;
this.autoUpdater = autoUpdater;
this.progressAggregator = progressAggregator;
this.alerts = alerts;
this.sharingDialogPresenter = sharingDialogPresenter;
this.issueReportDialogPresenter = issueReportDialogPresenter;
this.shutdown = shutdown;
this.statusRepors = statusReportFactory;
this.theme = theme;
this.changeNotification = changeNotification;
view.SetViewModel(this);
viewerPresenter.ManualRefresh += delegate(object sender, EventArgs args)
{
using (tracer.NewFrame)
{
tracer.Info("----> User Command: Refresh");
logSources.Refresh();
}
};
viewerPresenter.FocusedMessageBookmarkChanged += delegate(object sender, EventArgs args)
{
if (searchResultPresenter != null)
{
searchResultPresenter.MasterFocusedMessage = viewerPresenter.FocusedMessageBookmark;
}
};
if (messagePropertiesDialogPresenter != null)
{
viewerPresenter.DefaultFocusedMessageActionCaption = "Show properties...";
viewerPresenter.DefaultFocusedMessageAction += (s, e) =>
{
messagePropertiesDialogPresenter.Show();
};
}
if (searchResultPresenter != null)
{
searchResultPresenter.OnClose += (sender, args) => searchPanelPresenter.CollapseSearchResultPanel();
searchResultPresenter.OnResizingStarted += (sender, args) => view.BeginSplittingSearchResults();
}
sourcesManagerPresenter.OnBusyState += (_, evt) => SetWaitState(evt.BusyStateRequired);
searchPanelPresenter.InputFocusAbandoned += delegate(object sender, EventArgs args)
{
loadedMessagesPresenter.LogViewerPresenter.ReceiveInputFocus();
};
loadedMessagesPresenter.OnResizingStarted += (s, e) => view.BeginSplittingTabsPanel();
this.heartBeatTimer.OnTimer += (sender, e) =>
{
if (e.IsRareUpdate)
{
SetAnalyzingIndication(logSources.Items.Any(s => s.TimeGaps.IsWorking));
}
};
logSources.OnLogSourceAdded += (sender, evt) =>
{
UpdateFormCaption();
};
logSources.OnLogSourceRemoved += (sender, evt) =>
{
UpdateFormCaption();
};
progressAggregator.ProgressStarted += (sender, args) =>
{
view.SetTaskbarState(TaskbarState.Progress);
UpdateFormCaption();
};
progressAggregator.ProgressEnded += (sender, args) =>
{
view.SetTaskbarState(TaskbarState.Idle);
UpdateFormCaption();
};
progressAggregator.ProgressChanged += (sender, args) =>
{
view.UpdateTaskbarProgress(args.ProgressPercentage);
UpdateFormCaption();
};
if (sharingDialogPresenter != null)
{
sharingDialogPresenter.AvailabilityChanged += (sender, args) =>
{
UpdateShareButton();
};
sharingDialogPresenter.IsBusyChanged += (sender, args) =>
{
UpdateShareButton();
};
}
;
UpdateFormCaption();
UpdateShareButton();
view.SetIssueReportingMenuAvailablity(issueReportDialogPresenter.IsAvailable);
}
private void UpdateHandler(IDragDropHandler handler)
{
this.handler = handler;
this.dragBeginHelper.UpdateDragStartedHandler(new DragBeginHelper.DragStartedHandler(handler.OnDragBegin));
}
public static DragDropEffectsEx QueryDrag(this IDragDropHandler dragDropHandler, IEnumerable <IEntryModel> ems)
{
var dragHelper = dragDropHandler.GetDragHelper(ems);
return(dragHelper.QueryDrag(ems.Cast <IDraggable>()));
}
public static bool QueryCanDrop(this IDragDropHandler dragDropHandler, IEntryModel dest)
{
var dropHelper = dragDropHandler.GetDropHelper(dest);
return(dropHelper.IsDroppable);
}
/// <summary>
/// Registers a drag and drop handler.
/// </summary>
/// <param name="handler">The handler.</param>
public void RegisterHandler(IDragDropHandler handler)
{
_handlers.Add(handler);
}
public void UnRegisterDragDropHandler(object source, IDragDropHandler handler)
{
if (dragDropHandlers.Keys.Contains<object>(source))
dragDropHandlers.Remove(source);
}
public static void SetDropHandler(UIElement target, IDragDropHandler value)
{
target.SetValue(DropHandlerProperty, value);
}
