extras/MonoDevelop.Database/MonoDevelop.Database.Designer/Widgets/TriggersEditorWidget.cs

   1 //
   2 // Authors:
   3 //   Ben Motmans  <ben.motmans@gmail.com>
   4 //
   5 // Copyright (c) 2007 Ben Motmans
   6 //
   7 // Permission is hereby granted, free of charge, to any person obtaining
   8 // a copy of this software and associated documentation files (the
   9 // "Software"), to deal in the Software without restriction, including
  10 // without limitation the rights to use, copy, modify, merge, publish,
  11 // distribute, sublicense, and/or sell copies of the Software, and to
  12 // permit persons to whom the Software is furnished to do so, subject to
  13 // the following conditions:
  14 //
  15 // The above copyright notice and this permission notice shall be
  16 // included in all copies or substantial portions of the Software.
  17 //
  18 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  19 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  21 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  22 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  23 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  24 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25 //
  26
  27 using Gtk;
  28 using System;
  29 using System.Threading;
  30 using System.Collections.Generic;
  31 using MonoDevelop.Core;
  32 using MonoDevelop.Core.Gui;
  33 using MonoDevelop.Database.Sql;
  34 using MonoDevelop.Database.Components;
  35
  36 namespace MonoDevelop.Database.Designer
  37 {
  38         [System.ComponentModel.Category("widget")]
  39         [System.ComponentModel.ToolboxItem(true)]
  40         public partial class TriggersEditorWidget : Gtk.Bin
  41         {
  42                 public event EventHandler ContentChanged;
  43
  44                 private ISchemaProvider schemaProvider;
  45                 private TableSchema table;
  46                 private TriggerSchemaCollection triggers;
  47
  48                 private SchemaActions action;
  49
  50                 private ListStore store;
  51                 private ListStore storeTypes;
  52                 private ListStore storeEvents;
  53
  54                 private const int colNameIndex = 0;
  55                 private const int colTypeIndex = 1;
  56                 private const int colEventIndex = 2;
  57                 private const int colFireTypeIndex = 3;
  58                 private const int colPositionIndex = 4;
  59                 private const int colActiveIndex = 5;
  60                 private const int colCommentIndex = 6;
  61                 private const int colSourceIndex = 7;
  62                 private const int colObjIndex = 8;
  63
  64                 public TriggersEditorWidget (ISchemaProvider schemaProvider, SchemaActions action)
  65                 {
  66                         if (schemaProvider == null)
  67                                 throw new ArgumentNullException ("schemaProvider");
  68
  69                         this.schemaProvider = schemaProvider;
  70                         this.action = action;
  71
  72                         this.Build();
  73
  74                         sqlEditor.Editable = false;
  75                         sqlEditor.TextChanged += new EventHandler (SourceChanged);
  76
  77                         store = new ListStore (typeof (string), typeof (string), typeof (string), typeof (bool), typeof (string), typeof (bool), typeof (string), typeof (string), typeof (object));
  78                         storeTypes = new ListStore (typeof (string));
  79                         storeEvents = new ListStore (typeof (string));
  80                         listTriggers.Model = store;
  81                         listTriggers.Selection.Changed += new EventHandler (OnSelectionChanged);
  82
  83                         foreach (string name in Enum.GetNames (typeof (TriggerType)))
  84                                  storeTypes.AppendValues (name);
  85                         foreach (string name in Enum.GetNames (typeof (TriggerEvent)))
  86                                  storeEvents.AppendValues (name);
  87
  88                         TreeViewColumn colName = new TreeViewColumn ();
  89                         TreeViewColumn colType = new TreeViewColumn ();
  90                         TreeViewColumn colEvent = new TreeViewColumn ();
  91                         TreeViewColumn colFireType = new TreeViewColumn ();
  92                         TreeViewColumn colPosition = new TreeViewColumn ();
  93                         TreeViewColumn colActive = new TreeViewColumn ();
  94                         TreeViewColumn colComment = new TreeViewColumn ();
  95
  96                         colName.Title = AddinCatalog.GetString ("Name");
  97                         colType.Title = AddinCatalog.GetString ("Type");
  98                         colEvent.Title = AddinCatalog.GetString ("Event");
  99                         colFireType.Title = AddinCatalog.GetString ("Each Row");
 100                         colPosition.Title = AddinCatalog.GetString ("Position");
 101                         colActive.Title = AddinCatalog.GetString ("Active");
 102                         colComment.Title = AddinCatalog.GetString ("Comment");
 103
 104                         colType.MinWidth = 120;
 105                         colEvent.MinWidth = 120;
 106
 107                         CellRendererText nameRenderer = new CellRendererText ();
 108                         CellRendererCombo typeRenderer = new CellRendererCombo ();
 109                         CellRendererCombo eventRenderer = new CellRendererCombo ();
 110                         CellRendererToggle fireTypeRenderer = new CellRendererToggle ();
 111                         CellRendererText positionRenderer = new CellRendererText ();
 112                         CellRendererToggle activeRenderer = new CellRendererToggle ();
 113                         CellRendererText commentRenderer = new CellRendererText ();
 114
 115                         nameRenderer.Editable = true;
 116                         nameRenderer.Edited += new EditedHandler (NameEdited);
 117
 118                         typeRenderer.Model = storeTypes;
 119                         typeRenderer.TextColumn = 0;
 120                         typeRenderer.Editable = true;
 121                         typeRenderer.Edited += new EditedHandler (TypeEdited);
 122
 123                         eventRenderer.Model = storeEvents;
 124                         eventRenderer.TextColumn = 0;
 125                         eventRenderer.Editable = true;
 126                         eventRenderer.Edited += new EditedHandler (EventEdited);
 127
 128                         fireTypeRenderer.Activatable = true;
 129                         fireTypeRenderer.Toggled += new ToggledHandler (FireTypeToggled);
 130
 131                         positionRenderer.Editable = true;
 132                         positionRenderer.Edited += new EditedHandler (PositionEdited);
 133
 134                         activeRenderer.Activatable = true;
 135                         activeRenderer.Toggled += new ToggledHandler (ActiveToggled);
 136
 137                         commentRenderer.Editable = true;
 138                         commentRenderer.Edited += new EditedHandler (CommentEdited);
 139
 140                         colName.PackStart (nameRenderer, true);
 141                         colType.PackStart (typeRenderer, true);
 142                         colEvent.PackStart (eventRenderer, true);
 143                         colFireType.PackStart (fireTypeRenderer, true);
 144                         colPosition.PackStart (positionRenderer, true);
 145                         colActive.PackStart (activeRenderer, true);
 146                         colComment.PackStart (commentRenderer, true);
 147
 148                         colName.AddAttribute (nameRenderer, "text", colNameIndex);
 149                         colType.AddAttribute (typeRenderer, "text", colTypeIndex);
 150                         colEvent.AddAttribute (eventRenderer, "text", colEventIndex);
 151                         colFireType.AddAttribute (fireTypeRenderer, "active", colFireTypeIndex);
 152                         colPosition.AddAttribute (positionRenderer, "text", colPositionIndex);
 153                         colActive.AddAttribute (activeRenderer, "active", colActiveIndex);
 154                         colComment.AddAttribute (commentRenderer, "text", colCommentIndex);
 155
 156                         listTriggers.AppendColumn (colName);
 157                         listTriggers.AppendColumn (colType);
 158                         listTriggers.AppendColumn (colEvent);
 159                         listTriggers.AppendColumn (colFireType);
 160                         listTriggers.AppendColumn (colPosition);
 161                         listTriggers.AppendColumn (colActive);
 162                         listTriggers.AppendColumn (colComment);
 163
 164                         ShowAll ();
 165                 }
 166
 167                 public void Initialize (TableSchema table, TriggerSchemaCollection triggers)
 168                 {
 169                         if (table == null)
 170                                 throw new ArgumentNullException ("table");
 171                         if (triggers == null)
 172                                 throw new ArgumentNullException ("triggers");
 173
 174                         this.table = table;
 175                         this.triggers = triggers;
 176
 177                         foreach (TriggerSchema trigger in triggers)
 178                                 AddTrigger (trigger);
 179                 }
 180
 181                 protected virtual void RemoveClicked (object sender, System.EventArgs e)
 182                 {
 183                         TreeIter iter;
 184                         if (listTriggers.Selection.GetSelected (out iter)) {
 185                                 TriggerSchema trigger = store.GetValue (iter, colObjIndex) as TriggerSchema;
 186
 187                                 if (MessageService.Confirm (
 188                                         AddinCatalog.GetString ("Are you sure you want to remove trigger '{0}'?", trigger.Name),
 189                                         AlertButton.Remove
 190                                 )) {
 191                                         store.Remove (ref iter);
 192                                         triggers.Remove (trigger);
 193                                         EmitContentChanged ();
 194                                 }
 195                         }
 196                 }
 197
 198                 protected virtual void AddClicked (object sender, EventArgs e)
 199                 {
 200                         TriggerSchema trigger = schemaProvider.CreateTriggerSchema ("trigger_" + table.Name);
 201                         trigger.TableName = table.Name;
 202                         int index = 1;
 203                         while (triggers.Contains (trigger.Name))
 204                                 trigger.Name = "trigger_" + table.Name + (index++);
 205                         triggers.Add (trigger);
 206                         AddTrigger (trigger);
 207                         EmitContentChanged ();
 208                 }
 209
 210                 private void AddTrigger (TriggerSchema trigger)
 211                 {
 212                         store.AppendValues (trigger.Name, trigger.TriggerType.ToString (),
 213                                 trigger.TriggerEvent.ToString (), trigger.TriggerFireType == TriggerFireType.ForEachRow,
 214                                 trigger.Position.ToString (), trigger.IsActive, trigger.Comment,
 215                                 trigger.Source , trigger);
 216                 }
 217
 218                 private void NameEdited (object sender, EditedArgs args)
 219                 {
 220                         TreeIter iter;
 221                         if (store.GetIterFromString (out iter, args.Path)) {
 222                                 if (!string.IsNullOrEmpty (args.NewText)) {
 223                                         store.SetValue (iter, colNameIndex, args.NewText);
 224                                 } else {
 225                                         string oldText = store.GetValue (iter, colNameIndex) as string;
 226                                         (sender as CellRendererText).Text = oldText;
 227                                 }
 228                         }
 229                 }
 230
 231                 protected virtual void OnSelectionChanged (object sender, EventArgs e)
 232                 {
 233                         TreeIter iter;
 234                         if (listTriggers.Selection.GetSelected (out iter)) {
 235                                 buttonRemove.Sensitive = true;
 236                                 sqlEditor.Editable = true;
 237
 238                                 TriggerSchema trigger = store.GetValue (iter, colObjIndex) as TriggerSchema;
 239
 240                                 sqlEditor.Text = trigger.Source;
 241
 242                         } else {
 243                                 buttonRemove.Sensitive = false;
 244                                 sqlEditor.Editable = false;
 245                                 sqlEditor.Text = String.Empty;
 246                         }
 247                 }
 248
 249                 private void SourceChanged (object sender, EventArgs args)
 250                 {
 251                         TreeIter iter;
 252                         if (listTriggers.Selection.GetSelected (out iter)) {
 253                                 store.SetValue (iter, colSourceIndex, sqlEditor.Text);
 254                                 EmitContentChanged ();
 255                         }
 256                 }
 257
 258                 private void TypeEdited (object sender, EditedArgs args)
 259                 {
 260                         TreeIter iter;
 261                         if (store.GetIterFromString (out iter, args.Path)) {
 262                                 foreach (string name in Enum.GetNames (typeof (TriggerType))) {
 263                                         if (args.NewText == name) {
 264                                                 store.SetValue (iter, colTypeIndex, args.NewText);
 265                                                 EmitContentChanged ();
 266                                                 return;
 267                                         }
 268                                 }
 269                                 string oldText = store.GetValue (iter, colTypeIndex) as string;
 270                                 (sender as CellRendererText).Text = oldText;
 271                         }
 272                 }
 273
 274                 private void EventEdited (object sender, EditedArgs args)
 275                 {
 276                         TreeIter iter;
 277                         if (store.GetIterFromString (out iter, args.Path)) {
 278                                 foreach (string name in Enum.GetNames (typeof (TriggerEvent))) {
 279                                         if (args.NewText == name) {
 280                                                 store.SetValue (iter, colEventIndex, args.NewText);
 281                                                 EmitContentChanged ();
 282                                                 return;
 283                                         }
 284                                 }
 285                                 string oldText = store.GetValue (iter, colEventIndex) as string;
 286                                 (sender as CellRendererText).Text = oldText;
 287                         }
 288                 }
 289
 290                 private void PositionEdited (object sender, EditedArgs args)
 291                 {
 292                         TreeIter iter;
 293                         if (store.GetIterFromString (out iter, args.Path)) {
 294                                 int len;
 295                                 if (!string.IsNullOrEmpty (args.NewText) && int.TryParse (args.NewText, out len)) {
 296                                         store.SetValue (iter, colPositionIndex, args.NewText);
 297                                         EmitContentChanged ();
 298                                 } else {
 299                                         string oldText = store.GetValue (iter, colPositionIndex) as string;
 300                                         (sender as CellRendererText).Text = oldText;
 301                                 }
 302                         }
 303                 }
 304
 305                 private void FireTypeToggled (object sender, ToggledArgs args)
 306                 {
 307                         TreeIter iter;
 308                         if (store.GetIterFromString (out iter, args.Path)) {
 309                                 bool val = (bool) store.GetValue (iter, colFireTypeIndex);
 310                                 store.SetValue (iter, colFireTypeIndex, !val);
 311                                 EmitContentChanged ();
 312                         }
 313                 }
 314
 315                 private void ActiveToggled (object sender, ToggledArgs args)
 316                 {
 317                         TreeIter iter;
 318                         if (store.GetIterFromString (out iter, args.Path)) {
 319                                 bool val = (bool) store.GetValue (iter, colActiveIndex);
 320                                 store.SetValue (iter, colActiveIndex, !val);
 321                                 EmitContentChanged ();
 322                         }
 323                 }
 324
 325                 private void CommentEdited (object sender, EditedArgs args)
 326                 {
 327                         TreeIter iter;
 328                         if (store.GetIterFromString (out iter, args.Path)) {
 329                                 store.SetValue (iter, colCommentIndex, args.NewText);
 330                                 EmitContentChanged ();
 331                         }
 332                 }
 333
 334                 public virtual bool ValidateSchemaObjects (out string msg)
 335                 {
 336                         TreeIter iter;
 337                         if (store.GetIterFirst (out iter)) {
 338                                 do {
 339                                         string name = store.GetValue (iter, colNameIndex) as string;
 340                                         string source = store.GetValue (iter, colSourceIndex) as string;
 341                                         //type, event, firetype, position and fireType are always valid
 342
 343                                         if (String.IsNullOrEmpty (source)) {
 344                                                 msg = AddinCatalog.GetString ("Trigger '{0}' does not contain a trigger statement.", name);
 345                                                 return false;
 346                                         }
 347                                 } while (store.IterNext (ref iter));
 348                         }
 349                         msg = null;
 350                         return true;
 351                 }
 352
 353                 public virtual void FillSchemaObjects ()
 354                 {
 355                         TreeIter iter;
 356                         if (store.GetIterFirst (out iter)) {
 357                                 do {
 358                                         TriggerSchema trigger = store.GetValue (iter, colObjIndex) as TriggerSchema;
 359
 360                                         trigger.Name = store.GetValue (iter, colNameIndex) as string;
 361
 362                                         trigger.TriggerType = (TriggerType)Enum.Parse (typeof (TriggerType), store.GetValue (iter, colTypeIndex) as string);
 363                                         trigger.TriggerEvent = (TriggerEvent)Enum.Parse (typeof (TriggerEvent), store.GetValue (iter, colEventIndex) as string);
 364                                         trigger.TriggerFireType = (TriggerFireType)Enum.Parse (typeof (TriggerFireType), store.GetValue (iter, colFireTypeIndex) as string);
 365
 366                                         trigger.Position = int.Parse (store.GetValue (iter, colPositionIndex) as string);
 367                                         trigger.IsActive = (bool)store.GetValue (iter, colActiveIndex);
 368
 369                                         trigger.Comment = store.GetValue (iter, colCommentIndex) as string;
 370                                         trigger.Source = store.GetValue (iter, colSourceIndex) as string;
 371
 372                                         table.Triggers.Add (trigger);
 373                                 } while (store.IterNext (ref iter));
 374                         }
 375                 }
 376
 377                 protected virtual void EmitContentChanged ()
 378                 {
 379                         if (ContentChanged != null)
 380                                 ContentChanged (this, EventArgs.Empty);
 381                 }
 382         }
 383 }