Changeset 2756


Ignore:
Timestamp:
Feb 20, 2011, 6:54:17 PM (11 years ago)
Author:
kopal
Message:

working on 'operations' which modify the Model:

  • added some 'new','delete','move' - and so on - operations
Location:
trunk/WorkspaceManagerModel
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • trunk/WorkspaceManagerModel/Execution/ExecutionEngine.cs

    r2747 r2756  
    247247        {
    248248            //Get the gui Thread
    249             this.workspaceModel.Editor.Presentation.Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
     249            /*this.workspaceModel.Editor.Presentation.Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
    250250            {
    251251                List<PluginModel> pluginModels = workspaceModel.AllPluginModels;
     
    275275            }
    276276            , null);
    277 
     277            */
    278278        }
    279279    }
  • trunk/WorkspaceManagerModel/Model/Elements/PluginModel.cs

    r2750 r2756  
    202202                        connectorModel.PluginModel.Plugin.PropertyChanged += connectorModel.PropertyChangedOnPlugin;
    203203                        InputConnectors.Add(connectorModel);
    204                         WorkspaceModel.AllConnectorModels.Add(connectorModel);
    205                         if(!this.WorkspaceModel.UndoRedoManager.Working)
    206                         {
    207                             this.WorkspaceModel.UndoRedoManager.DidOperation(new NewModelElementOperation(connectorModel));
    208                         }
     204                        WorkspaceModel.AllConnectorModels.Add(connectorModel);                       
    209205                    }
    210206                    else if (propertyInfoAttribute.Direction.Equals(Direction.ControlSlave))
     
    221217                        connectorModel.PluginModel.Plugin.PropertyChanged += connectorModel.PropertyChangedOnPlugin;
    222218                        InputConnectors.Add(connectorModel);
    223                         WorkspaceModel.AllConnectorModels.Add(connectorModel);
    224                         if(!this.WorkspaceModel.UndoRedoManager.Working)
    225                         {
    226                             this.WorkspaceModel.UndoRedoManager.DidOperation(new NewModelElementOperation(connectorModel));
    227                         }
     219                        WorkspaceModel.AllConnectorModels.Add(connectorModel);                       
    228220                    }
    229221                    else if (propertyInfoAttribute.Direction.Equals(Direction.OutputData))
     
    241233                        connectorModel.PluginModel.Plugin.PropertyChanged += connectorModel.PropertyChangedOnPlugin;
    242234                        OutputConnectors.Add(connectorModel);
    243                         WorkspaceModel.AllConnectorModels.Add(connectorModel);
    244                         if(!this.WorkspaceModel.UndoRedoManager.Working)
    245                         {
    246                             this.WorkspaceModel.UndoRedoManager.DidOperation(new NewModelElementOperation(connectorModel));
    247                         }
     235                        WorkspaceModel.AllConnectorModels.Add(connectorModel);                     
    248236                    }
    249237                    else if (propertyInfoAttribute.Direction.Equals(Direction.ControlMaster))
     
    261249                        connectorModel.PluginModel.Plugin.PropertyChanged += connectorModel.PropertyChangedOnPlugin;
    262250                        OutputConnectors.Add(connectorModel);
    263                         WorkspaceModel.AllConnectorModels.Add(connectorModel);
    264                         if(!this.WorkspaceModel.UndoRedoManager.Working)
    265                         {
    266                             this.WorkspaceModel.UndoRedoManager.DidOperation(new NewModelElementOperation(connectorModel));
    267                         }
     251                        WorkspaceModel.AllConnectorModels.Add(connectorModel);                       
    268252                    }
    269253                }
     
    293277                            eventinfo.AddEventHandler(Plugin, new DynamicPropertiesChanged(connectorModel.PropertyTypeChangedOnPlugin));                           
    294278                            InputConnectors.Add(connectorModel);
    295                             WorkspaceModel.AllConnectorModels.Add(connectorModel);
    296                             if(!this.WorkspaceModel.UndoRedoManager.Working)
    297                             {
    298                                 this.WorkspaceModel.UndoRedoManager.DidOperation(new NewModelElementOperation(connectorModel));
    299                             }
     279                            WorkspaceModel.AllConnectorModels.Add(connectorModel);                           
    300280                        }
    301281                        else if (dynamicProperty.PInfo.Direction.Equals(Direction.OutputData))
     
    309289                            connectorModel.Name = dynamicProperty.Name;
    310290                            connectorModel.ToolTip = dynamicProperty.PInfo.ToolTip;
    311                              EventInfo eventinfo = Plugin.GetType().GetEvent(dynamicPropertyInfoAttribute.UpdateDynamicPropertiesEvent);
     291                            EventInfo eventinfo = Plugin.GetType().GetEvent(dynamicPropertyInfoAttribute.UpdateDynamicPropertiesEvent);
    312292                            eventinfo.AddEventHandler(Plugin, new DynamicPropertiesChanged(connectorModel.PropertyTypeChangedOnPlugin));
    313293                            connectorModel.IsDynamic = true;
     
    317297                            connectorModel.Outgoing = true;
    318298                            OutputConnectors.Add(connectorModel);
    319                             WorkspaceModel.AllConnectorModels.Add(connectorModel);
    320                             if(!this.WorkspaceModel.UndoRedoManager.Working)
    321                             {
    322                                 this.WorkspaceModel.UndoRedoManager.DidOperation(new NewModelElementOperation(connectorModel));
    323                             }
     299                            WorkspaceModel.AllConnectorModels.Add(connectorModel);                           
    324300                        }
    325301                    }
     
    383359                this.imageIndex = args.ImageIndex;
    384360            }
    385                
    386             /*if (this.WorkspaceModel.Editor.isExecuting())
    387             {
    388                 this.GuiNeedsUpdate = true;
    389             }
    390             else
    391             {*/
    392                 this.WorkspaceModel.Editor.Presentation.Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
    393                 {
    394                     this.UpdateableViewElement.update();
    395                 }, null);
    396             //}           
    397361        }
    398362
  • trunk/WorkspaceManagerModel/Model/Elements/WorkspaceModel.cs

    r2750 r2756  
    3838    {
    3939
    40         internal WorkspaceModel()
     40        public WorkspaceModel()
    4141        {
    4242            this.AllPluginModels = new List<PluginModel>();
     
    4545            this.AllImageModels = new List<ImageModel>();
    4646            this.AllTextModels = new List<TextModel>();
    47         }
    48 
    49         [NonSerialized]
    50         private IEditor workspaceManagerEditor;
    51 
    52         /// <summary>
    53         /// The surrounding WorkspaceManagerEditor
    54         /// </summary>
    55         public IEditor Editor
    56         {
    57             get
    58             {
    59                 return workspaceManagerEditor;
    60             }
    61             set
    62             {
    63                 workspaceManagerEditor = value;
    64             }
    65         }
     47            this.UndoRedoManager = new UndoRedoManager();
     48        }     
    6649
    6750        [NonSerialized]
     
    175158            }           
    176159            this.AllPluginModels.Add(pluginModel);
     160            this.HasChanges = true;           
     161            return pluginModel;
     162        }
     163
     164        /// <summary>
     165        /// Add an existing PluginModel to this WorkspaceModel
     166        /// </summary>
     167        /// <param name="pluginModel"></param>
     168        /// <returns></returns>
     169        internal void addPluginModel(PluginModel pluginModel)
     170        {           
     171            this.AllPluginModels.Add(pluginModel);
    177172            this.HasChanges = true;
    178             if (!this.UndoRedoManager.Working)
    179             {
    180                 this.UndoRedoManager.DidOperation(new NewModelElementOperation(pluginModel));
    181             }
    182             return pluginModel;
    183         }
    184 
    185         /// <summary>
    186         /// Creates a new PluginModel belonging to this WorkspaceModel
    187         /// Position and Dimension are (x,y,width,height) = (0,0,0,0)
    188         /// </summary>
    189         /// <param name="pluginType"></param>
    190         /// <returns></returns>
    191         internal PluginModel newPluginModel(Type pluginType)
    192         {
    193             return newPluginModel(new Point(0, 0), 0, 0, pluginType);
    194         }       
    195 
     173        }
     174       
    196175        /// <summary>
    197176        /// Creates a new Connection starting at "from"-Connector going to "to"-Connector with
     
    241220            this.AllConnectionModels.Add(connectionModel);
    242221            this.HasChanges = true;
    243             if (!this.UndoRedoManager.Working)
    244             {
    245                 this.UndoRedoManager.DidOperation(new NewModelElementOperation(connectionModel));
    246             }
    247222            return connectionModel;
     223        }
     224
     225        /// <summary>
     226        /// Add an existing ConnectionModel to this WorkspaceModel
     227        /// </summary>
     228        /// <param name="model"></param>
     229        /// <param name="from"></param>
     230        /// <param name="to"></param>
     231        internal void addConnectionModel(ConnectionModel model)
     232        {
     233            ConnectorModel from = model.From;
     234            ConnectorModel to = model.To;
     235            from.OutputConnections.Add(model);
     236            to.InputConnections.Add(model);
     237           
     238            //If we connect two IControls we have to set data directly:
     239            if (from.IControl && to.IControl)
     240            {
     241                object data = null;
     242                //Get IControl data from "to"
     243                if (to.IsDynamic)
     244                {
     245                    data = to.PluginModel.Plugin.GetType().GetMethod(to.DynamicGetterName).Invoke(to.PluginModel.Plugin, new object[] { to.PropertyName });
     246                }
     247                else
     248                {
     249                    data = to.PluginModel.Plugin.GetType().GetProperty(to.PropertyName).GetValue(to.PluginModel.Plugin, null);
     250                }
     251
     252                //Set IControl data
     253                if (from.IsDynamic)
     254                {
     255                    MethodInfo propertyInfo = from.PluginModel.Plugin.GetType().GetMethod(from.DynamicSetterName);
     256                    propertyInfo.Invoke(from.PluginModel.Plugin, new object[] { from.PropertyName, data });
     257                }
     258                else
     259                {
     260                    PropertyInfo propertyInfo = from.PluginModel.Plugin.GetType().GetProperty(from.PropertyName);
     261                    propertyInfo.SetValue(from.PluginModel.Plugin, data, null);
     262                }
     263            }
     264
     265            this.AllConnectionModels.Add(model);
     266            this.HasChanges = true;
    248267        }
    249268
     
    257276            ImageModel imageModel = new ImageModel(imgUri);
    258277            this.AllImageModels.Add(imageModel);
    259             this.HasChanges = true;
    260             if (!this.UndoRedoManager.Working)
    261             {
    262                 this.UndoRedoManager.DidOperation(new NewModelElementOperation(imageModel));
    263             }
     278            this.HasChanges = true;         
    264279            return imageModel;
    265280        }
     
    274289            TextModel textModel = new TextModel();
    275290            this.AllTextModels.Add(textModel);
    276             this.HasChanges = true;
    277             if (!this.UndoRedoManager.Working)
    278             {
    279                 this.UndoRedoManager.DidOperation(new NewModelElementOperation(textModel));
    280             }
     291            this.HasChanges = true;           
    281292            return textModel;
    282293        }
     
    288299        /// <returns></returns>
    289300        internal bool deleteImageModel(ImageModel imageModel)
    290         {
    291             if (!this.UndoRedoManager.Working)
    292             {
    293                 this.UndoRedoManager.DidOperation(new DeleteModelElementOperation(imageModel));
    294             }
     301        {           
    295302            return this.AllImageModels.Remove(imageModel);
    296303        }
     
    302309        /// <returns></returns>
    303310        internal bool deleteTextModel(TextModel textModel)
    304         {
    305             if (!this.UndoRedoManager.Working)
    306             {
    307                 this.UndoRedoManager.DidOperation(new DeleteModelElementOperation(textModel));
    308             }
     311        {           
    309312            return this.AllTextModels.Remove(textModel);
    310313        }
     
    333336                }
    334337                pluginModel.Plugin.Dispose();               
    335                 this.HasChanges = true;
    336                 if (!this.UndoRedoManager.Working)
    337                 {
    338                     this.UndoRedoManager.DidOperation(new DeleteModelElementOperation(pluginModel));
    339                 }
    340 
     338                this.HasChanges = true;               
    341339                return this.AllPluginModels.Remove(pluginModel);
    342340            }           
     
    366364                    deleteConnectionModel(outputConnection);
    367365                }
    368                 this.HasChanges = true;
    369                 if (!this.UndoRedoManager.Working)
    370                 {
    371                     this.UndoRedoManager.DidOperation(new DeleteModelElementOperation(connectorModel));
    372                 }
    373 
     366                this.HasChanges = true;               
    374367                return this.AllConnectorModels.Remove(connectorModel);
    375368            }
     
    390383            connectionModel.From.OutputConnections.Remove(connectionModel);           
    391384            this.HasChanges = true;
    392             if (!this.UndoRedoManager.Working)
    393             {
    394                 this.UndoRedoManager.DidOperation(new DeleteModelElementOperation(connectionModel));
    395             }
    396 
     385           
    397386            return this.AllConnectionModels.Remove(connectionModel);
    398387        }
     
    437426            this.HasChanges = true;
    438427            return true;
     428        }
     429
     430        /// <summary>
     431        /// Modify the current WorkspaceModel by using an operation
     432        /// </summary>
     433        /// <param name="operation"></param>
     434        public void ModifyModel(Operation operation){
     435            operation.Execute(this);
     436            this.UndoRedoManager.DidOperation(operation);           
    439437        }
    440438
  • trunk/WorkspaceManagerModel/Model/Operations/Operations.cs

    r2749 r2756  
    1 using System;
     1/*                             
     2   Copyright 2011 Nils Kopal
     3
     4   Licensed under the Apache License, Version 2.0 (the "License");
     5   you may not use this file except in compliance with the License.
     6   You may obtain a copy of the License at
     7
     8       http://www.apache.org/licenses/LICENSE-2.0
     9
     10   Unless required by applicable law or agreed to in writing, software
     11   distributed under the License is distributed on an "AS IS" BASIS,
     12   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13   See the License for the specific language governing permissions and
     14   limitations under the License.
     15*/
     16
     17using System;
    218using System.Collections.Generic;
    319using System.Linq;
     
    824namespace WorkspaceManagerModel.Model.Operations
    925{
    10     /// <summary>
    11     /// abstract basic class representing a single operation which modifies the model
     26
     27    /// <summary>
     28    /// Abstract basic class representing a single operation which modifies the model
    1229    /// </summary>
    1330    public abstract class Operation
     
    1734        }
    1835        public VisualElementModel Model { get; internal set; }
    19         public abstract void Execute();
    20         public abstract void Undo();       
    21     }
    22 
    23     public class NewModelElementOperation : Operation
    24     {
    25         public NewModelElementOperation(VisualElementModel model)
     36        internal abstract void Execute(WorkspaceModel workspaceModel);
     37        internal abstract void Undo(WorkspaceModel workspaceModel);       
     38    }
     39
     40    /// <summary>
     41    /// Creates a new PluginModel
     42    /// </summary>
     43    public class NewPluginModelOperation : Operation
     44    {
     45        private Point Position = new Point(0,0);
     46        private double Width = 0;
     47        private double Height = 0;
     48        private Type PluginType = null;
     49
     50        public NewPluginModelOperation(Point position, double width, double height, Type pluginType)
     51            : base(null)
     52        {
     53            this.Position = position;
     54            this.Width = width;
     55            this.Height = height;
     56            this.PluginType = pluginType;
     57        }
     58
     59        #region Operation Members
     60
     61        internal override void Execute(WorkspaceModel workspaceModel)
     62        {
     63            if (this.Model == null)
     64            {
     65                this.Model = workspaceModel.newPluginModel(this.Position,
     66                    this.Width,
     67                    this.Height,
     68                    this.PluginType);
     69            }
     70            else
     71            {
     72                workspaceModel.addPluginModel((PluginModel)Model);
     73            }
     74        }
     75
     76        internal override void Undo(WorkspaceModel workspaceModel)
     77        {
     78            workspaceModel.deletePluginModel((PluginModel)this.Model);
     79        }
     80
     81        #endregion
     82    }
     83
     84    /// <summary>
     85    /// Deletes an existing PluginModel
     86    /// </summary>
     87    public class DeletePluginModelOperation : Operation
     88    {
     89        private Point Position = new Point(0, 0);
     90        private double Width = 0;
     91        private double Height = 0;
     92        private Type PluginType = null;
     93
     94        public DeletePluginModelOperation(PluginModel model)
    2695            : base(model)
    2796        {
    28 
    29         }
    30 
    31         #region Operation Members
    32        
    33         public override void Execute()
    34         {
    35             if (Model is PluginModel)
    36             {
    37 
    38             }
    39             else if (Model is ConnectorModel)
    40             {
    41 
    42             }
    43             else if (Model is ConnectionModel)
    44             {
    45 
    46             }
    47             else if (Model is TextModel)
    48             {
    49             }
    50             else if (Model is ImageModel)
    51             {
    52 
     97            this.Position = model.GetPosition();
     98            this.Width = model.GetWidth();
     99            this.Height = model.GetHeight();
     100            this.PluginType = model.PluginType;
     101        }
     102
     103        #region Operation Members
     104
     105        internal override void Execute(WorkspaceModel workspaceModel)
     106        {
     107            workspaceModel.deletePluginModel((PluginModel)this.Model);
     108        }
     109
     110        internal override void Undo(WorkspaceModel workspaceModel)
     111        {
     112            workspaceModel.addPluginModel((PluginModel)Model);
     113        }
     114
     115        #endregion
     116    }
     117
     118    /// <summary>
     119    /// Creates a new ConnectionModel
     120    /// </summary>
     121    public class NewConnectionModelOperation : Operation
     122    {
     123        private ConnectorModel From = null;
     124        private ConnectorModel To = null;
     125        private Type ConnectionType = null;
     126
     127        public NewConnectionModelOperation(ConnectorModel from, ConnectorModel to, Type connectionType) :
     128            base(null)
     129        {
     130            this.From = from;
     131            this.To = to;
     132            this.ConnectionType = connectionType;
     133        }
     134
     135        #region Operation Members
     136
     137        internal override void Execute(WorkspaceModel workspaceModel)
     138        {
     139            if (this.Model == null)
     140            {
     141                this.Model = workspaceModel.newConnectionModel(From, To, ConnectionType);
    53142            }
    54143            else
    55144            {
    56                 throw new NotImplementedException("Can not execute NewModelElementOperation: " + Model.GetType().Name);
    57             }
    58         }
    59 
    60         public override void Undo()
    61         {
    62             if (Model is PluginModel)
    63             {
    64 
    65             }
    66             else if (Model is ConnectorModel)
    67             {
    68 
    69             }
    70             else if (Model is ConnectionModel)
    71             {
    72 
    73             }
    74             else if (Model is TextModel)
    75             {
    76 
    77             }
    78             else if (Model is ImageModel)
    79             {
    80 
    81             }
    82             else
    83             {
    84                 throw new NotImplementedException("Can not undo NewModelElementOperation: " + Model.GetType().Name);
    85             }
    86         }
    87         #endregion
    88     }
    89 
    90     public class DeleteModelElementOperation : Operation
    91     {
    92 
    93         public DeleteModelElementOperation(VisualElementModel model)
     145                workspaceModel.addConnectionModel((ConnectionModel)this.Model);
     146            }
     147        }
     148
     149        internal override void Undo(WorkspaceModel workspaceModel)
     150        {
     151            workspaceModel.deleteConnectionModel((ConnectionModel)this.Model);
     152        }
     153
     154        #endregion
     155    }
     156
     157    /// <summary>
     158    /// Deletes a ConnectionModel
     159    /// </summary>
     160    public class DeleteConnectionModelOperation : Operation
     161    {
     162        public DeleteConnectionModelOperation(ConnectionModel model) :
     163            base(model)
     164        {
     165        }
     166
     167        #region Operation Members
     168
     169        internal override void Execute(WorkspaceModel workspaceModel)
     170        {
     171            workspaceModel.deleteConnectionModel((ConnectionModel)Model);
     172        }
     173
     174        internal override void Undo(WorkspaceModel workspaceModel)
     175        {
     176            workspaceModel.addConnectionModel((ConnectionModel)this.Model);
     177        }
     178
     179        #endregion
     180    }
     181
     182    /// <summary>
     183    /// Moves the Position of an existing VisualElementModel
     184    /// </summary>
     185    public class MoveModelElementOperation : Operation
     186    {
     187        private Point OldPosition = new Point(0, 0);
     188        private Point NewPosition = new Point(0, 0);
     189
     190        public MoveModelElementOperation(VisualElementModel model, Point newPosition)
    94191            : base(model)
    95192        {
    96 
    97         }
    98 
    99         #region Operation Members
    100 
    101         public override void Execute()
    102         {
    103             if (Model is PluginModel)
    104             {
    105 
    106             }
    107             else if (Model is ConnectorModel)
    108             {
    109 
    110             }
    111             else if (Model is ConnectionModel)
    112             {
    113 
    114             }
    115             else if (Model is TextModel)
    116             {
    117 
    118             }
    119             else if (Model is ImageModel)
    120             {
    121 
    122             }
    123             else
    124             {
    125                 throw new NotImplementedException("Can not execute DeleteModelElementOperation: " + Model.GetType().Name);
    126             }
    127         }
    128 
    129         public override void Undo()
    130         {
    131             if (Model is PluginModel)
    132             {
    133 
    134             }
    135             else if (Model is ConnectorModel)
    136             {
    137 
    138             }
    139             else if (Model is ConnectionModel)
    140             {
    141 
    142             }
    143             else if (Model is TextModel)
    144             {
    145 
    146             }
    147             else if (Model is ImageModel)
    148             {
    149 
    150             }
    151             else
    152             {
    153                 throw new NotImplementedException("Can not undo DeleteModelElementOperation: " + Model.GetType().Name);
    154             }
    155         }
    156 
    157         #endregion
    158     }
    159 
    160     public class MoveModelElementOperation : Operation
    161     {
    162 
    163         public MoveModelElementOperation(VisualElementModel model)
     193            this.OldPosition = model.GetPosition();
     194            this.NewPosition = newPosition;
     195        }
     196
     197        #region Operation Members
     198
     199        internal override void Execute(WorkspaceModel workspaceModel)
     200        {
     201            Model.Position = NewPosition;
     202        }
     203
     204        internal override void Undo(WorkspaceModel workspaceModel)
     205        {
     206            Model.Position = OldPosition;
     207        }
     208
     209        #endregion
     210    }
     211
     212    /// <summary>
     213    /// Resizes an existing VisualElementModel
     214    /// </summary>
     215    public class ResizeModelElementOperation : Operation
     216    {
     217        private double OldWidth = 0;
     218        private double OldHeight = 0;
     219        private double NewWidth = 0;
     220        private double NewHeight = 0;
     221
     222        public ResizeModelElementOperation(VisualElementModel model, double newWidth, double newHeight)
    164223            : base(model)
    165224        {
    166 
    167         }
    168 
    169         #region Operation Members
    170 
    171         public override void Execute()
    172         {
    173             if (Model is PluginModel)
    174             {
    175 
    176             }
    177             else if (Model is ConnectorModel)
    178             {
    179 
    180             }
    181             else if (Model is ConnectionModel)
    182             {
    183 
    184             }
    185             else if (Model is TextModel)
    186             {
    187 
    188             }
    189             else if (Model is ImageModel)
    190             {
    191 
    192             }
    193             else
    194             {
    195                 throw new NotImplementedException("Can not execute MoveModelElementOperation: " + Model.GetType().Name);
    196             }
    197         }
    198 
    199         public override void Undo()
    200         {
    201             if (Model is PluginModel)
    202             {
    203 
    204             }
    205             else if (Model is ConnectorModel)
    206             {
    207 
    208             }
    209             else if (Model is ConnectionModel)
    210             {
    211 
    212             }
    213             else if (Model is TextModel)
    214             {
    215 
    216             }
    217             else if (Model is ImageModel)
    218             {
    219 
    220             }
    221             else
    222             {
    223                 throw new NotImplementedException("Can not undo MoveModelElementOperation: " + Model.GetType().Name);
    224             }
    225         }
    226 
    227         public Point OldPosition
    228         {
    229             get;
    230             set;
    231         }
    232 
    233         public Point NewPosition
    234         {
    235             get;
    236             set;
    237         }
    238 
    239         #endregion
    240     }
     225            this.OldWidth = model.GetWidth();
     226            this.OldHeight = model.GetHeight();
     227            this.NewWidth = newWidth;
     228            this.NewHeight = newHeight;
     229        }
     230
     231        #region Operation Members
     232
     233        internal override void Execute(WorkspaceModel workspaceModel)
     234        {
     235            Model.Width = NewWidth;
     236            Model.Height = NewHeight;
     237        }
     238
     239        internal override void Undo(WorkspaceModel workspaceModel)
     240        {
     241            Model.Width = OldWidth;
     242            Model.Height = OldHeight;
     243        }
     244
     245        #endregion
     246    }
     247
    241248}
  • trunk/WorkspaceManagerModel/Model/Tools/ModelPersistance.cs

    r2747 r2756  
    3939        /// <param name="filename"></param>
    4040        /// <returns></returns>
    41         public static WorkspaceModel loadModel(string filename, IEditor workspaceManagerEditor)
     41        public static WorkspaceModel loadModel(string filename)
    4242        {
    4343            PersistantModel persistantModel = (PersistantModel)XMLSerialization.XMLSerialization.Deserialize(filename,true);
    4444            WorkspaceModel workspacemodel = persistantModel.WorkspaceModel;
    45             workspacemodel.Editor = workspaceManagerEditor;           
    46 
     45           
    4746            //restore all settings of each plugin
    4847            foreach (PersistantPlugin persistantPlugin in persistantModel.PersistantPluginList)
  • trunk/WorkspaceManagerModel/Model/Tools/UndoRedoManager.cs

    r2750 r2756  
    6060        public void Undo()
    6161        {
    62             Working = true;
    63             if (UndoStack.Count > 0)
    64             {
    65                 object lastModelModel = null;
    66                 Operation op = UndoStack.Pop();
    67                 lastModelModel = op.Model;
    68                 op.Undo();
    69                 RedoStack.Push(op);
    70 
    71                 if (UndoStack.Count > 0 && //(!UndoStack.First().SingleOperation ||
    72                     (UndoStack.First() is MoveModelElementOperation &&
    73                     UndoStack.First().Model == lastModelModel))//)
    74                 {
    75                     do
    76                     {
    77                         lastModelModel = op.Model;
    78                         op = UndoStack.Pop();
    79                         op.Undo();
    80                         RedoStack.Push(op);
    81                     } while (UndoStack.Count > 0 && //(!UndoStack.First().SingleOperation || (UndoStack.First() is MoveModelModelOperation &&
    82                     UndoStack.First().Model == lastModelModel)/*))*/;
    83                 }
    84             }
    85             Working = false;
     62           
    8663        }
    8764
     
    9168        public void Redo()
    9269        {
    93             Working = true;
    94             if (RedoStack.Count > 0)
    95             {               
    96                 Operation op = null;
    97                 object lastModelModel = null;
    98                 do
    99                 {
    100                     op = RedoStack.Pop();                   
    101                     lastModelModel = op.Model;
    102                     op.Execute();
    103                     UndoStack.Push(op);
    104                 } while (RedoStack.Count > 0 && //(!RedoStack.First().SingleOperation || (RedoStack.First() is MoveModelModelOperation &&
    105                     RedoStack.First().Model == lastModelModel)/*))*/;
    106 
    107             }
    108             Working = false;
     70           
    10971        }
    11072
Note: See TracChangeset for help on using the changeset viewer.