// Called after LookingGlass is initialized
public void Initialize()
{
try {
// get a handle to the renderer module in LookingGlass
string rendererName = m_lgb.AppParams.ParamString("RadegastWindow.Renderer.Name");
m_framesPerSec = Math.Min(100, Math.Max(1, m_lgb.AppParams.ParamInt("RadegastWindow.FramesPerSec")));
m_frameTimeMs = 1000 / m_framesPerSec;
m_frameAllowanceMs = Math.Max(m_framesPerSec - 20, 10);
m_renderer = (IRenderProvider)m_lgb.ModManager.Module(rendererName);
if (m_renderer == null)
{
m_log.Log(LogLevel.DBADERROR, "RadegastWindow.Initialize: COULD NOT ATTACH RENDERER '{0};", rendererName);
throw new LookingGlassException(String.Format("RadegastWindow.Initialize: COULD NOT ATTACH RENDERER '{0};", rendererName));
}
m_log.Log(LogLevel.DVIEWDETAIL, "Initialize. Connecting to renderer {0} at {1}fps",
m_renderer, m_framesPerSec);
// The linkage to the renderer for display is also a link into it's UI system
m_UILink = m_renderer.UserInterface;
m_refreshTimer = new System.Threading.Timer(delegate(Object param) {
this.LGWindow.Invalidate();
}, null, 2000, m_frameTimeMs);
}
catch (Exception e) {
m_log.Log(LogLevel.DBADERROR, "Initialize. exception: {0}", e.ToString());
throw new LookingGlassException("Exception initializing view");
}
}
public StandardPackerContext(IUserInterfaceProvider uiProvider)
{
MarkedAssemblies = new List <string>();
MarkedReferences = new Dictionary <AssemblyDefinition, string>();
AnalysisDatabase = new Dictionary <string, AnalysisEntry>();
UIProvider = uiProvider;
PackingSteps = new List <IPackingStep>();
}
public StandardPackerContext(IUserInterfaceProvider uiProvider)
{
MarkedAssemblies = new List<string>();
MarkedReferences = new Dictionary<AssemblyDefinition, string>();
AnalysisDatabase = new Dictionary<string, AnalysisEntry>();
UIProvider = uiProvider;
PackingSteps = new List<IPackingStep>();
}
public XwtProvider(IUserInterfaceProvider uiProvider, bool autostart = true)
{
Emulator.UserInterfaceProvider = uiProvider;
if (autostart)
{
StartXwtThreadOnMainThread();
}
}
public static void Initialize(IUserInterfaceProvider uip)
{
if (uip == null)
{
throw new ArgumentNullException();
}
uiProvider = uip;
}
public static AppConfigManager GetInstance(IErrorReport errorReport, IUserInterfaceProvider userIP)
{
if (instance == null)
{
instance = new AppConfigManager(errorReport, userIP);
}
return(instance);
}
public static XwtProvider Create(IUserInterfaceProvider uiProvider)
{
Emulator.UserInterfaceProvider = uiProvider;
var xwtProvider = new XwtProvider();
return((xwtProvider.StartXwtThreadOnMainThread())
? xwtProvider
: null);
}
// IModule.OnLoad
public void OnLoad(string name, LookingGlassBase lgbase) {
m_moduleName = name;
m_lgb = lgbase;
m_ui = new UserInterfaceCommon();
m_ui.OnUserInterfaceKeypress += UI_OnUserInterfaceKeypress;
m_ui.OnUserInterfaceMouseMove += UI_OnUserInterfaceMouseMove;
m_ui.OnUserInterfaceMouseButton += UI_OnUserInterfaceMouseButton;
m_ui.OnUserInterfaceEntitySelected += UI_OnUserInterfaceEntitySelected;
}
public void Constructor_ShouldThrow_WhenUserInterfaceParamaterIsNotValid()
{
IUserInterfaceProvider userInterface = null;
var commandProvider = new Mock <ICommandProvider>();
Assert.That(
() => new SchoolSystemEngine(userInterface, commandProvider.Object),
Throws.ArgumentNullException.With.Message.Contains("userInterface"));
}
protected GraphViewProvider(Activity activity, TraceDataSource dataSource, IWindowlessControlContainerExt container, IErrorReport errorReport, IUserInterfaceProvider userIP, GraphViewMode mode)
{
currentActivity = activity;
currentDataSource = dataSource;
currentContainer = container;
this.errorReport = errorReport;
currentViewMode = mode;
this.userIP = userIP;
}
public static XwtProvider Create(IUserInterfaceProvider uiProvider)
{
#if GUI_DISABLED
return(null);
#else
Emulator.UserInterfaceProvider = uiProvider;
var xwtProvider = new XwtProvider();
return((xwtProvider.StartXwtThreadOnMainThread())
? xwtProvider
: null);
#endif
}
internal void Initialize(TraceViewerForm parentForm, IUserInterfaceProvider uiProvider)
{
this.parentForm = parentForm;
this.uiProvider = uiProvider;
parentForm.ObjectStateController.RegisterStateSwitchListener(objectStateController);
parentForm.LeftPanelStateController.RegisterStateSwitchListener(parentLeftPanelObjectStateController);
parentForm.LeftPanelStateController.SwitchState("LeftPanelActivityViewState");
lookinList.SelectedIndex = 0;
recentFindStringList = PersistedSettings.LoadRecentFindStringList();
RefreshAutoCompleteSource();
TraceViewerForm traceViewerForm = this.parentForm;
traceViewerForm.FindTextChangedCallback = (TraceViewerForm.FindTextChanged)Delegate.Combine(traceViewerForm.FindTextChangedCallback, new TraceViewerForm.FindTextChanged(TraceViewerForm_FindTextChanged));
}
public SchoolSystemEngine(IUserInterfaceProvider userInterface, ICommandProvider commandProvider)
{
if (userInterface == null)
{
throw new ArgumentNullException(nameof(userInterface));
}
if (commandProvider == null)
{
throw new ArgumentNullException(nameof(commandProvider));
}
this.userInterface = userInterface;
this.commandProvider = commandProvider;
}
public void Initialize()
{
try {
// the link to the renderer for display is also a link to the user interface routines
m_UILink = m_renderer.UserInterface;
m_cameraModified = true;
m_refreshTimer = new System.Threading.Timer(delegate(Object param) {
this.glControl.Invalidate();
}, null, 2000, m_frameTimeMs);
}
catch (Exception e) {
m_log.Log(LogLevel.DBADERROR, "Initialize. exception: {0}", e.ToString());
throw new LookingGlassException("Exception initializing view");
}
}
private AppConfigManager(IErrorReport errorReport, IUserInterfaceProvider userIP)
{
try
{
this.errorReport = errorReport;
this.userIP = userIP;
XmlNode xmlNode = InternalLoadSettingNodeFromAppConfigFile("filterOptions");
if (xmlNode == null)
{
customFilterOptionSettings = new CustomFilterOptionSettings();
}
else
{
customFilterOptionSettings = new CustomFilterOptionSettings(xmlNode);
}
}
catch (LogFileException)
{
customFilterOptionSettings = new CustomFilterOptionSettings();
}
}
public AddDefaultParametersStage(
[NotNull] ISystemVersionProvider systemVersionProvider,
[NotNull] ITimeService timeService,
[NotNull] IUserInterfaceProvider userInterfaceProvider)
{
if (systemVersionProvider == null)
{
throw new ArgumentNullException(nameof(systemVersionProvider));
}
if (timeService == null)
{
throw new ArgumentNullException(nameof(timeService));
}
if (userInterfaceProvider == null)
{
throw new ArgumentNullException(nameof(userInterfaceProvider));
}
_systemVersionProvider = systemVersionProvider;
_timeService = timeService;
_userInterfaceProvider = userInterfaceProvider;
}
public static object UIThreadInvokeHelper(IUserInterfaceProvider userIP, Delegate d, params object[] props)
{
if (userIP != null && (object)d != null)
{
RuntimeHelpers.PrepareConstrainedRegions();
try
{
if (props == null)
{
return(userIP.InvokeOnUIThread(d));
}
return(userIP.InvokeOnUIThread(d, props));
}
catch (Exception ex)
{
ExceptionManager.GeneralExceptionFilter(ex);
ExceptionManager.LogAppError(new TraceViewerException(SR.GetString("MsgInvokeExceptionOccur"), ex.GetType().ToString() + SR.GetString("MsgReturnBack") + ex.ToString()));
}
}
return(null);
}
internal void Initialize(TraceViewerForm parent, IUserInterfaceProvider userIP, IErrorReport errorReport)
{
parentForm = parent;
this.userIP = userIP;
this.errorReport = errorReport;
extensionMenu = new ToolStripDropDownButton();
extensionMenu.Text = SR.GetString("FV_Options");
extensionMenu.ShowDropDownArrow = true;
extensionMenu.ToolTipText = SR.GetString("FV_OptionsTip");
showBasicsMenuItem = new ToolStripMenuItem(SR.GetString("FV_BasicInfoOption"));
showBasicsMenuItem.ToolTipText = SR.GetString("FV_BasicInfoOptionTip");
showBasicsMenuItem.Checked = true;
showBasicsMenuItem.CheckOnClick = true;
showBasicsMenuItem.Click += changeOptionsMenuItem_Click;
showDiagMenuItem = new ToolStripMenuItem(SR.GetString("FV_DiagInfoOption"));
showDiagMenuItem.ToolTipText = SR.GetString("FV_DiagInfoOptionTip");
showDiagMenuItem.Checked = true;
showDiagMenuItem.CheckOnClick = true;
showDiagMenuItem.Click += changeOptionsMenuItem_Click;
extensionMenu.DropDownItems.Add(showBasicsMenuItem);
extensionMenu.DropDownItems.Add(showDiagMenuItem);
toolStrip.Items.Add(extensionMenu);
}
private static ISchoolSystemEngine GetEngine(IUserInterfaceProvider userInterface, ICommandProvider commandProvider)
{
var engine = new SchoolSystemEngine(userInterface, commandProvider);
return(engine);
}
// Called after LookingGlass is initialized
public void Initialize()
{
try {
// get a handle to the renderer module in LookingGlass
string rendererName = m_lgb.AppParams.ParamString("RadegastWindow.Renderer.Name");
m_framesPerSec = Math.Min(100, Math.Max(1, m_lgb.AppParams.ParamInt("RadegastWindow.FramesPerSec")));
m_frameTimeMs = 1000 / m_framesPerSec;
m_frameAllowanceMs = Math.Max(m_framesPerSec - 20, 10);
m_renderer = (IRenderProvider)m_lgb.ModManager.Module(rendererName);
if (m_renderer == null) {
m_log.Log(LogLevel.DBADERROR, "RadegastWindow.Initialize: COULD NOT ATTACH RENDERER '{0};", rendererName);
throw new LookingGlassException(String.Format("RadegastWindow.Initialize: COULD NOT ATTACH RENDERER '{0};", rendererName));
}
m_log.Log(LogLevel.DVIEWDETAIL, "Initialize. Connecting to renderer {0} at {1}fps",
m_renderer, m_framesPerSec);
// The linkage to the renderer for display is also a link into it's UI system
m_UILink = m_renderer.UserInterface;
m_refreshTimer = new System.Threading.Timer(delegate(Object param) {
this.LGWindow.Invalidate();
}, null, 2000, m_frameTimeMs);
}
catch (Exception e) {
m_log.Log(LogLevel.DBADERROR, "Initialize. exception: {0}", e.ToString());
throw new LookingGlassException("Exception initializing view");
}
}
// ==========================================================================
// IModule.Stop()
public override void Stop()
{
if (m_userInterface != null) {
m_userInterface.Dispose();
m_userInterface = null;
}
return;
}
// ==========================================================================
public override bool AfterAllModulesLoaded()
{
// allow others to get our statistics
m_restHandler = new RestHandler("/stats/" + m_moduleName + "/detailStats", m_stats);
#region OGRE STATS
// Setup the shared piece of memory that Ogre can place statistics in
m_ogreStatsPinned = new int[Ogr.StatSize];
for (int ii = 0; ii < Ogr.StatSize; ii++) m_ogreStatsPinned[ii] = 0;
if (ModuleParams.ParamBool("Renderer.Ogre.CollectOgreStats")) {
m_ogreStatsHandle = GCHandle.Alloc(m_ogreStatsPinned, GCHandleType.Pinned);
Ogr.SetStatsBlock(m_ogreStatsHandle.AddrOfPinnedObject());
// m_ogreStatsPinned = (int[])Marshal.AllocHGlobal(Ogr.StatSize * 4);
// Ogr.SetStatsBlock(m_ogreStatsPinned);
}
// Create a ParameterSet that can be read externally via REST/JSON
m_ogreStats = new ParameterSet();
// add an initial parameter that calculates frames per sec
m_ogreStats.Add("FramesPerSecond",
delegate(string xx) {
// Ogre passed the number *1000 so there can be some decimal points
float fps = (float)m_ogreStatsPinned[Ogr.StatFramesPerSec] / 1000f;
return new OMVSD.OSDString(fps.ToString());
}, "Frames per second"
);
m_ogreStats.Add("LastFrameMS", delegate(string xx) {
return new OMVSD.OSDString(m_ogreStatsPinned[Ogr.StatLastFrameMs].ToString()); },
"Milliseconds used rendering last frame");
m_ogreStats.Add("TotalFrames", delegate(string xx) {
return new OMVSD.OSDString(m_ogreStatsPinned[Ogr.StatTotalFrames].ToString()); },
"Number of frames rendered");
m_ogreStats.Add("VisibleToVisible", delegate(string xx) {
return new OMVSD.OSDString(m_ogreStatsPinned[Ogr.StatVisibleToVisible].ToString()); },
"Meshes at were visible that are still visible in last frame");
m_ogreStats.Add("InvisibleToVisible", delegate(string xx) {
return new OMVSD.OSDString(m_ogreStatsPinned[Ogr.StatInvisibleToVisible].ToString()); },
"Meshes that were invisible that are now visible in last frame");
m_ogreStats.Add("VisibleToInvisible", delegate(string xx) {
return new OMVSD.OSDString(m_ogreStatsPinned[Ogr.StatVisibleToInvisible].ToString()); },
"Meshes that were visible that are now invisible in last frame");
m_ogreStats.Add("InvisibleToInvisible", delegate(string xx) {
return new OMVSD.OSDString(m_ogreStatsPinned[Ogr.StatInvisibleToInvisible].ToString()); },
"Meshes that were invisible that are still invisible in last frame");
m_ogreStats.Add("CullMeshesLoaded", delegate(string xx) {
return new OMVSD.OSDString(m_ogreStatsPinned[Ogr.StatCullMeshesLoaded].ToString()); },
"Total meshes loaded due to unculling");
m_ogreStats.Add("CullTexturesLoaded", delegate(string xx) {
return new OMVSD.OSDString(m_ogreStatsPinned[Ogr.StatCullTexturesLoaded].ToString()); },
"Total textures loaded due to unculling");
m_ogreStats.Add("CullMeshesUnloaded", delegate(string xx) {
return new OMVSD.OSDString(m_ogreStatsPinned[Ogr.StatCullMeshesUnloaded].ToString()); },
"Total meshes unloaded due to culling");
m_ogreStats.Add("CullTexturesUnloaded", delegate(string xx) {
return new OMVSD.OSDString(m_ogreStatsPinned[Ogr.StatCullTexturesUnloaded].ToString()); },
"Total textures unloaded due to culling");
m_ogreStats.Add("CullMeshesQueuedToLoad", delegate(string xx) {
return new OMVSD.OSDString(m_ogreStatsPinned[Ogr.StatCullMeshesQueuedToLoad].ToString()); },
"Meshes currently queued to load due to unculling");
// between frame work
m_ogreStats.Add("BetweenFrameworkItems", delegate(string xx) {
return new OMVSD.OSDString(m_ogreStatsPinned[Ogr.StatBetweenFrameWorkItems].ToString()); },
"Number of between frame work items waiting");
m_ogreStats.Add("BetweenFrameworkDiscardedDups", delegate(string xx) {
return new OMVSD.OSDString(m_ogreStatsPinned[Ogr.StatBetweenFrameDiscardedDups].ToString()); },
"Between frame work requests which duplicated existing requests");
m_ogreStats.Add("TotalBetweenFrameRefreshResource", delegate(string xx) {
return new OMVSD.OSDString(m_ogreStatsPinned[Ogr.StatBetweenFrameRefreshResource].ToString()); },
"Number of 'refresh resource' work items queued");
m_ogreStats.Add("TotalBetweenFrameRemoveSceneNode", delegate(string xx) {
return new OMVSD.OSDString(m_ogreStatsPinned[Ogr.StatBetweenFrameRemoveSceneNode].ToString()); },
"Number of 'remove scene node' work items queued");
m_ogreStats.Add("TotalBetweenFrameCreateMaterialResource", delegate(string xx) {
return new OMVSD.OSDString(m_ogreStatsPinned[Ogr.StatBetweenFrameCreateMaterialResource].ToString()); },
"Number of 'create material resource' work items queued");
m_ogreStats.Add("TotalBetweenFrameCreateMeshResource", delegate(string xx) {
return new OMVSD.OSDString(m_ogreStatsPinned[Ogr.StatBetweenFrameCreateMeshResource].ToString()); },
"Number of 'create mesh resource' work items queued");
m_ogreStats.Add("TotalBetweenFrameCreateMeshScenenode", delegate(string xx) {
return new OMVSD.OSDString(m_ogreStatsPinned[Ogr.StatBetweenFrameCreateMeshSceneNode].ToString()); },
"Number of 'create mesh scene node' work items queued");
m_ogreStats.Add("TotalBetweenFrameAddLoadedMesh", delegate(string xx) {
return new OMVSD.OSDString(m_ogreStatsPinned[Ogr.StatBetweenFrameAddLoadedMesh].ToString()); },
"Number of 'add loaded mesh' work items queued");
m_ogreStats.Add("TotalBetweenframeupdatescenenode", delegate(string xx) {
return new OMVSD.OSDString(m_ogreStatsPinned[Ogr.StatBetweenFrameUpdateSceneNode].ToString()); },
"Number of 'update scene node' work items queued");
m_ogreStats.Add("TotalBetweenFrameUnknownProcess", delegate(string xx) {
return new OMVSD.OSDString(m_ogreStatsPinned[Ogr.StatBetweenFrameUnknownProcess].ToString()); },
"Number of work items with unknow process codes");
m_ogreStats.Add("TotalBetweenFrameTotalProcessed", delegate(string xx) {
return new OMVSD.OSDString(m_ogreStatsPinned[Ogr.StatBetweenFrameTotalProcessed].ToString()); },
"Total number of work items actually processed");
// material processing queues
m_ogreStats.Add("MaterialUpdatesRemaining", delegate(string xx) {
return new OMVSD.OSDString(m_ogreStatsPinned[Ogr.StatMaterialUpdatesRemaining].ToString()); },
"Number of material updates waiting");
// mesh processing queues
m_ogreStats.Add("MeshTrackerLoadQueued", delegate(string xx) {
return new OMVSD.OSDString(m_ogreStatsPinned[Ogr.StatMeshTrackerLoadQueued].ToString()); },
"Number of mesh loads queued");
m_ogreStats.Add("MeshTrackerUnloadQueued", delegate(string xx) {
return new OMVSD.OSDString(m_ogreStatsPinned[Ogr.StatMeshTrackerUnloadQueued].ToString()); },
"Number of mesh unloads queued");
m_ogreStats.Add("MeshTrackerSerializedQueued", delegate(string xx) {
return new OMVSD.OSDString(m_ogreStatsPinned[Ogr.StatMeshTrackerSerializedQueued].ToString()); },
"Number of mesh serializations queued");
m_ogreStats.Add("MeshTrackerTotalQueued", delegate(string xx) {
return new OMVSD.OSDString(m_ogreStatsPinned[Ogr.StatMeshTrackerTotalQueued].ToString()); },
"Total mesh tracker requests queued");
m_ogreStats.Add("LockParity", delegate(string xx) {
return new OMVSD.OSDString(m_ogreStatsPinned[Ogr.StatLockParity].ToString()); },
"Parity of LG locks");
m_ogreStats.Add("RoutineInOut", delegate(string xx) {
return new OMVSD.OSDString(m_ogreStatsPinned[Ogr.StatInOut].ToString()); },
"Entry and exit of routines");
// make the values accessable from outside
m_ogreStatsHandler = new RestHandler("/stats/" + m_moduleName + "/ogreStats", m_ogreStats);
#endregion OGRE STATS
// Load the input system we're supposed to be using
// The input system is a module tha we get given the name of. Go find it and link it in.
String uiModule = ModuleParams.ParamString(m_moduleName + ".Ogre.InputSystem.Name");
if (uiModule != null && uiModule.Length > 0) {
try {
m_log.Log(LogLevel.DRENDER, "Loading UI processor '{0}'", uiModule);
m_userInterface = (IUserInterfaceProvider)ModuleManager.Instance.Module(uiModule);
if (m_userInterface == null) {
m_log.Log(LogLevel.DBADERROR, "FATAL: Could not find user interface class {0}", uiModule);
return false;
}
}
catch (Exception e) {
m_log.Log(LogLevel.DBADERROR, "FATAL: Could not load user interface class {0}: {1}", uiModule, e.ToString());
return false;
}
}
else {
m_log.Log(LogLevel.DBADERROR, "Using null user interfare");
m_userInterface = new UserInterfaceNull();
}
// if we are doing detail logging, enable logging by the LookingGlassOgre code
if (m_log.WouldLog(LogLevel.DOGREDETAIL)) {
m_log.Log(LogLevel.DRENDER, "Logging detail high enough to enable unmanaged code log messages");
debugLogCallbackHandle = new Ogr.DebugLogCallback(OgrLogger);
Ogr.SetDebugLogCallback(debugLogCallbackHandle);
}
// push the callback pointers into the LookingGlassOgre code
fetchParameterCallbackHandle = new Ogr.FetchParameterCallback(GetAParameter);
Ogr.SetFetchParameterCallback(fetchParameterCallbackHandle);
checkKeepRunningCallbackHandle = new Ogr.CheckKeepRunningCallback(CheckKeepRunning);
Ogr.SetCheckKeepRunningCallback(checkKeepRunningCallbackHandle);
// link the input devices to and turn on low level IO reception
if (m_userInterface.NeedsRendererLinkage()) {
userIOCallbackHandle = new Ogr.UserIOCallback(ReceiveUserIOConv);
Ogr.SetUserIOCallback(userIOCallbackHandle);
}
// handles so unmanaged code can call back to managed code
requestResourceCallbackHandle = new Ogr.RequestResourceCallback(RequestResource);
Ogr.SetRequestResourceCallback(requestResourceCallbackHandle);
betweenFramesCallbackHandle = new Ogr.BetweenFramesCallback(ProcessBetweenFrames);
Ogr.SetBetweenFramesCallback(betweenFramesCallbackHandle);
m_sceneMagnification = float.Parse(ModuleParams.ParamString(m_moduleName + ".Ogre.LL.SceneMagnification"));
m_shouldForceMeshRebuild = ModuleParams.ParamBool(m_moduleName + ".Ogre.ForceMeshRebuild");
m_shouldRenderOnMainThread = ModuleParams.ParamBool(m_moduleName + ".ShouldRenderOnMainThread");
m_shouldPrebuildMesh = ModuleParams.ParamBool(ModuleName + ".Ogre.PrebuildMesh");
// pick up a bunch of parameterized values
m_betweenFrameTotalCost = ModuleParams.ParamInt(m_moduleName + ".Ogre.BetweenFrame.Costs.Total");
// start up the Ogre renderer
try {
Ogr.InitializeOgre();
}
catch (Exception e) {
m_log.Log(LogLevel.DBADERROR, "EXCEPTION INITIALIZING OGRE: {0}", e.ToString());
return false;
}
m_sceneMgr = new OgreSceneMgr(Ogr.GetSceneMgr());
// if we get here, rendering is set up and running
return true;
}
internal static GraphViewProvider GetGraphViewProvider(Activity activity, TraceDataSource dataSource, IWindowlessControlContainerExt container, IErrorReport errorReport, IUserInterfaceProvider userIP, GraphViewMode mode, object initData)
{
GraphViewProvider graphViewProvider = null;
if (activity != null && dataSource != null && container != null && errorReport != null)
{
if (mode == GraphViewMode.TraceMode)
{
graphViewProvider = new ActivityTraceModeGraphProvider(activity, dataSource, container, errorReport, userIP, mode);
}
if (graphViewProvider != null && initData != null)
{
graphViewProvider.Initialize(initData);
}
}
return(graphViewProvider);
}
public void Initialize(CustomFilterManager filterManager, IUserInterfaceProvider userIP, TraceViewerForm appForm)
{
this.filterManager = filterManager;
this.userIP = userIP;
this.appForm = appForm;
}
public ProjectManager(TraceViewerForm parent)
{
parent.DataSourceChangedHandler = (TraceViewerForm.DataSourceChanged)Delegate.Combine(parent.DataSourceChangedHandler, new TraceViewerForm.DataSourceChanged(DataSource_OnChanged));
userIP = parent.GetInterfaceProvider();
}
public void Initialize()
{
try {
// the link to the renderer for display is also a link to the user interface routines
m_UILink = m_renderer.UserInterface;
m_cameraModified = true;
m_refreshTimer = new System.Threading.Timer(delegate(Object param) {
this.glControl.Invalidate();
}, null, 2000, m_frameTimeMs);
}
catch (Exception e) {
m_log.Log(LogLevel.DBADERROR, "Initialize. exception: {0}", e.ToString());
throw new LookingGlassException("Exception initializing view");
}
}
public void Dispose() {
if (m_ui != null) {
m_ui.Dispose();
m_ui = null;
}
}
// IModule.AfterAllModulesLoaded
public virtual bool AfterAllModulesLoaded()
{
LogManager.Log.Log(LogLevel.DINIT, ModuleName + ".AfterAllModulesLoaded()");
m_userInterface = new UserInterfaceNull();
return true;
}
internal ActivityTraceModeGraphProvider(Activity activity, TraceDataSource dataSource, IWindowlessControlContainerExt container, IErrorReport errorReport, IUserInterfaceProvider userIP, GraphViewMode mode)
: base(activity, dataSource, container, errorReport, userIP, mode)
{
}
// IModule.AfterAllModulesLoaded
public bool AfterAllModulesLoaded()
{
LogManager.Log.Log(LogLevel.DINIT, ModuleName + ".AfterAllModulesLoaded()");
// Load the input system we're supposed to be using
// The input system is a module tha we get given the name of. Go find it and link it in.
String uiModule = ModuleParams.ParamString(m_moduleName + ".InputSystem.Name");
if (uiModule != null && uiModule.Length > 0) {
try {
m_log.Log(LogLevel.DRENDER, "Loading UI processor '{0}'", uiModule);
m_userInterface = (IUserInterfaceProvider)ModuleManager.Instance.Module(uiModule);
if (m_userInterface == null) {
m_log.Log(LogLevel.DBADERROR, "FATAL: Could not find user interface class {0}", uiModule);
return false;
}
}
catch (Exception e) {
m_log.Log(LogLevel.DBADERROR, "FATAL: Could not load user interface class {0}: {1}", uiModule, e.ToString());
return false;
}
}
else {
m_log.Log(LogLevel.DBADERROR, "Using null user interfare");
m_userInterface = new UserInterfaceNull();
}
return true;
}
