class/System.Design/System.ComponentModel.Design.Serialization/BasicDesignerLoader.cs

   1 //
   2 // System.ComponentModel.Design.Serialization.BasicDesignerLoader
   3 //
   4 // Authors:
   5 //        Ivan N. Zlatev (contact i-nZ.net)
   6 //
   7 // (C) 2007 Ivan N. Zlatev
   8
   9 //
  10 // Permission is hereby granted, free of charge, to any person obtaining
  11 // a copy of this software and associated documentation files (the
  12 // "Software"), to deal in the Software without restriction, including
  13 // without limitation the rights to use, copy, modify, merge, publish,
  14 // distribute, sublicense, and/or sell copies of the Software, and to
  15 // permit persons to whom the Software is furnished to do so, subject to
  16 // the following conditions:
  17 //
  18 // The above copyright notice and this permission notice shall be
  19 // included in all copies or substantial portions of the Software.
  20 //
  21 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  22 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  24 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  25 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  26 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  27 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28 //
  29
  30 #if NET_2_0
  31
  32 using System;
  33 using System.Collections;
  34 using System.ComponentModel;
  35 using System.ComponentModel.Design;
  36 using System.Windows.Forms;
  37
  38 namespace System.ComponentModel.Design.Serialization
  39 {
  40         public abstract class BasicDesignerLoader : DesignerLoader, IDesignerLoaderService
  41         {
  42
  43                 [Flags]
  44                 protected enum ReloadOptions
  45                 {
  46                         Default,
  47                         Force,
  48                         ModifyOnError,
  49                         NoFlush
  50                 }
  51
  52                 private bool _loaded;
  53                 private bool _loading;
  54                 private IDesignerLoaderHost _host;
  55                 private int _dependenciesCount;
  56                 private bool _notificationsEnabled;
  57                 private bool _modified;
  58                 private string _baseComponentClassName;
  59                 private DesignerSerializationManager _serializationMananger;
  60                 private bool _flushing;
  61                 private bool _reloadScheduled;
  62                 private ReloadOptions _reloadOptions;
  63
  64                 protected BasicDesignerLoader ()
  65                 {
  66                         _loading = _loaded = _flushing = _reloadScheduled = false;
  67                         _host = null;
  68                         _notificationsEnabled = false;
  69                         _modified = false;
  70                         _dependenciesCount = 0;
  71                 }
  72
  73                 protected virtual void Initialize ()
  74                 {
  75                         _serializationMananger = new DesignerSerializationManager (_host);
  76
  77                         DesignSurfaceServiceContainer serviceContainer = _host.GetService (typeof (IServiceContainer)) as DesignSurfaceServiceContainer;
  78                         if (serviceContainer != null) {
  79                                 serviceContainer.AddService (typeof (IDesignerLoaderService), (IDesignerLoaderService) this);
  80                                 serviceContainer.AddNonReplaceableService (typeof (IDesignerSerializationManager), _serializationMananger);
  81                         }
  82                 }
  83
  84                 public override void BeginLoad (IDesignerLoaderHost host)
  85                 {
  86                         if (host == null)
  87                                 throw new ArgumentNullException ("host");
  88                         if (_loaded)
  89                                 throw new InvalidOperationException ("Already loaded.");
  90                         if (_host != null && _host != host)
  91                                 throw new InvalidOperationException ("Trying to load with a different host");
  92
  93                         if (_host == null) { // beingload is called on reload - no need to initialize twice.
  94                                 _host = host;
  95                                 Initialize ();
  96                         }
  97                         IDisposable session = _serializationMananger.CreateSession ();
  98
  99                         IDesignerLoaderService loader = _host.GetService (typeof (IDesignerLoaderService)) as IDesignerLoaderService;
 100
 101                         if (loader != null) {
 102                                 _dependenciesCount = -1;
 103                                 loader.AddLoadDependency ();
 104                         } else {
 105                                 OnBeginLoad ();
 106                         }
 107
 108                         bool successful = true;
 109
 110                         try {
 111                                 PerformLoad (_serializationMananger);
 112                         } catch (Exception e) {
 113                                 successful = false;
 114                                 _serializationMananger.Errors.Add (e);
 115                         }
 116
 117                         if (loader != null)
 118                                 loader.DependentLoadComplete (successful, _serializationMananger.Errors);
 119                         else
 120                                 OnEndLoad (successful, _serializationMananger.Errors);
 121
 122                         session.Dispose ();
 123                 }
 124
 125                 protected abstract void PerformLoad (IDesignerSerializationManager serializationManager);
 126
 127                 protected virtual void OnBeginLoad ()
 128                 {
 129                         _loading = true;
 130                 }
 131
 132                 protected virtual void OnEndLoad (bool successful, ICollection errors)
 133                 {
 134                         _host.EndLoad (_baseComponentClassName, successful,  errors);
 135
 136                         if (successful) {
 137                                 _loaded = true;
 138                                 EnableComponentNotification (true);
 139                         } else {
 140                                 if (_reloadScheduled) { // we are reloading
 141                                         bool modify = ((_reloadOptions & ReloadOptions.ModifyOnError) == ReloadOptions.ModifyOnError);
 142                                         if (modify) {
 143                                                 OnModifying ();
 144                                                 this.Modified = true;
 145                                         }
 146                                 }
 147                         }
 148                         _loading = false;
 149                 }
 150
 151                 public override bool Loading {
 152                         get { return _loading; }
 153                 }
 154
 155                 protected IDesignerLoaderHost LoaderHost {
 156                         get { return _host; }
 157                 }
 158
 159                 protected virtual bool Modified {
 160                         get { return _modified; }
 161                         set { _modified = value; }
 162                 }
 163
 164                 protected object PropertyProvider {
 165                         get {
 166                                 if (!_loaded)
 167                                         throw new InvalidOperationException ("host not initialized");
 168                                 return _serializationMananger.PropertyProvider;
 169                         }
 170                         set {
 171                                 if (!_loaded)
 172                                         throw new InvalidOperationException ("host not initialized");
 173                                 _serializationMananger.PropertyProvider = value;
 174                         }
 175                 }
 176
 177                 protected bool ReloadPending {
 178                         get { return _reloadScheduled; }
 179                 }
 180
 181                 protected virtual bool EnableComponentNotification (bool enable)
 182                 {
 183                         if (!_loaded)
 184                                 throw new InvalidOperationException ("host not initialized");
 185
 186                         IComponentChangeService service = _host.GetService (typeof (IComponentChangeService)) as IComponentChangeService;
 187                         if (service != null && _notificationsEnabled != enable) {
 188                                 if (enable) {
 189                                         service.ComponentAdding += new ComponentEventHandler (OnComponentAdding);
 190                                         service.ComponentAdded += new ComponentEventHandler (OnComponentAdded);
 191                                         service.ComponentRemoving += new ComponentEventHandler (OnComponentRemoving);
 192                                         service.ComponentRemoved += new ComponentEventHandler (OnComponentRemoved);
 193                                         service.ComponentChanging += new ComponentChangingEventHandler (OnComponentChanging);
 194                                         service.ComponentChanged += new ComponentChangedEventHandler (OnComponentChanged);
 195                                         service.ComponentRename += new ComponentRenameEventHandler (OnComponentRename);
 196                                 } else {
 197                                         service.ComponentAdding -= new ComponentEventHandler (OnComponentAdding);
 198                                         service.ComponentAdded -= new ComponentEventHandler (OnComponentAdded);
 199                                         service.ComponentRemoving -= new ComponentEventHandler (OnComponentRemoving);
 200                                         service.ComponentRemoved -= new ComponentEventHandler (OnComponentRemoved);
 201                                         service.ComponentChanging -= new ComponentChangingEventHandler (OnComponentChanging);
 202                                         service.ComponentChanged -= new ComponentChangedEventHandler (OnComponentChanged);
 203                                         service.ComponentRename -= new ComponentRenameEventHandler (OnComponentRename);
 204                                 }
 205                         }
 206                         return _notificationsEnabled == true ? true : false;
 207                 }
 208
 209                 private void OnComponentAdded (object sender, ComponentEventArgs args)
 210                 {
 211                         if (!_loading && _loaded)
 212                                 this.Modified = true;
 213                 }
 214
 215                 private void OnComponentRemoved (object sender, ComponentEventArgs args)
 216                 {
 217                         if (!_loading && _loaded)
 218                                 this.Modified = true;
 219                 }
 220
 221                 private void OnComponentAdding (object sender, ComponentEventArgs args)
 222                 {
 223                         if (!_loading && _loaded)
 224                                 OnModifying ();
 225                 }
 226
 227                 private void OnComponentRemoving (object sender, ComponentEventArgs args)
 228                 {
 229                         if (!_loading && _loaded)
 230                                 OnModifying ();
 231                 }
 232
 233                 private void OnComponentChanged (object sender, ComponentChangedEventArgs args)
 234                 {
 235                         if (!_loading && _loaded)
 236                                 this.Modified = true;
 237                 }
 238
 239                 private void OnComponentChanging (object sender, ComponentChangingEventArgs args)
 240                 {
 241                         if (!_loading && _loaded)
 242                                 OnModifying ();
 243                 }
 244
 245                 private void OnComponentRename (object sender, ComponentRenameEventArgs args)
 246                 {
 247                         if (!_loading && _loaded) {
 248                                         OnModifying ();
 249                                         this.Modified = true;
 250                         }
 251                 }
 252
 253                 public override void Flush ()
 254                 {
 255                         if (!_loaded)
 256                                 throw new InvalidOperationException ("host not initialized");
 257
 258                         if (!_flushing && this.Modified) {
 259                                 _flushing = true;
 260                                 using ((IDisposable)_serializationMananger.CreateSession ()) {
 261                                         try {
 262                                                 PerformFlush (_serializationMananger);
 263                                         } catch (Exception e) {
 264                                                 _serializationMananger.Errors.Add (e);
 265                                                 ReportFlushErrors (_serializationMananger.Errors);
 266                                         }
 267                                 }
 268                                 _flushing = false;
 269                         }
 270                 }
 271
 272                 protected abstract void PerformFlush (IDesignerSerializationManager serializationManager);
 273
 274                 // MSDN: The default implementation always returns true.
 275                 protected virtual bool IsReloadNeeded ()
 276                 {
 277                         return true;
 278                 }
 279
 280
 281                 protected virtual void OnBeginUnload ()
 282                 {
 283                 }
 284
 285                 protected virtual void OnModifying ()
 286                 {
 287                 }
 288
 289                 // MSDN: reloads are performed at idle time
 290                 protected void Reload (ReloadOptions flags)
 291                 {
 292                         if (!_reloadScheduled) {
 293                                 _reloadScheduled = true;
 294                                 _reloadOptions = flags;
 295                                 bool force = ((flags & ReloadOptions.Force) == ReloadOptions.Force);
 296                                 if (force)
 297                                         ReloadCore ();
 298                                 else
 299                                         Application.Idle += new EventHandler (OnIdle);
 300                         }
 301                 }
 302
 303                 private void OnIdle (object sender,  EventArgs args)
 304                 {
 305                         Application.Idle -= new EventHandler (OnIdle);
 306                         ReloadCore ();
 307                 }
 308
 309                 private void ReloadCore ()
 310                 {
 311                         bool flush = !((_reloadOptions & ReloadOptions.NoFlush) == ReloadOptions.NoFlush);
 312
 313                         if (flush)
 314                                 Flush ();
 315                         Unload ();
 316                         _host.Reload ();
 317                         BeginLoad (_host); // calls EndLoad, which will check for ReloadOptions.ModifyOnError
 318                         _reloadScheduled = false;
 319                 }
 320
 321                 private void Unload ()
 322                 {
 323                         if (_loaded) {
 324                                 OnBeginUnload ();
 325                                 EnableComponentNotification (false);
 326                                 _loaded = false;
 327                                 _baseComponentClassName = null;
 328                         }
 329                 }
 330
 331
 332                 // The default implementation of ReportFlushErrors raises the last exception in the collection.
 333                 //
 334                 protected virtual void ReportFlushErrors (ICollection errors)
 335                 {
 336                         object last = null;
 337                         foreach (object o in errors)
 338                                 last = o;
 339                         throw (Exception)last;
 340                 }
 341
 342                 // Must be called during PerformLoad by subclasses.
 343                 protected void SetBaseComponentClassName (string name)
 344                 {
 345                         if (name == null)
 346                                 throw new ArgumentNullException ("name");
 347                         _baseComponentClassName = name;
 348                 }
 349
 350 #region IDesignerLoaderService implementation
 351
 352                 void IDesignerLoaderService.AddLoadDependency ()
 353                 {
 354                         _dependenciesCount++;
 355                         if (_dependenciesCount == 0) {
 356                                 _dependenciesCount = 1;
 357                                 OnBeginLoad ();
 358                         }
 359                 }
 360
 361                 void IDesignerLoaderService.DependentLoadComplete (bool successful, ICollection errorCollection)
 362                 {
 363                         if (_dependenciesCount == 0)
 364                                 throw new InvalidOperationException ("dependencies == 0");
 365
 366                         _dependenciesCount--;
 367                         if (_dependenciesCount == 0) {
 368                                 OnEndLoad (successful,  errorCollection);
 369                         }
 370                 }
 371
 372                 bool IDesignerLoaderService.Reload ()
 373                 {
 374                         if (_dependenciesCount == 0) {
 375                                 this.Reload (ReloadOptions.Force);
 376                                 return true;
 377                         }
 378                         return false;
 379                 }
 380 #endregion
 381
 382                 protected object GetService (Type serviceType)
 383                 {
 384                         if (_host != null)
 385                                 return _host.GetService (serviceType);
 386                         return null;
 387                 }
 388
 389                 public override void Dispose ()
 390                 {
 391                         this.LoaderHost.RemoveService (typeof (IDesignerLoaderService));
 392                         Unload ();
 393                 }
 394         }
 395 }
 396
 397 #endif