private void OnIdle(object sender, EventArgs e)
{
Application.Idle -= new EventHandler(this.OnIdle);
if (this._state[StateReloadAtIdle])
{
this._state[StateReloadAtIdle] = false;
DesignSurfaceManager service = (DesignSurfaceManager)this.GetService(typeof(DesignSurfaceManager));
DesignSurface objB = (DesignSurface)this.GetService(typeof(DesignSurface));
if (((service != null) && (objB != null)) && !object.ReferenceEquals(service.ActiveDesignSurface, objB))
{
this._state[StateActiveDocument] = false;
this._state[StateDeferredReload] = true;
}
else
{
IDesignerLoaderHost loaderHost = this.LoaderHost;
if ((loaderHost != null) && (this._state[StateForceReload] || this.IsReloadNeeded()))
{
try
{
if (this._state[StateFlushReload])
{
this.Flush();
}
this.UnloadDocument();
loaderHost.Reload();
}
finally
{
this._state[(StateForceReload | StateModifyIfErrors) | StateFlushReload] = false;
}
}
}
}
}
/// <summary>
/// Initialize the workflow designer loader
/// </summary>
protected override void Initialize()
{
base.Initialize();
//add any necessary services
IDesignerLoaderHost host = LoaderHost;
if (host != null)
{
//add the custom MenuCommandService
host.AddService(
typeof(IMenuCommandService),
new WorkflowMenuService(host));
//add the TypeProvider
host.AddService(
typeof(ITypeProvider), _typeProvider, true);
//add the toolbox service
_toolboxService = new WorkflowToolboxService(host);
host.AddService(
typeof(IToolboxService), _toolboxService);
//add the property value UI service
host.AddService(
typeof(IPropertyValueUIService),
new WorkflowPropertyValueService());
//add the event binding service
host.AddService(
typeof(IEventBindingService),
new WorkflowEventBindingService(host));
}
}
public override void Dispose()
{
if (this._state[StateReloadAtIdle])
{
Application.Idle -= new EventHandler(this.OnIdle);
}
this.UnloadDocument();
IComponentChangeService service = (IComponentChangeService)this.GetService(typeof(IComponentChangeService));
if (service != null)
{
service.ComponentAdded -= new ComponentEventHandler(this.OnComponentAdded);
service.ComponentAdding -= new ComponentEventHandler(this.OnComponentAdding);
service.ComponentRemoving -= new ComponentEventHandler(this.OnComponentRemoving);
service.ComponentRemoved -= new ComponentEventHandler(this.OnComponentRemoved);
service.ComponentChanged -= new ComponentChangedEventHandler(this.OnComponentChanged);
service.ComponentChanging -= new ComponentChangingEventHandler(this.OnComponentChanging);
service.ComponentRename -= new ComponentRenameEventHandler(this.OnComponentRename);
}
if (this._host != null)
{
this._host.RemoveService(typeof(IDesignerLoaderService));
this._host.Activated -= new EventHandler(this.OnDesignerActivate);
this._host.Deactivated -= new EventHandler(this.OnDesignerDeactivate);
this._host = null;
}
}
public override void BeginLoad(IDesignerLoaderHost host)
{
string baseClassName;
if (host == null)
{
throw new ArgumentNullException("SampleDesignerLoader.BeginLoad: Invalid designerLoaderHost.");
}
this.host = host;
ArrayList errors = new ArrayList();
bool successful = true;
host.AddService(typeof(IDesignerSerializationManager), new SampleDesignerSerializationManager(this));
host.AddService(typeof(IEventBindingService), new SampleEventBindingService(host));
host.AddService(typeof(ITypeResolutionService), new SampleTypeResolutionService());
host.AddService(typeof(CodeDomProvider), new CSharpCodeProvider());
host.AddService(typeof(IResourceService), new SampleResourceService(host));
if (this.fileName == null)
{
baseClassName = host.CreateComponent(typeof(Form)).Site.Name;
}
else
{
baseClassName = this.ReadFile(this.fileName, errors, out this.xmlDocument);
}
IComponentChangeService cs = host.GetService(typeof(IComponentChangeService)) as IComponentChangeService;
if (cs != null)
{
cs.ComponentChanged += new ComponentChangedEventHandler(this.OnComponentChanged);
cs.ComponentAdded += new ComponentEventHandler(this.OnComponentAddedRemoved);
cs.ComponentRemoved += new ComponentEventHandler(this.OnComponentAddedRemoved);
}
host.EndLoad(baseClassName, successful, errors);
this.dirty = true;
this.unsaved = false;
}
/// <summary>
/// 载入页面的时候调用，负责从xml文件读取信息
/// 调用函数ReadFile进行描述文件节点的具体信息处理，根据读取的信息进行设计器的加载。
/// </summary>
/// <param name="document">需要加载的xml文件</param>
/// <returns></returns>
public bool MyPerformLoad(XmlDocument document)
{
ArrayList errors = new ArrayList();
bool successful = true; //标志加载过程是否成功
string baseClassName = null;
this.hostLoader = this.LoaderHost; //获取加载程序宿主。（从 BasicDesignerLoader 继承。）
if (hostLoader == null)
{
//CassMessageBox.Warning("设计器加载异常！");
return(false);
}
//存放错误信息,如果加载期间遇到错误，则必须将这些错误作为异常集合传递到 errorCollection 参数中。
baseClassName = ReadFile(document, errors);
if (baseClassName == null)
{
return(false);
}
if (errors.Count > 0)
{
successful = false;
}
// 结束设计器加载操作。
//baseClassName 此设计器正在设计的文档的基类的完全限定名。
//successful 如果设计器已成功加载，则为 true；否则为 false。
//errorCollection 包含加载期间遇到的错误（如果有的话）的集合。
hostLoader.EndLoad(baseClassName, successful, errors);
return(successful);
}
public WorkflowDesignerEventsCoordinator(IDesignerLoaderHost serviceProvider)
{
this.serviceProvider = serviceProvider;
this.serviceProvider.LoadComplete += new EventHandler(this.OnDesignerReloaded);
IDesignerEventService service = this.serviceProvider.GetService(typeof(IDesignerEventService)) as IDesignerEventService;
if (service != null)
{
service.ActiveDesignerChanged += new ActiveDesignerEventHandler(this.OnActiveDesignerChanged);
}
ITypeProvider provider = this.serviceProvider.GetService(typeof(ITypeProvider)) as ITypeProvider;
if (provider != null)
{
provider.TypesChanged += new EventHandler(this.OnTypeSystemTypesChanged);
}
ISelectionService service2 = this.serviceProvider.GetService(typeof(ISelectionService)) as ISelectionService;
if (service2 != null)
{
service2.SelectionChanged += new EventHandler(this.OnSelectionChanged);
}
IComponentChangeService service3 = this.serviceProvider.GetService(typeof(IComponentChangeService)) as IComponentChangeService;
if (service3 != null)
{
service3.ComponentChanged += new ComponentChangedEventHandler(this.OnComponentChanged);
}
IPropertyValueUIService service4 = this.serviceProvider.GetService(typeof(IPropertyValueUIService)) as IPropertyValueUIService;
if (service4 != null)
{
service4.AddPropertyValueUIHandler(new PropertyValueUIHandler(this.OnPropertyGridAdornments));
}
}
/// <summary>
/// Flushes all changes to the designer.
/// </summary>
/// <param name="serializationManager">An <see cref="T:System.ComponentModel.Design.Serialization.IDesignerSerializationManager"/> to use for persisting the state of loaded designers.</param>
protected override void PerformFlush(IDesignerSerializationManager serializationManager)
{
bool success = true;
ArrayList errors = new ArrayList();
IDesignerHost idh = (IDesignerHost)this.Host.GetService(typeof(IDesignerHost));
Controls.ISerializableControl serializable = (LoaderHost.RootComponent as Controls.ISerializableControl);
if (serializable == null)
{
throw new ApplicationException("Invalid root control type in designer.");
}
Serialization.SerializationObject serializationObject = this.GetSerializationObject();
try
{
this.Buffer = this.SerializeFrameXml(serializationObject);
}
catch (Exception exception)
{
Debug.WriteLine(exception);
success = false;
errors.Add(exception);
}
IDesignerLoaderHost host = this.LoaderHost;
host.EndLoad(FrameXmlDesignerLoader.hostedBaseClassName, success, errors);
Trace.WriteLine("PerformFlush");
}
/// <include file='doc\VSDesignerLoader.uex' path='docs/doc[@for="VSDesignerLoader.CreateCodeLoader"]/*' />
/// <devdoc>
/// Called to create the MCM loader.
/// </devdoc>
protected override CodeLoader CreateCodeLoader(TextBuffer buffer, IDesignerLoaderHost host)
{
CodeLoader loader = null;
// Get the context object off of the hierarchy, and ask it for an IVSMDCodeDomProvider
// instance.
//
IVsHierarchy hier = Hierarchy;
if (hier is IVsProject)
{
NativeMethods.IOleServiceProvider oleProvider = (NativeMethods.IOleServiceProvider)((IVsProject)hier).GetItemContext(ItemId);
if (oleProvider != null)
{
ServiceProvider contextProv = new ServiceProvider(oleProvider);
IVSMDCodeDomProvider codeDomProvider = (IVSMDCodeDomProvider)contextProv.GetService(typeof(IVSMDCodeDomProvider));
if (codeDomProvider != null)
{
loader = new VsCodeDomLoader(this, hier, ItemId, (CodeDomProvider)codeDomProvider.CodeDomProvider, buffer, host);
}
}
}
if (loader == null)
{
throw new NotSupportedException(SR.GetString(SR.DESIGNERLOADERNoLanguageSupport));
}
return(loader);
}
void SetDesignerSupportsProjectResourcesToFalse(IDesignerLoaderHost host)
{
ProjectResourceService projectResourceService = host.GetService(typeof(ProjectResourceService)) as ProjectResourceService;
if (projectResourceService != null) {
projectResourceService.DesignerSupportsProjectResources = false;
}
}
public WorkflowDesignerEventsCoordinator(IDesignerLoaderHost serviceProvider)
{
this.serviceProvider = serviceProvider;
this.serviceProvider.LoadComplete += new EventHandler(this.OnDesignerReloaded);
IDesignerEventService service = this.serviceProvider.GetService(typeof(IDesignerEventService)) as IDesignerEventService;
if (service != null)
{
service.ActiveDesignerChanged += new ActiveDesignerEventHandler(this.OnActiveDesignerChanged);
}
ITypeProvider provider = this.serviceProvider.GetService(typeof(ITypeProvider)) as ITypeProvider;
if (provider != null)
{
provider.TypesChanged += new EventHandler(this.OnTypeSystemTypesChanged);
}
ISelectionService service2 = this.serviceProvider.GetService(typeof(ISelectionService)) as ISelectionService;
if (service2 != null)
{
service2.SelectionChanged += new EventHandler(this.OnSelectionChanged);
}
IComponentChangeService service3 = this.serviceProvider.GetService(typeof(IComponentChangeService)) as IComponentChangeService;
if (service3 != null)
{
service3.ComponentChanged += new ComponentChangedEventHandler(this.OnComponentChanged);
}
IPropertyValueUIService service4 = this.serviceProvider.GetService(typeof(IPropertyValueUIService)) as IPropertyValueUIService;
if (service4 != null)
{
service4.AddPropertyValueUIHandler(new PropertyValueUIHandler(this.OnPropertyGridAdornments));
}
}
// TODO: toggle comments of exception handlers
//
public override void BeginLoad(IDesignerLoaderHost host)
{
if (host == null)
{
throw new ArgumentNullException("host");
}
if (_loaded)
{
throw new InvalidOperationException("Already loaded.");
}
if (_host != null && _host != host)
{
throw new InvalidOperationException("Trying to load with a different host");
}
if (_host == null) // beingload is called on reload - no need to initialize twice.
{
_host = host;
Initialize();
}
IDisposable session = _serializationMananger.CreateSession();
IDesignerLoaderService loader = _host.GetService(typeof(IDesignerLoaderService)) as IDesignerLoaderService;
if (loader != null)
{
_dependenciesCount = -1;
loader.AddLoadDependency();
}
else
{
OnBeginLoad();
}
bool successful = true;
// try {
PerformLoad(_serializationMananger);
// } catch (Exception e) {
// successful = false;
// _serializationMananger.Errors.Add (e);
// while (e.InnerException != null) {
// _serializationMananger.Errors.Add (e);
// Console.WriteLine (e.InnerException);
// e = e.InnerException;
// }
// }
if (loader != null)
{
loader.DependentLoadComplete(successful, _serializationMananger.Errors);
}
else
{
OnEndLoad(successful, _serializationMananger.Errors);
}
session.Dispose();
}
/// <include file='doc\SoapDesignerLoader.uex' path='docs/doc[@for="SoapDesignerLoader.CreateCodeLoader"]/*' />
/// <devdoc>
/// Called to create the MCM loader.
/// </devdoc>
protected override CodeLoader CreateCodeLoader(TextBuffer buffer, IDesignerLoaderHost host)
{
// Now create the generic loader
//
CodeDomProvider provider = new SoapCodeProvider();
return(new CodeDomLoader(this, provider, buffer, host));
}
public override void BeginLoad(IDesignerLoaderHost host)
{
this.loading = true;
this.typeResolutionService = (ITypeResolutionService)host.GetService(typeof(ITypeResolutionService));
this.designerLoaderHost = host;
base.BeginLoad(host);
}
/// <include file='doc\DocumentManager.uex' path='docs/doc[@for="DocumentManager.ComponentDesignerLoader.Dispose"]/*' />
/// <devdoc>
/// The host will call this method when it no longer needs the
/// code stream. Typically, this only happens when the document is closed.
/// </devdoc>
public override void Dispose()
{
if (host != null)
{
host.RemoveService(typeof(IDesignerLoaderService));
}
host = null;
}
protected BasicDesignerLoader()
{
_loading = _loaded = _flushing = _reloadScheduled = false;
_host = null;
_notificationsEnabled = false;
_modified = false;
_dependenciesCount = 0;
}
protected BasicDesignerLoader ()
{
_loading = _loaded = _flushing = _reloadScheduled = false;
_host = null;
_notificationsEnabled = false;
_modified = false;
_dependenciesCount = 0;
}
public override void BeginLoad(IDesignerLoaderHost host)
{
this.loading = true;
this.typeResolutionService = (ITypeResolutionService)host.GetService(typeof(ITypeResolutionService));
this.designerLoaderHost = host;
base.BeginLoad(host);
}
public override void BeginLoad(IDesignerLoaderHost host)
{
Debug.Assert(host != null);
this.host = host;
host.AddService(typeof(INameCreationService), new NameCreationService(host));
host.AddService(typeof(ComponentSerializationService), new CodeDomComponentSerializationService((IServiceProvider)host));
host.AddService(typeof(IDesignerSerializationService), new DesignerSerializationService((IServiceProvider)host));
base.BeginLoad(host);
}
void SetDesignerSupportsProjectResourcesToFalse(IDesignerLoaderHost host)
{
ProjectResourceService projectResourceService = host.GetService(typeof(ProjectResourceService)) as ProjectResourceService;
if (projectResourceService != null)
{
projectResourceService.DesignerSupportsProjectResources = false;
}
}
public override void BeginLoad(IDesignerLoaderHost host)
{
Debug.Assert(host != null);
this.host = host;
host.AddService(typeof(INameCreationService), new NameCreationService(host));
host.AddService(typeof(ComponentSerializationService), new CodeDomComponentSerializationService((IServiceProvider)host));
host.AddService(typeof(IDesignerSerializationService), new DesignerSerializationService((IServiceProvider)host));
base.BeginLoad(host);
}
protected override void PerformLoad(IDesignerSerializationManager designerSerializationManager)
{
this.host = this.LoaderHost;
if (host == null)
{
throw new ArgumentNullException("BasicHostLoader.BeginLoad: Invalid designerLoaderHost.");
}
ArrayList errors = new ArrayList();
bool successful = true;
string baseClassName;
if (fileName == null)
{
if (rootComponentType == typeof(Form))
{
IComponent component = host.CreateComponent(rootComponentType);
(component as Form).FormBorderStyle = FormBorderStyle.None;
(component as Form).Size = Screen.PrimaryScreen.Bounds.Size;
baseClassName = "Form1";
}
else if (rootComponentType == typeof(UserControl))
{
host.CreateComponent(typeof(UserControl));
baseClassName = "UserControl1";
}
else if (rootComponentType == typeof(Component))
{
host.CreateComponent(typeof(Component));
baseClassName = "Component1";
}
else
{
throw new Exception("Undefined Host Type: " + rootComponentType.ToString());
}
}
else
{
baseClassName = AssemblyHelper.ReadFile(fileName, errors, out xmlDocument, host);
}
IComponentChangeService cs = host.GetService(typeof(IComponentChangeService)) as IComponentChangeService;
if (cs != null)
{
cs.ComponentChanged += new ComponentChangedEventHandler(OnComponentChanged);
cs.ComponentAdded += new ComponentEventHandler(OnComponentAddedRemoved);
cs.ComponentRemoved += new ComponentEventHandler(OnComponentAddedRemoved);
}
host.EndLoad(baseClassName, successful, errors);
_dirty = true;
_unsaved = false;
}
public override void BeginLoad(IDesignerLoaderHost host)
{
if (host == null) {
throw new ArgumentNullException("host");
}
this.host = host;
host.AddService(typeof(ComponentSerializationService), new CodeDomComponentSerializationService((IServiceProvider)host));
host.AddService(typeof(IDesignerSerializationService), new DesignerSerializationService((IServiceProvider)host));
base.BeginLoad(host);
}
/// <summary>
/// CTOR
/// </summary>
/// <param name="host"></param>
/// <param name="createAllOwnerDrawControlsDelegate"></param>
/// <param name="getControlDesignerInfo"></param>
internal ControlFactory(IDesignerLoaderHost host,
CreateAllOwnerDrawControlsDelegate createAllOwnerDrawControlsDelegate,
GetControlDesignerInfoDelegate getControlDesignerInfo,
RuntimeHostSurface runtimeHostSurface)
{
this.host = host;
this.createAllOwnerDrawControls = createAllOwnerDrawControlsDelegate;
this.getControlDesignerInfo = getControlDesignerInfo;
this.runtimeHostSurface = runtimeHostSurface;
}
protected override void PerformLoad(IDesignerSerializationManager designerSerializationManager)
{
this.host = this.LoaderHost;
ArrayList errors = new ArrayList();
bool successful = true;
string baseClassName;
baseClassName = "Home";
host.EndLoad(baseClassName, successful, errors);
}
// Note that IDesignerLoader : IDesignerHost
//
public override void BeginLoad (IDesignerLoaderHost loaderHost)
{
_loading = true;
// initializa root component and designer
//
loaderHost.CreateComponent (_componentType);
// finish off loading - no error collection here.
//
loaderHost.EndLoad (_componentType.FullName, true, null);
_loading = false;
}
public override void BeginLoad(IDesignerLoaderHost host)
{
VerifyDesignerHasDialogId();
GetDialogElement();
VerifyDialogElementFound();
AddServicesToHost(host);
base.BeginLoad(host);
}
// Note that IDesignerLoader : IDesignerHost
//
public override void BeginLoad(IDesignerLoaderHost loaderHost)
{
_loading = true;
// initializa root component and designer
//
loaderHost.CreateComponent(_componentType);
// finish off loading - no error collection here.
//
loaderHost.EndLoad(_componentType.FullName, true, null);
_loading = false;
}
public override void BeginLoad(IDesignerLoaderHost host)
{
if (host == null)
{
throw new ArgumentNullException("host");
}
this.host = host;
host.AddService(typeof(ComponentSerializationService), new CodeDomComponentSerializationService((IServiceProvider)host));
host.AddService(typeof(IDesignerSerializationService), new DesignerSerializationService((IServiceProvider)host));
base.BeginLoad(host);
}
public override void BeginLoad(IDesignerLoaderHost host)
{
VerifyDesignerHasDialogId();
GetDialogElement();
VerifyDialogElementFound();
AddServicesToHost(host);
base.BeginLoad(host);
}
protected override void Initialize()
{
base.Initialize();
IDesignerLoaderHost host = LoaderHost;
if (host != null)
{
TypeProvider typeProvider = new TypeProvider(host);
typeProvider.AddAssemblyReference(typeof(string).Assembly.Location);
}
}
public InternalReportLoader(IDesignerLoaderHost host,IDesignerGenerator generator, Stream stream)
{
if (host == null) {
throw new ArgumentNullException("host");
}
if (generator == null) {
throw new ArgumentNullException("generator");
}
this.host = host;
this.generator = generator;
this.stream = stream;
}
public static IComponent CreateComponent(IDesignerLoaderHost host, Type type, string name)
{
if (typeof(IComponent).IsAssignableFrom(type))
{
if (host != null)
{
INameCreationService cs = host.GetService(typeof(INameCreationService)) as INameCreationService;
if (cs != null)
{
IVplNameService ns = cs as IVplNameService;
if (ns != null)
{
ns.ComponentType = type;
}
}
return(host.CreateComponent(type, name));
}
else
{
IComponent ic = (IComponent)CreateObject(type);
ic.Site = new XTypeSite(ic);
ic.Site.Name = name;
return(ic);
}
}
if (host != null)
{
INameCreationService cs = host.GetService(typeof(INameCreationService)) as INameCreationService;
if (cs != null)
{
IVplNameService ns = cs as IVplNameService;
if (ns != null)
{
ns.ComponentType = typeof(XClass);
}
}
XClass obj = (XClass)host.CreateComponent(typeof(XClass), name);
obj.AssignType(type);
obj.AssignValue(CreateObject(type));
return(obj);
}
else
{
XClass obj = new XClass();
obj.Site = new XTypeSite(obj);
obj.Site.Name = name;
obj.AssignType(type);
obj.AssignValue(CreateObject(type));
return(obj);
}
}
// Called by the host when we load a document.
protected override void PerformLoad(IDesignerSerializationManager designerSerializationManager)
{
this.host = this.LoaderHost;
if (host == null)
{
throw new ArgumentNullException("BasicHostLoader.BeginLoad: Invalid designerLoaderHost.");
}
// The loader will put error messages in here.
ArrayList errors = new ArrayList();
bool successful = true;
string baseClassName = "Form1";
if (rootComponentType == typeof(Form))
{
//Control control = (Control)host.CreateComponent(typeof(GuiForm));
ControlFactory factory = new ControlFactory(host, createAllOwnerDrawControls, getControlDesignerInfo, runtimeHostSurface);
Form form = factory.PrepearForm(formToClone, null) as Form;
TypeDescriptor.GetProperties(form)["Locked"].SetValue(form, true);
baseClassName = "Form1";
SetSerializedValues(form);
SetVisibility(form);
}
// Now that we are done with the load work, we need to begin to listen to events.
// Listening to event notifications is how a designer "Loader" can also be used
// to save data. If we wanted to integrate this loader with source code control,
// we would listen to the "ing" events as well as the "ed" events.
IComponentChangeService cs = host.GetService(typeof(IComponentChangeService)) as IComponentChangeService;
if (cs != null)
{
cs.ComponentChanged += new ComponentChangedEventHandler(OnComponentChanged);
cs.ComponentAdded += new ComponentEventHandler(OnComponentAddedRemoved);
cs.ComponentRemoved += new ComponentEventHandler(OnComponentAddedRemoved);
}
// Let the host know we are done loading.
host.EndLoad(baseClassName, successful, errors);
// We've just loaded a document, so you can bet we need to flush changes.
dirty = true;
unsaved = false;
}
public override void BeginLoad(IDesignerLoaderHost host)
{
host.AddService(typeof(ComponentSerializationService), new CodeDomComponentSerializationService((IServiceProvider)host));
host.AddService(typeof(INameCreationService), new RubyNameCreationService(host));
host.AddService(typeof(IDesignerSerializationService), new DesignerSerializationService(host));
ProjectResourceService projectResourceService = host.GetService(typeof(ProjectResourceService)) as ProjectResourceService;
if (projectResourceService != null)
{
projectResourceService.DesignerSupportsProjectResources = false;
}
base.BeginLoad(host);
}
public InternalReportLoader(IDesignerLoaderHost host, IDesignerGenerator generator, Stream stream)
{
if (host == null)
{
throw new ArgumentNullException("host");
}
if (generator == null)
{
throw new ArgumentNullException("generator");
}
this.host = host;
this.generator = generator;
this.stream = stream;
}
public override void Dispose()
{
try
{
IDesignerLoaderHost host = LoaderHost;
if (host != null)
{
host.RemoveService(typeof(ITypeProvider), true);
}
}
finally
{
base.Dispose();
}
}
public override void Dispose()
{
IDesignerLoaderHost host = LoaderHost;
if (host != null)
{
host.RemoveService(typeof(IIdentifierCreationService));
host.RemoveService(typeof(IMenuCommandService));
host.RemoveService(typeof(IToolboxService));
host.RemoveService(typeof(ITypeProvider), true);
host.RemoveService(typeof(IWorkflowCompilerOptionsService));
host.RemoveService(typeof(IEventBindingService));
}
base.Dispose();
}
public override void Flush()
{
if ((!this._state[StateFlushInProgress] && this._state[StateLoaded]) && this.Modified)
{
this._state[StateFlushInProgress] = true;
Cursor current = Cursor.Current;
Cursor.Current = Cursors.WaitCursor;
try
{
IDesignerLoaderHost host = this._host;
bool flag = true;
if ((host != null) && (host.RootComponent != null))
{
using (this._serializationManager.CreateSession())
{
try
{
this.PerformFlush(this._serializationManager);
}
catch (CheckoutException)
{
flag = false;
throw;
}
catch (Exception exception)
{
this._serializationManager.Errors.Add(exception);
}
ICollection errors = this._serializationManager.Errors;
if ((errors != null) && (errors.Count > 0))
{
this.ReportFlushErrors(errors);
}
}
}
if (flag)
{
this.Modified = false;
}
}
finally
{
this._state[StateFlushInProgress] = false;
Cursor.Current = current;
}
}
}
protected override void Initialize()
{
base.Initialize();
IDesignerLoaderHost host = LoaderHost;
if (host != null)
{
host.RemoveService(typeof(IIdentifierCreationService));
host.AddService(typeof(IIdentifierCreationService), new IdentifierCreationService(host));
host.AddService(typeof(IMenuCommandService), new MenuCommandService(host));
TypeProvider typeProvider = new TypeProvider(host);
typeProvider.AddAssemblyReference(typeof(string).Assembly.Location);
host.AddService(typeof(ITypeProvider), typeProvider, true);
host.AddService(typeof(IEventBindingService), new EventBindingService());
}
}
// Called by the host when we load a document.
protected override void PerformLoad(IDesignerSerializationManager designerSerializationManager)
{
this.host = this.LoaderHost;
if (host == null)
{
throw new ArgumentNullException("BasicHostLoader.BeginLoad: Invalid designerLoaderHost.");
}
// The loader will put error messages in here.
ArrayList errors = new ArrayList();
bool successful = true;
string baseClassName;
// If no filename was passed in, just create a form and be done with it. If a file name
// was passed, read it.
if (fileName == null)
{
host.CreateComponent(rootComponentType);
baseClassName = rootComponentType.Name;
}
else
{
baseClassName = ReadFile(fileName, errors, out xmlDocument);
}
// Now that we are done with the load work, we need to begin to listen to events.
// Listening to event notifications is how a designer "Loader" can also be used
// to save data. If we wanted to integrate this loader with source code control,
// we would listen to the "ing" events as well as the "ed" events.
IComponentChangeService cs = host.GetService(typeof(IComponentChangeService)) as IComponentChangeService;
if (cs != null)
{
cs.ComponentChanged += new ComponentChangedEventHandler(OnComponentChanged);
cs.ComponentAdded += new ComponentEventHandler(OnComponentAddedRemoved);
cs.ComponentRemoved += new ComponentEventHandler(OnComponentAddedRemoved);
}
// Let the host know we are done loading.
host.EndLoad(baseClassName, successful, errors);
// We've just loaded a document, so you can bet we need to flush changes.
dirty = true;
unsaved = false;
}
public InternalReportLoader(IDesignerLoaderHost host,IDesignerGenerator generator, Stream stream)
{
if (host == null) {
throw new ArgumentNullException("host");
}
if (generator == null) {
throw new ArgumentNullException("generator");
}
if (stream == null) {
throw new ArgumentNullException("stream");
}
Console.WriteLine("---------InternalReportLoader------------");
this.host = host;
this.generator = generator;
this.stream = stream;
}
public override void BeginLoad(IDesignerLoaderHost host)
{
// Check dialog id.
if (designer.DialogId == null) {
throw new FormsDesignerLoadException(StringParser.Parse("${res:ICSharpCode.WixBinding.WixDialogDesigner.NoDialogSelectedInDocumentMessage}"));
}
// Get dialog element.
WixDocument document = CreateWixDocument();
document.LoadXml(designer.GetDocumentXml());
wixDialog = document.GetDialog(designer.DialogId, new WorkbenchTextFileReader());
if (wixDialog == null) {
throw new FormsDesignerLoadException(String.Format(StringParser.Parse("${res:ICSharpCode.WixBinding.DialogDesignerGenerator.DialogIdNotFoundMessage}"), designer.DialogId));
}
host.AddService(typeof(ComponentSerializationService), new CodeDomComponentSerializationService((IServiceProvider)host));
host.AddService(typeof(INameCreationService), new XmlDesignerLoader.NameCreationService(host));
host.AddService(typeof(IDesignerSerializationService), new DesignerSerializationService(host));
base.BeginLoad(host);
}
public override void BeginLoad (IDesignerLoaderHost host)
{
if (host == null)
throw new ArgumentNullException ("host");
if (_loaded)
throw new InvalidOperationException ("Already loaded.");
if (_host != null && _host != host)
throw new InvalidOperationException ("Trying to load with a different host");
if (_host == null) { // beingload is called on reload - no need to initialize twice.
_host = host;
Initialize ();
}
IDisposable session = _serializationMananger.CreateSession ();
IDesignerLoaderService loader = _host.GetService (typeof (IDesignerLoaderService)) as IDesignerLoaderService;
if (loader != null) {
_dependenciesCount = -1;
loader.AddLoadDependency ();
} else {
OnBeginLoad ();
}
bool successful = true;
try {
PerformLoad (_serializationMananger);
} catch (Exception e) {
successful = false;
_serializationMananger.Errors.Add (e);
}
if (loader != null)
loader.DependentLoadComplete (successful, _serializationMananger.Errors);
else
OnEndLoad (successful, _serializationMananger.Errors);
session.Dispose ();
}
public override void BeginLoad(IDesignerLoaderHost loaderHost)
{
string baseClassName = null;
if (this._type != null)
{
loaderHost.CreateComponent(this._type);
baseClassName = this._type.FullName;
}
else
{
foreach (IComponent component in this._components)
{
loaderHost.Container.Add(component);
}
}
loaderHost.EndLoad(baseClassName, true, null);
}
void AddServicesToHost(IDesignerLoaderHost host)
{
host.AddService(typeof(ComponentSerializationService), new CodeDomComponentSerializationService((IServiceProvider)host));
host.AddService(typeof(INameCreationService), new XmlDesignerNameCreationService(host));
host.AddService(typeof(IDesignerSerializationService), new DesignerSerializationService(host));
}
void BeginLoad(IDesignerLoaderHost host)
{
loader = new ScriptingDesignerLoader(new MockDesignerGenerator());
loader.BeginLoad(host);
}
public override void BeginLoad(IDesignerLoaderHost host)
{
AddServices(host);
SetDesignerSupportsProjectResourcesToFalse(host);
base.BeginLoad(host);
}
public WorkflowDesignerEventsCoordinator(IDesignerLoaderHost serviceProvider)
{
this.serviceProvider = serviceProvider;
this.serviceProvider.LoadComplete += new EventHandler(OnDesignerReloaded);
//Listen to the events so that we are sure that we appropriately refresh the designer actions and tasks when the types
//change
IDesignerEventService designerEventService = this.serviceProvider.GetService(typeof(IDesignerEventService)) as IDesignerEventService;
if (designerEventService != null)
designerEventService.ActiveDesignerChanged += new ActiveDesignerEventHandler(OnActiveDesignerChanged);
ITypeProvider typeProvider = this.serviceProvider.GetService(typeof(ITypeProvider)) as ITypeProvider;
if (typeProvider != null)
typeProvider.TypesChanged += new EventHandler(OnTypeSystemTypesChanged);
ISelectionService selectionService = this.serviceProvider.GetService(typeof(ISelectionService)) as ISelectionService;
if (selectionService != null)
selectionService.SelectionChanged += new EventHandler(OnSelectionChanged);
IComponentChangeService componentChangedService = this.serviceProvider.GetService(typeof(IComponentChangeService)) as IComponentChangeService;
if (componentChangedService != null)
componentChangedService.ComponentChanged += new ComponentChangedEventHandler(OnComponentChanged);
IPropertyValueUIService propertyValueService = this.serviceProvider.GetService(typeof(IPropertyValueUIService)) as IPropertyValueUIService;
if (propertyValueService != null)
propertyValueService.AddPropertyValueUIHandler(new PropertyValueUIHandler(OnPropertyGridAdornments));
}
public override void Dispose()
{
if (this._state[StateReloadAtIdle])
{
Application.Idle -= new EventHandler(this.OnIdle);
}
this.UnloadDocument();
IComponentChangeService service = (IComponentChangeService) this.GetService(typeof(IComponentChangeService));
if (service != null)
{
service.ComponentAdded -= new ComponentEventHandler(this.OnComponentAdded);
service.ComponentAdding -= new ComponentEventHandler(this.OnComponentAdding);
service.ComponentRemoving -= new ComponentEventHandler(this.OnComponentRemoving);
service.ComponentRemoved -= new ComponentEventHandler(this.OnComponentRemoved);
service.ComponentChanged -= new ComponentChangedEventHandler(this.OnComponentChanged);
service.ComponentChanging -= new ComponentChangingEventHandler(this.OnComponentChanging);
service.ComponentRename -= new ComponentRenameEventHandler(this.OnComponentRename);
}
if (this._host != null)
{
this._host.RemoveService(typeof(IDesignerLoaderService));
this._host.Activated -= new EventHandler(this.OnDesignerActivate);
this._host.Deactivated -= new EventHandler(this.OnDesignerDeactivate);
this._host = null;
}
}
// Called by the host when we load a document.
protected override void PerformLoad(IDesignerSerializationManager designerSerializationManager)
{
this.host = this.LoaderHost;
if (host == null)
{
throw new ArgumentNullException("BasicHostLoader.BeginLoad: Invalid designerLoaderHost.");
}
// The loader will put error messages in here.
ArrayList errors = new ArrayList();
bool successful = true;
string baseClassName;
// If no filename was passed in, just create a form and be done with it. If a file name
// was passed, read it.
if (fileName == null)
{
baseClassName = name;
if (rootComponentType == typeof(Form))
{
host.CreateComponent(typeof(Form));
}
else if (rootComponentType == typeof(UserControl))
{
host.CreateComponent(typeof(UserControl));
}
else if (rootComponentType == typeof(Component))
{
host.CreateComponent(typeof(Component));
}
else
{
throw new Exception("Undefined Host Type: " + rootComponentType.ToString());
}
}
else
{
baseClassName = ReadFile(fileName, errors, out xmlDocument);
}
// Now that we are done with the load work, we need to begin to listen to events.
// Listening to event notifications is how a designer "Loader" can also be used
// to save data. If we wanted to integrate this loader with source code control,
// we would listen to the "ing" events as well as the "ed" events.
IComponentChangeService cs = host.GetService(typeof(IComponentChangeService)) as IComponentChangeService;
if (cs != null)
{
cs.ComponentChanged += new ComponentChangedEventHandler(OnComponentChanged);
cs.ComponentAdded += new ComponentEventHandler(OnComponentAddedRemoved);
cs.ComponentRemoved += new ComponentEventHandler(OnComponentAddedRemoved);
}
// Let the host know we are done loading.
host.EndLoad(baseClassName, successful, errors);
// We've just loaded a document, so you can bet we need to flush changes.
dirty = true;
unsaved = false;
}
// Methods
public virtual void BeginLoad(IDesignerLoaderHost host) {}
// Called by the host when we load a document.
public override void BeginLoad(IDesignerLoaderHost host)
{
if (host == null)
{
throw new ArgumentNullException("SampleDesignerLoader.BeginLoad: Invalid designerLoaderHost.");
}
this.host = host;
// The loader will put error messages in here.
//
ArrayList errors = new ArrayList();
bool successful = true;
string baseClassName;
// The loader is responsible for providing certain services to the host.
//
host.AddService(typeof(IDesignerSerializationManager), new SampleDesignerSerializationManager(this));
host.AddService(typeof(IEventBindingService), new SampleEventBindingService(host));
host.AddService(typeof(ITypeResolutionService), new SampleTypeResolutionService());
host.AddService(typeof(CodeDomProvider), new CSharpCodeProvider());
host.AddService(typeof(IResourceService), new SampleResourceService(host));
// If no filename was passed in, just create a form and be done with it. If a file name
// was passed, read it.
//
if (fileName == null)
{
baseClassName = host.CreateComponent(typeof(System.Windows.Forms.Form)).Site.Name;
}
else
{
baseClassName = ReadFile(fileName, errors, out xmlDocument);
}
// Now that we are done with the load work, we need to begin to listen to events.
// Listening to event notifications is how a designer "Loader" can also be used
// to save data. If we wanted to integrate this loader with source code control,
// we would listen to the "ing" events as well as the "ed" events.
//
IComponentChangeService cs = host.GetService(typeof(IComponentChangeService)) as IComponentChangeService;
if (cs != null)
{
cs.ComponentChanged += new ComponentChangedEventHandler(OnComponentChanged);
cs.ComponentAdded += new ComponentEventHandler(OnComponentAddedRemoved);
cs.ComponentRemoved += new ComponentEventHandler(OnComponentAddedRemoved);
}
// Let the host know we are done loading.
host.EndLoad(baseClassName, successful, errors);
// We've just loaded a document, so you can bet we need to flush changes.
dirty = true;
unsaved = false;
}
/// <devdoc> /// Called by the designer host to begin the loading process. The designer /// host passes in an instance of a designer loader host (which is typically /// the same object as the designer host. This loader host allows /// the designer loader to reload the design document and also allows /// the designer loader to indicate that it has finished loading the /// design document. /// </devdoc> public abstract void BeginLoad(IDesignerLoaderHost host);
// Methods
public abstract virtual void BeginLoad(IDesignerLoaderHost host) {}
public override void BeginLoad(IDesignerLoaderHost host)
{
if (host == null)
{
throw new ArgumentNullException("host");
}
if (this._state[StateLoaded])
{
Exception exception = new InvalidOperationException(System.Design.SR.GetString("BasicDesignerLoaderAlreadyLoaded")) {
HelpLink = "BasicDesignerLoaderAlreadyLoaded"
};
throw exception;
}
if ((this._host != null) && (this._host != host))
{
Exception exception2 = new InvalidOperationException(System.Design.SR.GetString("BasicDesignerLoaderDifferentHost")) {
HelpLink = "BasicDesignerLoaderDifferentHost"
};
throw exception2;
}
this._state[StateLoaded | StateLoadFailed] = false;
this._loadDependencyCount = 0;
if (this._host == null)
{
this._host = host;
this._hostInitialized = true;
this._serializationManager = new DesignerSerializationManager(this._host);
DesignSurfaceServiceContainer container = this.GetService(typeof(DesignSurfaceServiceContainer)) as DesignSurfaceServiceContainer;
if (container != null)
{
container.AddFixedService(typeof(IDesignerSerializationManager), this._serializationManager);
}
else
{
IServiceContainer container2 = this.GetService(typeof(IServiceContainer)) as IServiceContainer;
if (container2 == null)
{
this.ThrowMissingService(typeof(IServiceContainer));
}
container2.AddService(typeof(IDesignerSerializationManager), this._serializationManager);
}
this.Initialize();
host.Activated += new EventHandler(this.OnDesignerActivate);
host.Deactivated += new EventHandler(this.OnDesignerDeactivate);
}
bool successful = true;
ArrayList errorCollection = null;
IDesignerLoaderService service = this.GetService(typeof(IDesignerLoaderService)) as IDesignerLoaderService;
try
{
if (service != null)
{
service.AddLoadDependency();
}
else
{
this._loading = true;
this.OnBeginLoad();
}
this.PerformLoad(this._serializationManager);
}
catch (Exception innerException)
{
while (innerException is TargetInvocationException)
{
innerException = innerException.InnerException;
}
errorCollection = new ArrayList();
errorCollection.Add(innerException);
successful = false;
}
if (service != null)
{
service.DependentLoadComplete(successful, errorCollection);
}
else
{
this.OnEndLoad(successful, errorCollection);
this._loading = false;
}
}
/// <summary>
/// ����ҳ���ʱ����ã������xml�ļ���ȡ��Ϣ
/// ���ú���ReadFile���������ļ��ڵ�ľ�����Ϣ��������ݶ�ȡ����Ϣ����������ļ��ء�
/// </summary>
/// <param name="document">��Ҫ���ص�xml�ļ�</param>
/// <returns></returns>
public bool MyPerformLoad(XmlDocument document)
{
ArrayList errors = new ArrayList();
bool successful = true; //��־���ع����Ƿ�ɹ�
string baseClassName = null;
this.hostLoader = this.LoaderHost; //��ȡ���س������������� BasicDesignerLoader �̳С���
if (hostLoader == null)
{
//CassMessageBox.Warning("����������쳣��");
return false;
}
//��Ŵ�����Ϣ,��������ڼ�������������뽫��Щ������Ϊ�쳣���ϴ��ݵ� errorCollection �����С�
baseClassName = ReadFile(document, errors);
if (baseClassName == null)
{
return false;
}
if (errors.Count > 0)
{
successful = false;
}
// ������������ز�����
//baseClassName �������������Ƶ��ĵ��Ļ������ȫ������
//successful ���������ѳɹ����أ���Ϊ true������Ϊ false��
//errorCollection ���������ڼ������Ĵ�������еĻ����ļ��ϡ�
hostLoader.EndLoad(baseClassName, successful, errors);
return successful;
}
