示例#1
0
        Stream(ArrayList data, PlotProgress plotProgress)
        {
            data.Add(new Snoop.Data.ClassSeparator(typeof(PlotProgress)));

            data.Add(new Snoop.Data.Bool("Is plot cancelled", plotProgress.IsPlotCancelled));
            data.Add(new Snoop.Data.Bool("Is sheet cancelled", plotProgress.IsSheetCancelled));
            data.Add(new Snoop.Data.Bool("Is visible", plotProgress.IsVisible));
            data.Add(new Snoop.Data.Int("Lower plot progress range", plotProgress.LowerPlotProgressRange));
            data.Add(new Snoop.Data.Int("Lower sheet progress range", plotProgress.LowerSheetProgressRange));
            data.Add(new Snoop.Data.String("Plot cancel status", plotProgress.PlotCancelStatus.ToString()));
            data.Add(new Snoop.Data.Int("Plot progress pos", plotProgress.PlotProgressPos));
            data.Add(new Snoop.Data.String("Sheet cancel status", plotProgress.SheetCancelStatus.ToString()));
            data.Add(new Snoop.Data.Int("Sheet progress pos", plotProgress.SheetProgressPos));
            data.Add(new Snoop.Data.String("Status msg string", plotProgress.StatusMsgString));
            data.Add(new Snoop.Data.Int("Upper plot progress range", plotProgress.UpperPlotProgressRange));
            data.Add(new Snoop.Data.Int("Upper sheet progress range", plotProgress.UpperSheetProgressRange));

            PlotProgressDialog plotProgDlg = plotProgress as PlotProgressDialog;

            if (plotProgDlg != null)
            {
                Stream(data, plotProgDlg);
                return;
            }
        }
示例#2
0
		void callback_BeginPlot(object sender, BeginPlotEventArgs e)
		{
			PlotProgress oPlotProgress = e.PlotProgress;
			if (oPlotProgress != null)
				WriteLine(string.Format("BeginPlot - PlotProgress.IsVisible:{0} PlotType:{1}",e.PlotProgress.IsVisible, e.PlotType));
			else
				WriteLine(string.Format("BeginPlot - PlotProgress:null PlotType:{0}", e.PlotType));
		}
示例#3
0
        CollectEvent(object sender, CollectorEventArgs e)
        {
            // cast the sender object to the SnoopCollector we are expecting
            Collector snoopCollector = sender as Collector;

            if (snoopCollector == null)
            {
                Debug.Assert(false);    // why did someone else send us the message?
                return;
            }

            // see if it is a type we are responsible for
            PlotLogger log = e.ObjToSnoop as PlotLogger;

            if (log != null)
            {
                Stream(snoopCollector.Data(), log);
                return;
            }

            DsdData dsdData = e.ObjToSnoop as DsdData;

            if (dsdData != null)
            {
                Stream(snoopCollector.Data(), dsdData);
                return;
            }

            DsdEntry dsdEntry = e.ObjToSnoop as DsdEntry;

            if (dsdEntry != null)
            {
                Stream(snoopCollector.Data(), dsdEntry);
                return;
            }

            Dwf3dOptions dwf3dOpt = e.ObjToSnoop as Dwf3dOptions;

            if (dwf3dOpt != null)
            {
                Stream(snoopCollector.Data(), dwf3dOpt);
                return;
            }

            BeginDocumentEventArgs beginDocArgs = e.ObjToSnoop as BeginDocumentEventArgs;

            if (beginDocArgs != null)
            {
                Stream(snoopCollector.Data(), beginDocArgs);
                return;
            }

            BeginPageEventArgs beginPageArgs = e.ObjToSnoop as BeginPageEventArgs;

            if (beginPageArgs != null)
            {
                Stream(snoopCollector.Data(), beginPageArgs);
                return;
            }

            BeginPlotEventArgs beginPlotArgs = e.ObjToSnoop as BeginPlotEventArgs;

            if (beginPlotArgs != null)
            {
                Stream(snoopCollector.Data(), beginPlotArgs);
                return;
            }

            EndDocumentEventArgs endDocArgs = e.ObjToSnoop as EndDocumentEventArgs;

            if (endDocArgs != null)
            {
                Stream(snoopCollector.Data(), endDocArgs);
                return;
            }

            EndPageEventArgs endPageArgs = e.ObjToSnoop as EndPageEventArgs;

            if (endPageArgs != null)
            {
                Stream(snoopCollector.Data(), endPageArgs);
                return;
            }

            EndPlotEventArgs endPlotArgs = e.ObjToSnoop as EndPlotEventArgs;

            if (endPlotArgs != null)
            {
                Stream(snoopCollector.Data(), endPlotArgs);
                return;
            }

            PlotInfo plotInfo = e.ObjToSnoop as PlotInfo;

            if (plotInfo != null)
            {
                Stream(snoopCollector.Data(), plotInfo);
                return;
            }

            PlotPageInfo plotPageInfo = e.ObjToSnoop as PlotPageInfo;

            if (plotPageInfo != null)
            {
                Stream(snoopCollector.Data(), plotPageInfo);
                return;
            }

            PlotConfig plotConfig = e.ObjToSnoop as PlotConfig;

            if (plotConfig != null)
            {
                Stream(snoopCollector.Data(), plotConfig);
                return;
            }

            PlotConfigInfo plotConfigInfo = e.ObjToSnoop as PlotConfigInfo;

            if (plotConfigInfo != null)
            {
                Stream(snoopCollector.Data(), plotConfigInfo);
                return;
            }

            PlotEngine plotEngine = e.ObjToSnoop as PlotEngine;

            if (plotEngine != null)
            {
                Stream(snoopCollector.Data(), plotEngine);
                return;
            }

            PlotInfoValidator plotInfoValidator = e.ObjToSnoop as PlotInfoValidator;

            if (plotInfoValidator != null)
            {
                Stream(snoopCollector.Data(), plotInfoValidator);
                return;
            }

            PlotProgress plotProgress = e.ObjToSnoop as PlotProgress;

            if (plotProgress != null)
            {
                Stream(snoopCollector.Data(), plotProgress);
                return;
            }

            // ValueTypes we have to treat a bit different
            if (e.ObjToSnoop is MediaBounds)
            {
                Stream(snoopCollector.Data(), (MediaBounds)e.ObjToSnoop);
                return;
            }
        }