mcs/class/System.Web/System.Web.UI.WebControls/FormView.cs

   1 //\r
   2 // System.Web.UI.WebControls.FormView.cs\r
   3 //\r
   4 // Authors:\r
   5 //      Lluis Sanchez Gual (lluis@novell.com)\r
   6 //\r
   7 // (C) 2005 Novell, Inc (http://www.novell.com)\r
   8 //\r
   9 // Permission is hereby granted, free of charge, to any person obtaining\r
  10 // a copy of this software and associated documentation files (the\r
  11 // "Software"), to deal in the Software without restriction, including\r
  12 // without limitation the rights to use, copy, modify, merge, publish,\r
  13 // distribute, sublicense, and/or sell copies of the Software, and to\r
  14 // permit persons to whom the Software is furnished to do so, subject to\r
  15 // the following conditions:\r
  16 // \r
  17 // The above copyright notice and this permission notice shall be\r
  18 // included in all copies or substantial portions of the Software.\r
  19 // \r
  20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
  21 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
  22 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\r
  23 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE\r
  24 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION\r
  25 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\r
  26 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
  27 //\r
  28 \r
  29 #if NET_2_0\r
  30 \r
  31 using System;\r
  32 using System.Collections;\r
  33 using System.Collections.Specialized;\r
  34 using System.ComponentModel;\r
  35 using System.Web.UI;\r
  36 using System.Security.Permissions;\r
  37 using System.Text;\r
  38 using System.IO;\r
  39 using System.Reflection;\r
  40 \r
  41 namespace System.Web.UI.WebControls\r
  42 {\r
  43         [SupportsEventValidation]\r
  44         [DesignerAttribute ("System.Web.UI.Design.WebControls.FormViewDesigner, " + Consts.AssemblySystem_Design, "System.ComponentModel.Design.IDesigner")]\r
  45         [ControlValuePropertyAttribute ("SelectedValue")]\r
  46         [DefaultEventAttribute ("PageIndexChanging")]\r
  47         [AspNetHostingPermissionAttribute (SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]\r
  48         [AspNetHostingPermissionAttribute (SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal)]\r
  49         public class FormView: CompositeDataBoundControl, IDataItemContainer, INamingContainer, IPostBackEventHandler, IPostBackContainer\r
  50         {\r
  51                 object dataItem;\r
  52                 \r
  53                 Table table;\r
  54                 FormViewRow headerRow;\r
  55                 FormViewRow footerRow;\r
  56                 FormViewRow bottomPagerRow;\r
  57                 FormViewRow topPagerRow;\r
  58                 FormViewRow itemRow;\r
  59                 \r
  60                 IOrderedDictionary currentEditRowKeys;\r
  61                 IOrderedDictionary currentEditNewValues;\r
  62                 IOrderedDictionary currentEditOldValues;\r
  63                 \r
  64                 ITemplate pagerTemplate;\r
  65                 ITemplate emptyDataTemplate;\r
  66                 ITemplate headerTemplate;\r
  67                 ITemplate footerTemplate;\r
  68                 ITemplate editItemTemplate;\r
  69                 ITemplate insertItemTemplate;\r
  70                 ITemplate itemTemplate;\r
  71                 \r
  72                 PropertyDescriptor[] cachedKeyProperties;\r
  73                 readonly string[] emptyKeys = new string[0];\r
  74                 \r
  75                 // View state\r
  76                 PagerSettings pagerSettings;\r
  77                 \r
  78                 TableItemStyle editRowStyle;\r
  79                 TableItemStyle insertRowStyle;\r
  80                 TableItemStyle emptyDataRowStyle;\r
  81                 TableItemStyle footerStyle;\r
  82                 TableItemStyle headerStyle;\r
  83                 TableItemStyle pagerStyle;\r
  84                 TableItemStyle rowStyle;\r
  85                 \r
  86                 IOrderedDictionary _keyTable;\r
  87                 DataKey key;\r
  88                 DataKey oldEditValues;\r
  89                 \r
  90                 private static readonly object PageIndexChangedEvent = new object();\r
  91                 private static readonly object PageIndexChangingEvent = new object();\r
  92                 private static readonly object ItemCommandEvent = new object();\r
  93                 private static readonly object ItemCreatedEvent = new object();\r
  94                 private static readonly object ItemDeletedEvent = new object();\r
  95                 private static readonly object ItemDeletingEvent = new object();\r
  96                 private static readonly object ItemInsertedEvent = new object();\r
  97                 private static readonly object ItemInsertingEvent = new object();\r
  98                 private static readonly object ModeChangingEvent = new object();\r
  99                 private static readonly object ModeChangedEvent = new object();\r
 100                 private static readonly object ItemUpdatedEvent = new object();\r
 101                 private static readonly object ItemUpdatingEvent = new object();\r
 102                 \r
 103                 // Control state\r
 104                 int pageIndex;\r
 105                 FormViewMode currentMode = FormViewMode.ReadOnly; \r
 106                 bool hasCurrentMode;\r
 107                 int pageCount;\r
 108                 \r
 109                 public event EventHandler PageIndexChanged {\r
 110                         add { Events.AddHandler (PageIndexChangedEvent, value); }\r
 111                         remove { Events.RemoveHandler (PageIndexChangedEvent, value); }\r
 112                 }\r
 113                 \r
 114                 public event FormViewPageEventHandler PageIndexChanging {\r
 115                         add { Events.AddHandler (PageIndexChangingEvent, value); }\r
 116                         remove { Events.RemoveHandler (PageIndexChangingEvent, value); }\r
 117                 }\r
 118                 \r
 119                 public event FormViewCommandEventHandler ItemCommand {\r
 120                         add { Events.AddHandler (ItemCommandEvent, value); }\r
 121                         remove { Events.RemoveHandler (ItemCommandEvent, value); }\r
 122                 }\r
 123                 \r
 124                 public event EventHandler ItemCreated {\r
 125                         add { Events.AddHandler (ItemCreatedEvent, value); }\r
 126                         remove { Events.RemoveHandler (ItemCreatedEvent, value); }\r
 127                 }\r
 128                 \r
 129                 public event FormViewDeletedEventHandler ItemDeleted {\r
 130                         add { Events.AddHandler (ItemDeletedEvent, value); }\r
 131                         remove { Events.RemoveHandler (ItemDeletedEvent, value); }\r
 132                 }\r
 133                 \r
 134                 public event FormViewDeleteEventHandler ItemDeleting {\r
 135                         add { Events.AddHandler (ItemDeletingEvent, value); }\r
 136                         remove { Events.RemoveHandler (ItemDeletingEvent, value); }\r
 137                 }\r
 138                 \r
 139                 public event FormViewInsertedEventHandler ItemInserted {\r
 140                         add { Events.AddHandler (ItemInsertedEvent, value); }\r
 141                         remove { Events.RemoveHandler (ItemInsertedEvent, value); }\r
 142                 }\r
 143                 \r
 144                 public event FormViewInsertEventHandler ItemInserting {\r
 145                         add { Events.AddHandler (ItemInsertingEvent, value); }\r
 146                         remove { Events.RemoveHandler (ItemInsertingEvent, value); }\r
 147                 }\r
 148                 \r
 149                 public event FormViewModeEventHandler ModeChanging {\r
 150                         add { Events.AddHandler (ModeChangingEvent, value); }\r
 151                         remove { Events.RemoveHandler (ModeChangingEvent, value); }\r
 152                 }\r
 153                 \r
 154                 public event EventHandler ModeChanged {\r
 155                         add { Events.AddHandler (ModeChangedEvent, value); }\r
 156                         remove { Events.RemoveHandler (ModeChangedEvent, value); }\r
 157                 }\r
 158                 \r
 159                 public event FormViewUpdatedEventHandler ItemUpdated {\r
 160                         add { Events.AddHandler (ItemUpdatedEvent, value); }\r
 161                         remove { Events.RemoveHandler (ItemUpdatedEvent, value); }\r
 162                 }\r
 163                 \r
 164                 public event FormViewUpdateEventHandler ItemUpdating {\r
 165                         add { Events.AddHandler (ItemUpdatingEvent, value); }\r
 166                         remove { Events.RemoveHandler (ItemUpdatingEvent, value); }\r
 167                 }\r
 168                 \r
 169                 protected virtual void OnPageIndexChanged (EventArgs e)\r
 170                 {\r
 171                         if (Events != null) {\r
 172                                 EventHandler eh = (EventHandler) Events [PageIndexChangedEvent];\r
 173                                 if (eh != null) eh (this, e);\r
 174                         }\r
 175                 }\r
 176                 \r
 177                 protected virtual void OnPageIndexChanging (FormViewPageEventArgs e)\r
 178                 {\r
 179                         if (Events != null) {\r
 180                                 FormViewPageEventHandler eh = (FormViewPageEventHandler) Events [PageIndexChangingEvent];\r
 181                                 if (eh != null) eh (this, e);\r
 182                         }\r
 183                 }\r
 184                 \r
 185                 protected virtual void OnItemCommand (FormViewCommandEventArgs e)\r
 186                 {\r
 187                         if (Events != null) {\r
 188                                 FormViewCommandEventHandler eh = (FormViewCommandEventHandler) Events [ItemCommandEvent];\r
 189                                 if (eh != null) eh (this, e);\r
 190                         }\r
 191                 }\r
 192                 \r
 193                 protected virtual void OnItemCreated (EventArgs e)\r
 194                 {\r
 195                         if (Events != null) {\r
 196                                 EventHandler eh = (EventHandler) Events [ItemCreatedEvent];\r
 197                                 if (eh != null) eh (this, e);\r
 198                         }\r
 199                 }\r
 200                 \r
 201                 protected virtual void OnItemDeleted (FormViewDeletedEventArgs e)\r
 202                 {\r
 203                         if (Events != null) {\r
 204                                 FormViewDeletedEventHandler eh = (FormViewDeletedEventHandler) Events [ItemDeletedEvent];\r
 205                                 if (eh != null) eh (this, e);\r
 206                         }\r
 207                 }\r
 208                 \r
 209                 protected virtual void OnItemInserted (FormViewInsertedEventArgs e)\r
 210                 {\r
 211                         if (Events != null) {\r
 212                                 FormViewInsertedEventHandler eh = (FormViewInsertedEventHandler) Events [ItemInsertedEvent];\r
 213                                 if (eh != null) eh (this, e);\r
 214                         }\r
 215                 }\r
 216                 \r
 217                 protected virtual void OnItemInserting (FormViewInsertEventArgs e)\r
 218                 {\r
 219                         if (Events != null) {\r
 220                                 FormViewInsertEventHandler eh = (FormViewInsertEventHandler) Events [ItemInsertingEvent];\r
 221                                 if (eh != null) eh (this, e);\r
 222                         }\r
 223                 }\r
 224                 \r
 225                 protected virtual void OnItemDeleting (FormViewDeleteEventArgs e)\r
 226                 {\r
 227                         if (Events != null) {\r
 228                                 FormViewDeleteEventHandler eh = (FormViewDeleteEventHandler) Events [ItemDeletingEvent];\r
 229                                 if (eh != null) eh (this, e);\r
 230                         }\r
 231                 }\r
 232                 \r
 233                 protected virtual void OnModeChanged (EventArgs e)\r
 234                 {\r
 235                         if (Events != null) {\r
 236                                 EventHandler eh = (EventHandler) Events [ModeChangedEvent];\r
 237                                 if (eh != null) eh (this, e);\r
 238                         }\r
 239                 }\r
 240                 \r
 241                 protected virtual void OnModeChanging (FormViewModeEventArgs e)\r
 242                 {\r
 243                         if (Events != null) {\r
 244                                 FormViewModeEventHandler eh = (FormViewModeEventHandler) Events [ModeChangingEvent];\r
 245                                 if (eh != null) eh (this, e);\r
 246                         }\r
 247                 }\r
 248                 \r
 249                 protected virtual void OnItemUpdated (FormViewUpdatedEventArgs e)\r
 250                 {\r
 251                         if (Events != null) {\r
 252                                 FormViewUpdatedEventHandler eh = (FormViewUpdatedEventHandler) Events [ItemUpdatedEvent];\r
 253                                 if (eh != null) eh (this, e);\r
 254                         }\r
 255                 }\r
 256                 \r
 257                 protected virtual void OnItemUpdating (FormViewUpdateEventArgs e)\r
 258                 {\r
 259                         if (Events != null) {\r
 260                                 FormViewUpdateEventHandler eh = (FormViewUpdateEventHandler) Events [ItemUpdatingEvent];\r
 261                                 if (eh != null) eh (this, e);\r
 262                         }\r
 263                 }\r
 264                 \r
 265                 \r
 266                 [WebCategoryAttribute ("Paging")]\r
 267                 [DefaultValueAttribute (false)]\r
 268                 public virtual bool AllowPaging {\r
 269                         get {\r
 270                                 object ob = ViewState ["AllowPaging"];\r
 271                                 if (ob != null) return (bool) ob;\r
 272                                 return false;\r
 273                         }\r
 274                         set {\r
 275                                 ViewState ["AllowPaging"] = value;\r
 276                                 RequireBinding ();\r
 277                         }\r
 278                 }\r
 279                 \r
 280                 [UrlPropertyAttribute]\r
 281                 [WebCategoryAttribute ("Appearance")]\r
 282                 [DefaultValueAttribute ("")]\r
 283                 [EditorAttribute ("System.Web.UI.Design.ImageUrlEditor, " + Consts.AssemblySystem_Design, "System.Drawing.Design.UITypeEditor, " + Consts.AssemblySystem_Drawing)]\r
 284                 public virtual string BackImageUrl {\r
 285                         get {\r
 286                                 if (ControlStyleCreated)\r
 287                                         return ((TableStyle) ControlStyle).BackImageUrl;\r
 288                                 return String.Empty;\r
 289                         }\r
 290                         set {\r
 291                                 ((TableStyle) ControlStyle).BackImageUrl = value;\r
 292                         }\r
 293                 }\r
 294 \r
 295                 [DesignerSerializationVisibilityAttribute (DesignerSerializationVisibility.Hidden)]\r
 296                 [BrowsableAttribute (false)]\r
 297                 public virtual FormViewRow BottomPagerRow {\r
 298                         get {\r
 299                                 EnsureChildControls ();\r
 300                                 return bottomPagerRow;\r
 301                         }\r
 302                 }\r
 303         \r
 304                 [WebCategoryAttribute ("Accessibility")]\r
 305                 [DefaultValueAttribute ("")]\r
 306                 [LocalizableAttribute (true)]\r
 307                 public virtual string Caption {\r
 308                         get {\r
 309                                 object ob = ViewState ["Caption"];\r
 310                                 if (ob != null) return (string) ob;\r
 311                                 return string.Empty;\r
 312                         }\r
 313                         set {\r
 314                                 ViewState ["Caption"] = value;\r
 315                                 RequireBinding ();\r
 316                         }\r
 317                 }\r
 318                 \r
 319                 [WebCategoryAttribute ("Accessibility")]\r
 320                 [DefaultValueAttribute (TableCaptionAlign.NotSet)]\r
 321                 public virtual TableCaptionAlign CaptionAlign\r
 322                 {\r
 323                         get {\r
 324                                 object o = ViewState ["CaptionAlign"];\r
 325                                 if(o != null) return (TableCaptionAlign) o;\r
 326                                 return TableCaptionAlign.NotSet;\r
 327                         }\r
 328                         set {\r
 329                                 ViewState ["CaptionAlign"] = value;\r
 330                                 RequireBinding ();\r
 331                         }\r
 332                 }\r
 333 \r
 334                 [WebCategoryAttribute ("Layout")]\r
 335                 [DefaultValueAttribute (-1)]\r
 336                 public virtual int CellPadding\r
 337                 {\r
 338                         get {\r
 339                                 if (ControlStyleCreated)\r
 340                                         return ((TableStyle) ControlStyle).CellPadding;\r
 341                                 return -1;\r
 342                         }\r
 343                         set {\r
 344                                 ((TableStyle) ControlStyle).CellPadding = value;\r
 345                         }\r
 346                 }\r
 347 \r
 348                 [WebCategoryAttribute ("Layout")]\r
 349                 [DefaultValueAttribute (0)]\r
 350                 public virtual int CellSpacing\r
 351                 {\r
 352                         get {\r
 353                                 if (ControlStyleCreated)\r
 354                                         return ((TableStyle) ControlStyle).CellSpacing;\r
 355                                 return 0;\r
 356                         }\r
 357                         set {\r
 358                                 ((TableStyle) ControlStyle).CellSpacing = value;\r
 359                         }\r
 360                 }\r
 361                 \r
 362                 [DesignerSerializationVisibilityAttribute (DesignerSerializationVisibility.Hidden)]\r
 363                 [BrowsableAttribute (false)]\r
 364                 public FormViewMode CurrentMode {\r
 365                         get {\r
 366                                 return hasCurrentMode ? currentMode : DefaultMode;\r
 367                         }\r
 368                         private set {\r
 369                                 hasCurrentMode = true;\r
 370                                 currentMode = value;\r
 371                         }\r
 372                 }\r
 373 \r
 374                 FormViewMode defaultMode;\r
 375 \r
 376                 [DefaultValueAttribute (FormViewMode.ReadOnly)]\r
 377                 [WebCategoryAttribute ("Behavior")]\r
 378                 public virtual FormViewMode DefaultMode {\r
 379                         get {\r
 380                                 return defaultMode;\r
 381                         }\r
 382                         set {\r
 383                                 defaultMode = value;\r
 384                                 RequireBinding ();\r
 385                         }\r
 386                 }\r
 387 \r
 388                 string[] dataKeyNames;\r
 389                 [DefaultValueAttribute (null)]\r
 390                 [WebCategoryAttribute ("Data")]\r
 391                 [TypeConverter (typeof(StringArrayConverter))]\r
 392                 [EditorAttribute ("System.Web.UI.Design.WebControls.DataFieldEditor, " + Consts.AssemblySystem_Design, "System.Drawing.Design.UITypeEditor, " + Consts.AssemblySystem_Drawing)]\r
 393                 public virtual string[] DataKeyNames\r
 394                 {\r
 395                         get {\r
 396                                 if (dataKeyNames == null)\r
 397                                         return emptyKeys;\r
 398                                 return dataKeyNames;\r
 399                         }\r
 400                         set {\r
 401                                 dataKeyNames = value;\r
 402                                 RequireBinding ();\r
 403                         }\r
 404                 }\r
 405                 \r
 406                 IOrderedDictionary KeyTable {\r
 407                         get {\r
 408                                 if (_keyTable == null) {\r
 409                                         _keyTable = new OrderedDictionary (DataKeyNames.Length);\r
 410                                 }\r
 411                                 return _keyTable;\r
 412                         }\r
 413                 }\r
 414 \r
 415                 [BrowsableAttribute (false)]\r
 416                 [DesignerSerializationVisibilityAttribute (DesignerSerializationVisibility.Hidden)]\r
 417                 public virtual DataKey DataKey {\r
 418                         get {\r
 419                                 if (key == null) {\r
 420                                         key= new DataKey (KeyTable);\r
 421                                 }\r
 422                                 return key;\r
 423                         }\r
 424                 }\r
 425 \r
 426                 DataKey OldEditValues {\r
 427                         get {\r
 428                                 if (oldEditValues == null) {\r
 429                                         oldEditValues = new DataKey (new OrderedDictionary ());\r
 430                                 }\r
 431                                 return oldEditValues;\r
 432                         }\r
 433                 }\r
 434 \r
 435                 [DefaultValue (null)]\r
 436                 [TemplateContainer (typeof(FormView), BindingDirection.TwoWay)]\r
 437                 [PersistenceMode (PersistenceMode.InnerProperty)]\r
 438                 [Browsable (false)]\r
 439                 public virtual ITemplate EditItemTemplate {\r
 440                         get { return editItemTemplate; }\r
 441                         set { editItemTemplate = value; RequireBinding (); }\r
 442                 }\r
 443 \r
 444                 [WebCategoryAttribute ("Styles")]\r
 445                 [PersistenceMode (PersistenceMode.InnerProperty)]\r
 446                 [NotifyParentProperty (true)]\r
 447                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Content)]\r
 448                 [DefaultValueAttribute (null)]\r
 449                 public TableItemStyle EditRowStyle {\r
 450                         get {\r
 451                                 if (editRowStyle == null) {\r
 452                                         editRowStyle = new TableItemStyle ();\r
 453                                         if (IsTrackingViewState)\r
 454                                                 editRowStyle.TrackViewState();\r
 455                                 }\r
 456                                 return editRowStyle;\r
 457                         }\r
 458                 }\r
 459                 \r
 460                 [WebCategoryAttribute ("Styles")]\r
 461                 [PersistenceMode (PersistenceMode.InnerProperty)]\r
 462                 [NotifyParentProperty (true)]\r
 463                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Content)]\r
 464                 [DefaultValueAttribute (null)]\r
 465                 public TableItemStyle EmptyDataRowStyle {\r
 466                         get {\r
 467                                 if (emptyDataRowStyle == null) {\r
 468                                         emptyDataRowStyle = new TableItemStyle ();\r
 469                                         if (IsTrackingViewState)\r
 470                                                 emptyDataRowStyle.TrackViewState();\r
 471                                 }\r
 472                                 return emptyDataRowStyle;\r
 473                         }\r
 474                 }\r
 475                 \r
 476                 [DefaultValue (null)]\r
 477                 [TemplateContainer (typeof(FormView), BindingDirection.OneWay)]\r
 478                 [PersistenceMode (PersistenceMode.InnerProperty)]\r
 479                 [Browsable (false)]\r
 480                 public virtual ITemplate EmptyDataTemplate {\r
 481                         get { return emptyDataTemplate; }\r
 482                         set { emptyDataTemplate = value; RequireBinding (); }\r
 483                 }\r
 484                 \r
 485                 [LocalizableAttribute (true)]\r
 486                 [WebCategoryAttribute ("Appearance")]\r
 487                 [DefaultValueAttribute ("")]\r
 488                 public virtual string EmptyDataText {\r
 489                         get {\r
 490                                 object ob = ViewState ["EmptyDataText"];\r
 491                                 if (ob != null) return (string) ob;\r
 492                                 return string.Empty;\r
 493                         }\r
 494                         set {\r
 495                                 ViewState ["EmptyDataText"] = value;\r
 496                                 RequireBinding ();\r
 497                         }\r
 498                 }\r
 499         \r
 500                 [DesignerSerializationVisibilityAttribute (DesignerSerializationVisibility.Hidden)]\r
 501                 [BrowsableAttribute (false)]\r
 502                 public virtual FormViewRow FooterRow {\r
 503                         get {\r
 504                                 EnsureChildControls ();\r
 505                                 return footerRow;\r
 506                         }\r
 507                 }\r
 508         \r
 509                 [DefaultValue (null)]\r
 510                 [TemplateContainer (typeof(FormView), BindingDirection.OneWay)]\r
 511                 [PersistenceMode (PersistenceMode.InnerProperty)]\r
 512                 [Browsable (false)]\r
 513                 public virtual ITemplate FooterTemplate {\r
 514                         get { return footerTemplate; }\r
 515                         set { footerTemplate = value; RequireBinding (); }\r
 516                 }\r
 517 \r
 518                 [LocalizableAttribute (true)]\r
 519                 [WebCategoryAttribute ("Appearance")]\r
 520                 [DefaultValueAttribute ("")]\r
 521                 public virtual string FooterText {\r
 522                         get {\r
 523                                 object ob = ViewState ["FooterText"];\r
 524                                 if (ob != null) return (string) ob;\r
 525                                 return string.Empty;\r
 526                         }\r
 527                         set {\r
 528                                 ViewState ["FooterText"] = value;\r
 529                                 RequireBinding ();\r
 530                         }\r
 531                 }\r
 532                 \r
 533                 [WebCategoryAttribute ("Styles")]\r
 534                 [PersistenceMode (PersistenceMode.InnerProperty)]\r
 535                 [NotifyParentProperty (true)]\r
 536                 [DefaultValue (null)]\r
 537                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Content)]\r
 538                 public TableItemStyle FooterStyle {\r
 539                         get {\r
 540                                 if (footerStyle == null) {\r
 541                                         footerStyle = new TableItemStyle ();\r
 542                                         if (IsTrackingViewState)\r
 543                                                 footerStyle.TrackViewState();\r
 544                                 }\r
 545                                 return footerStyle;\r
 546                         }\r
 547                 }\r
 548                 \r
 549                 [WebCategoryAttribute ("Appearance")]\r
 550                 [DefaultValueAttribute (GridLines.None)]\r
 551                 public virtual GridLines GridLines {\r
 552                         get {\r
 553                                 if (ControlStyleCreated)\r
 554                                         return ((TableStyle) ControlStyle).GridLines;\r
 555                                 return GridLines.None;\r
 556                         }\r
 557                         set {\r
 558                                 ((TableStyle) ControlStyle).GridLines = value;\r
 559                         }\r
 560                 }\r
 561 \r
 562                 [DesignerSerializationVisibilityAttribute (DesignerSerializationVisibility.Hidden)]\r
 563                 [BrowsableAttribute (false)]\r
 564                 public virtual FormViewRow HeaderRow {\r
 565                         get {\r
 566                                 EnsureChildControls ();\r
 567                                 return headerRow;\r
 568                         }\r
 569                 }\r
 570         \r
 571                 [WebCategoryAttribute ("Styles")]\r
 572                 [PersistenceMode (PersistenceMode.InnerProperty)]\r
 573                 [NotifyParentProperty (true)]\r
 574                 [DefaultValue (null)]\r
 575                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Content)]\r
 576                 public TableItemStyle HeaderStyle {\r
 577                         get {\r
 578                                 if (headerStyle == null) {\r
 579                                         headerStyle = new TableItemStyle ();\r
 580                                         if (IsTrackingViewState)\r
 581                                                 headerStyle.TrackViewState();\r
 582                                 }\r
 583                                 return headerStyle;\r
 584                         }\r
 585                 }\r
 586                 \r
 587                 [DefaultValue (null)]\r
 588                 [TemplateContainer (typeof(FormView), BindingDirection.OneWay)]\r
 589                 [PersistenceMode (PersistenceMode.InnerProperty)]\r
 590                 [Browsable (false)]\r
 591                 public virtual ITemplate HeaderTemplate {\r
 592                         get { return headerTemplate; }\r
 593                         set { headerTemplate = value; RequireBinding (); }\r
 594                 }\r
 595 \r
 596                 [LocalizableAttribute (true)]\r
 597                 [WebCategoryAttribute ("Appearance")]\r
 598                 [DefaultValueAttribute ("")]\r
 599                 public virtual string HeaderText {\r
 600                         get {\r
 601                                 object ob = ViewState ["HeaderText"];\r
 602                                 if (ob != null) return (string) ob;\r
 603                                 return string.Empty;\r
 604                         }\r
 605                         set {\r
 606                                 ViewState ["HeaderText"] = value;\r
 607                                 RequireBinding ();\r
 608                         }\r
 609                 }\r
 610                 \r
 611                 [Category ("Layout")]\r
 612                 [DefaultValueAttribute (HorizontalAlign.NotSet)]\r
 613                 public virtual HorizontalAlign HorizontalAlign {\r
 614                         get {\r
 615                                 if (ControlStyleCreated)\r
 616                                         return ((TableStyle) ControlStyle).HorizontalAlign;\r
 617                                 return HorizontalAlign.NotSet;\r
 618                         }\r
 619                         set {\r
 620                                 ((TableStyle) ControlStyle).HorizontalAlign = value;\r
 621                         }\r
 622                 }\r
 623 \r
 624                 [DefaultValue (null)]\r
 625                 [TemplateContainer (typeof(FormView), BindingDirection.TwoWay)]\r
 626                 [PersistenceMode (PersistenceMode.InnerProperty)]\r
 627                 [Browsable (false)]\r
 628                 public virtual ITemplate InsertItemTemplate {\r
 629                         get { return insertItemTemplate; }\r
 630                         set { insertItemTemplate = value; RequireBinding (); }\r
 631                 }\r
 632 \r
 633                 [WebCategoryAttribute ("Styles")]\r
 634                 [PersistenceMode (PersistenceMode.InnerProperty)]\r
 635                 [NotifyParentProperty (true)]\r
 636                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Content)]\r
 637                 [DefaultValueAttribute (null)]\r
 638                 public TableItemStyle InsertRowStyle {\r
 639                         get {\r
 640                                 if (insertRowStyle == null) {\r
 641                                         insertRowStyle = new TableItemStyle ();\r
 642                                         if (IsTrackingViewState)\r
 643                                                 insertRowStyle.TrackViewState();\r
 644                                 }\r
 645                                 return insertRowStyle;\r
 646                         }\r
 647                 }\r
 648 \r
 649                 [DefaultValue (null)]\r
 650                 [TemplateContainer (typeof(FormView), BindingDirection.TwoWay)]\r
 651                 [PersistenceMode (PersistenceMode.InnerProperty)]\r
 652                 [Browsable (false)]\r
 653                 public virtual ITemplate ItemTemplate {\r
 654                         get { return itemTemplate; }\r
 655                         set { itemTemplate = value; RequireBinding (); }\r
 656                 }\r
 657                 \r
 658                 [BrowsableAttribute (false)]\r
 659                 [DesignerSerializationVisibilityAttribute (DesignerSerializationVisibility.Hidden)]\r
 660                 public virtual int PageCount {\r
 661                         get {\r
 662                                 return pageCount;\r
 663                         }\r
 664                 }\r
 665 \r
 666                 [WebCategoryAttribute ("Paging")]\r
 667                 [BindableAttribute (true, BindingDirection.OneWay)]\r
 668                 [DefaultValueAttribute (0)]\r
 669                 public virtual int PageIndex {\r
 670                         get {\r
 671                                 return pageIndex;\r
 672                         }\r
 673                         set {\r
 674                                 if (value < 0)\r
 675                                         throw new ArgumentOutOfRangeException ("PageIndex must be non-negative");\r
 676                                 if (pageIndex == value)\r
 677                                         return;\r
 678                                 pageIndex = value;\r
 679                                 RequireBinding ();\r
 680                         }\r
 681                 }\r
 682         \r
 683                 [WebCategoryAttribute ("Paging")]\r
 684                 [DesignerSerializationVisibilityAttribute (DesignerSerializationVisibility.Content)]\r
 685                 [NotifyParentPropertyAttribute (true)]\r
 686                 [PersistenceModeAttribute (PersistenceMode.InnerProperty)]\r
 687                 public virtual PagerSettings PagerSettings {\r
 688                         get {\r
 689                                 if (pagerSettings == null) {\r
 690                                         pagerSettings = new PagerSettings (this);\r
 691                                         if (IsTrackingViewState)\r
 692                                                 ((IStateManager)pagerSettings).TrackViewState ();\r
 693                                 }\r
 694                                 return pagerSettings;\r
 695                         }\r
 696                 }\r
 697         \r
 698                 [WebCategoryAttribute ("Styles")]\r
 699                 [PersistenceMode (PersistenceMode.InnerProperty)]\r
 700                 [NotifyParentProperty (true)]\r
 701                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Content)]\r
 702                 public TableItemStyle PagerStyle {\r
 703                         get {\r
 704                                 if (pagerStyle == null) {\r
 705                                         pagerStyle = new TableItemStyle ();\r
 706                                         if (IsTrackingViewState)\r
 707                                                 pagerStyle.TrackViewState();\r
 708                                 }\r
 709                                 return pagerStyle;\r
 710                         }\r
 711                 }\r
 712                 \r
 713                 \r
 714                 [DefaultValue (null)]\r
 715                 /* DataControlPagerCell isnt specified in the docs */\r
 716                 //[TemplateContainer (typeof(DataControlPagerCell), BindingDirection.OneWay)]\r
 717                 [PersistenceMode (PersistenceMode.InnerProperty)]\r
 718                 [Browsable (false)]\r
 719                 public virtual ITemplate PagerTemplate {\r
 720                         get { return pagerTemplate; }\r
 721                         set { pagerTemplate = value; RequireBinding (); }\r
 722                 }\r
 723                 \r
 724                 [DesignerSerializationVisibilityAttribute (DesignerSerializationVisibility.Hidden)]\r
 725                 [BrowsableAttribute (false)]\r
 726                 public virtual FormViewRow Row {\r
 727                         get {\r
 728                                 EnsureChildControls ();\r
 729                                 return itemRow;\r
 730                         }\r
 731                 }\r
 732                 \r
 733                 [WebCategoryAttribute ("Styles")]\r
 734                 [PersistenceMode (PersistenceMode.InnerProperty)]\r
 735                 [NotifyParentProperty (true)]\r
 736                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Content)]\r
 737                 [DefaultValue (null)]\r
 738                 public TableItemStyle RowStyle {\r
 739                         get {\r
 740                                 if (rowStyle == null) {\r
 741                                         rowStyle = new TableItemStyle ();\r
 742                                         if (IsTrackingViewState)\r
 743                                                 rowStyle.TrackViewState();\r
 744                                 }\r
 745                                 return rowStyle;\r
 746                         }\r
 747                 }\r
 748 \r
 749                 [DesignerSerializationVisibilityAttribute (DesignerSerializationVisibility.Hidden)]\r
 750                 [BrowsableAttribute (false)]\r
 751                 public object SelectedValue {\r
 752                         get { return DataKey.Value; }\r
 753                 }\r
 754                 \r
 755                 [DesignerSerializationVisibilityAttribute (DesignerSerializationVisibility.Hidden)]\r
 756                 [BrowsableAttribute (false)]\r
 757                 public virtual FormViewRow TopPagerRow {\r
 758                         get {\r
 759                                 EnsureChildControls ();\r
 760                                 return topPagerRow;\r
 761                         }\r
 762                 }\r
 763         \r
 764                 [DesignerSerializationVisibilityAttribute (DesignerSerializationVisibility.Hidden)]\r
 765                 [BrowsableAttribute (false)]\r
 766                 public virtual object DataItem {\r
 767                         get {\r
 768                                 EnsureDataBound ();\r
 769                                 return dataItem;\r
 770                         }\r
 771                 }\r
 772                 \r
 773                 [DesignerSerializationVisibilityAttribute (DesignerSerializationVisibility.Hidden)]\r
 774                 [BrowsableAttribute (false)]\r
 775                 public int DataItemCount {\r
 776                         get { return PageCount; }\r
 777                 }               \r
 778         \r
 779                 [DesignerSerializationVisibilityAttribute (DesignerSerializationVisibility.Hidden)]\r
 780                 [BrowsableAttribute (false)]\r
 781                 public virtual int DataItemIndex {\r
 782                         get { return PageIndex; }\r
 783                 }\r
 784 \r
 785                 int IDataItemContainer.DataItemIndex {\r
 786                         get { return DataItemIndex; }\r
 787                 }\r
 788         \r
 789                 int IDataItemContainer.DisplayIndex {\r
 790                         get { return PageIndex; }\r
 791                 }               \r
 792         \r
 793                 public virtual bool IsBindableType (Type type)\r
 794                 {\r
 795                         return type.IsPrimitive || type == typeof (string) || type == typeof (DateTime) || type == typeof (Guid) || type == typeof (Decimal);\r
 796                 }\r
 797                 \r
 798                 protected override DataSourceSelectArguments CreateDataSourceSelectArguments ()\r
 799                 {\r
 800                         DataSourceSelectArguments arg = new DataSourceSelectArguments ();\r
 801                         DataSourceView view = GetData ();\r
 802                         if (AllowPaging && view.CanPage) {\r
 803                                 arg.StartRowIndex = PageIndex;\r
 804                                 if (view.CanRetrieveTotalRowCount) {\r
 805                                         arg.RetrieveTotalRowCount = true;\r
 806                                         arg.MaximumRows = 1;\r
 807                                 }\r
 808                                 else {\r
 809                                         arg.MaximumRows = -1;\r
 810                                 }\r
 811                         }\r
 812                         return arg;\r
 813                 }\r
 814                 \r
 815                 protected virtual FormViewRow CreateRow (int rowIndex, DataControlRowType rowType, DataControlRowState rowState)\r
 816                 {\r
 817                         FormViewRow row = new FormViewRow (rowIndex, rowType, rowState);\r
 818                         OnItemCreated (EventArgs.Empty);\r
 819                         return row;\r
 820                 }\r
 821                 \r
 822                 void RequireBinding ()\r
 823                 {\r
 824                         if (Initialized) {\r
 825                                 RequiresDataBinding = true;\r
 826                         }\r
 827                 }\r
 828                 \r
 829                 protected virtual Table CreateTable ()\r
 830                 {\r
 831                         return new ContainedTable (this);\r
 832                 }\r
 833 \r
 834                 [MonoTODO]\r
 835                 protected override void EnsureDataBound ()\r
 836                 {\r
 837                         base.EnsureDataBound ();\r
 838                 }\r
 839         \r
 840                 protected override Style CreateControlStyle ()\r
 841                 {\r
 842                         TableStyle style = new TableStyle (ViewState);\r
 843                         style.CellSpacing = 0;\r
 844                         return style;\r
 845                 }\r
 846                 \r
 847                 protected override int CreateChildControls (IEnumerable data, bool dataBinding)\r
 848                 {\r
 849                         PagedDataSource dataSource = new PagedDataSource ();\r
 850                         dataSource.DataSource = data;\r
 851                         dataSource.AllowPaging = AllowPaging;\r
 852                         dataSource.PageSize = 1;\r
 853                         dataSource.CurrentPageIndex = PageIndex;\r
 854 \r
 855                         if (dataBinding && CurrentMode != FormViewMode.Insert) {\r
 856                                 DataSourceView view = GetData ();\r
 857                                 if (view != null && view.CanPage) {\r
 858                                         dataSource.AllowServerPaging = true;\r
 859                                         if (SelectArguments.RetrieveTotalRowCount)\r
 860                                                 dataSource.VirtualCount = SelectArguments.TotalRowCount;\r
 861                                 }\r
 862                         }\r
 863 \r
 864                         pageCount = dataSource.DataSourceCount;\r
 865                         bool showPager = AllowPaging && (pageCount > 1);\r
 866                         \r
 867                         Controls.Clear ();\r
 868                         table = CreateTable ();\r
 869                         Controls.Add (table);\r
 870 \r
 871                         // Gets the current data item\r
 872                         \r
 873                         IEnumerator e = dataSource.GetEnumerator (); \r
 874                         dataItem = null;\r
 875 \r
 876                         if (AllowPaging) {\r
 877                                 if (e.MoveNext ())\r
 878                                         dataItem = e.Current;\r
 879                         }\r
 880                         else\r
 881                         for (int page = 0; e.MoveNext (); page++ )\r
 882                                 if (page == PageIndex)\r
 883                                         dataItem = e.Current;\r
 884                         \r
 885                         // Main table creation\r
 886                         \r
 887                         if (HeaderText.Length != 0 || headerTemplate != null) {\r
 888                                 headerRow = CreateRow (-1, DataControlRowType.Header, DataControlRowState.Normal);\r
 889                                 InitializeRow (headerRow);\r
 890                                 table.Rows.Add (headerRow);\r
 891                         }\r
 892                         \r
 893                         if (showPager && PagerSettings.Position == PagerPosition.Top || PagerSettings.Position == PagerPosition.TopAndBottom) {\r
 894                                 topPagerRow = CreateRow (-1, DataControlRowType.Pager, DataControlRowState.Normal);\r
 895                                 InitializePager (topPagerRow, dataSource);\r
 896                                 table.Rows.Add (topPagerRow);\r
 897                         }\r
 898 \r
 899                         if (pageCount > 0) {\r
 900                                 DataControlRowState rstate = GetRowState ();\r
 901                                 itemRow = CreateRow (0, DataControlRowType.DataRow, rstate);\r
 902                                 InitializeRow (itemRow);\r
 903                                 table.Rows.Add (itemRow);\r
 904                         } else {\r
 905                                 switch (CurrentMode) {\r
 906                                 case FormViewMode.Edit:\r
 907                                         itemRow = CreateRow (-1, DataControlRowType.EmptyDataRow, DataControlRowState.Edit);\r
 908                                         break;\r
 909                                 case FormViewMode.Insert:\r
 910                                         itemRow = CreateRow (-1, DataControlRowType.DataRow, DataControlRowState.Insert);\r
 911                                         break;\r
 912                                 default:\r
 913                                         itemRow = CreateRow (-1, DataControlRowType.EmptyDataRow, DataControlRowState.Normal);\r
 914                                         break;\r
 915                                 }\r
 916                                 table.Rows.Add (itemRow);\r
 917                                 InitializeRow (itemRow);\r
 918                         }\r
 919 \r
 920                         if (FooterText.Length != 0 || footerTemplate != null) {\r
 921                                 footerRow = CreateRow (-1, DataControlRowType.Footer, DataControlRowState.Normal);\r
 922                                 InitializeRow (footerRow);\r
 923                                 table.Rows.Add (footerRow);\r
 924                         }\r
 925                         \r
 926                         if (showPager && PagerSettings.Position == PagerPosition.Bottom || PagerSettings.Position == PagerPosition.TopAndBottom) {\r
 927                                 bottomPagerRow = CreateRow (0, DataControlRowType.Pager, DataControlRowState.Normal);\r
 928                                 InitializePager (bottomPagerRow, dataSource);\r
 929                                 table.Rows.Add (bottomPagerRow);\r
 930                         }\r
 931 \r
 932                         if (dataBinding)\r
 933                                 DataBind (false);\r
 934                         \r
 935                         return dataSource.DataSourceCount;\r
 936                 }\r
 937                 \r
 938                 DataControlRowState GetRowState ()\r
 939                 {\r
 940                         DataControlRowState rstate = DataControlRowState.Normal;\r
 941                         if (CurrentMode == FormViewMode.Edit) rstate |= DataControlRowState.Edit;\r
 942                         else if (CurrentMode == FormViewMode.Insert) rstate |= DataControlRowState.Insert;\r
 943                         return rstate;\r
 944                 }\r
 945                 \r
 946                 protected virtual void InitializePager (FormViewRow row, PagedDataSource dataSource)\r
 947                 {\r
 948                         TableCell cell = new TableCell ();\r
 949                         cell.ColumnSpan = 2;\r
 950 \r
 951                         if (pagerTemplate != null)\r
 952                                 pagerTemplate.InstantiateIn (cell);\r
 953                         else\r
 954                                 cell.Controls.Add (PagerSettings.CreatePagerControl (dataSource.CurrentPageIndex, dataSource.PageCount));\r
 955                         \r
 956                         row.Cells.Add (cell);\r
 957                 }\r
 958                 \r
 959                 protected virtual void InitializeRow (FormViewRow row)\r
 960                 {\r
 961                         TableCell cell = new TableCell ();\r
 962                         \r
 963                         if (row.RowType == DataControlRowType.DataRow)\r
 964                         {\r
 965                                 if ((row.RowState & DataControlRowState.Edit) != 0) {\r
 966                                         if (editItemTemplate != null)\r
 967                                                 editItemTemplate.InstantiateIn (cell);\r
 968                                 } else if ((row.RowState & DataControlRowState.Insert) != 0) {\r
 969                                         if (insertItemTemplate != null)\r
 970                                                 insertItemTemplate.InstantiateIn (cell);\r
 971                                 } else if (itemTemplate != null)\r
 972                                         itemTemplate.InstantiateIn (cell);\r
 973                         }\r
 974                         else if (row.RowType == DataControlRowType.EmptyDataRow)\r
 975                         {\r
 976                                 if (emptyDataTemplate != null)\r
 977                                         emptyDataTemplate.InstantiateIn (cell);\r
 978                                 else\r
 979                                         cell.Text = EmptyDataText;\r
 980                         }\r
 981                         else if (row.RowType == DataControlRowType.Footer)\r
 982                         {\r
 983                                 if (footerTemplate != null)\r
 984                                         footerTemplate.InstantiateIn (cell);\r
 985                                 else\r
 986                                         cell.Text = FooterText;\r
 987                         }\r
 988                         else if (row.RowType == DataControlRowType.Header)\r
 989                         {\r
 990                                 if (headerTemplate != null)\r
 991                                         headerTemplate.InstantiateIn (cell);\r
 992                                 else\r
 993                                         cell.Text = HeaderText;\r
 994                         }\r
 995                         cell.ColumnSpan = 2;\r
 996                         row.Cells.Add (cell);\r
 997                 }\r
 998                 \r
 999                 void FillRowDataKey (object dataItem)\r
1000                 {\r
1001                         KeyTable.Clear ();\r
1002 \r
1003                         if (cachedKeyProperties == null) {\r
1004                                 PropertyDescriptorCollection props = TypeDescriptor.GetProperties (dataItem);\r
1005                                 cachedKeyProperties = new PropertyDescriptor [DataKeyNames.Length];\r
1006                                 for (int n=0; n<DataKeyNames.Length; n++) { \r
1007                                         PropertyDescriptor p = props [DataKeyNames[n]];\r
1008                                         if (p == null)\r
1009                                                 new InvalidOperationException ("Property '" + DataKeyNames[n] + "' not found in object of type " + dataItem.GetType());\r
1010                                         cachedKeyProperties [n] = p;\r
1011                                 }\r
1012                         }\r
1013                         foreach (PropertyDescriptor p in cachedKeyProperties)\r
1014                                 KeyTable [p.Name] = p.GetValue (dataItem);\r
1015                 }\r
1016                 \r
1017                 IOrderedDictionary GetRowValues (bool includePrimaryKey)\r
1018                 {\r
1019                         OrderedDictionary dic = new OrderedDictionary ();\r
1020                         ExtractRowValues (dic, includePrimaryKey);\r
1021                         return dic;\r
1022                 }\r
1023                 \r
1024                 protected virtual void ExtractRowValues (IOrderedDictionary fieldValues, bool includeKeys)\r
1025                 {\r
1026                         if (Row == null)\r
1027                                 return;\r
1028 \r
1029                         DataControlRowState rowState = Row.RowState;\r
1030                         IBindableTemplate bt;\r
1031                         \r
1032                         if ((rowState & DataControlRowState.Insert) != 0)\r
1033                                 bt = insertItemTemplate as IBindableTemplate; \r
1034                         else if ((rowState & DataControlRowState.Edit) != 0)\r
1035                                 bt = editItemTemplate as IBindableTemplate;\r
1036                         else\r
1037                                 return;\r
1038                         \r
1039                         if (bt != null) {\r
1040                                 IOrderedDictionary values = bt.ExtractValues (Row.Cells [0]);\r
1041                                 foreach (DictionaryEntry e in values) {\r
1042                                         if (includeKeys || Array.IndexOf (DataKeyNames, e.Key) == -1)\r
1043                                                 fieldValues [e.Key] = e.Value;\r
1044                                 }\r
1045                         }\r
1046                 }\r
1047                 \r
1048                 protected override HtmlTextWriterTag TagKey {\r
1049                         get {\r
1050                                 return HtmlTextWriterTag.Table;\r
1051                         }\r
1052                 }\r
1053                 \r
1054                 public sealed override void DataBind ()\r
1055                 {\r
1056                         if (CurrentMode == FormViewMode.Insert) {\r
1057                                 RequiresDataBinding = false;\r
1058                                 PerformDataBinding (new object [] { null });\r
1059                                 return;\r
1060                         }\r
1061 \r
1062                         cachedKeyProperties = null;\r
1063                         base.DataBind ();\r
1064                         \r
1065                         if (pageCount > 0) {\r
1066                                 if (CurrentMode == FormViewMode.Edit)\r
1067                                         oldEditValues = new DataKey (GetRowValues (true));\r
1068                                 FillRowDataKey (dataItem);\r
1069                                 key = new DataKey (KeyTable);\r
1070                         }\r
1071                 }\r
1072                 \r
1073                 protected internal override void PerformDataBinding (IEnumerable data)\r
1074                 {\r
1075                         base.PerformDataBinding (data);\r
1076                 }\r
1077 \r
1078                 protected internal virtual void PrepareControlHierarchy ()\r
1079                 {\r
1080                         if (table == null)\r
1081                                 return;\r
1082 \r
1083                         table.Caption = Caption;\r
1084                         table.CaptionAlign = CaptionAlign;\r
1085 \r
1086                         foreach (FormViewRow row in table.Rows) {\r
1087                                 switch (row.RowType) {\r
1088                                 case DataControlRowType.Header:\r
1089                                         if (headerStyle != null && !headerStyle.IsEmpty)\r
1090                                                 row.ControlStyle.CopyFrom (headerStyle);\r
1091                                         break;\r
1092                                 case DataControlRowType.Footer:\r
1093                                         if (footerStyle != null && !footerStyle.IsEmpty)\r
1094                                                 row.ControlStyle.CopyFrom (footerStyle);\r
1095                                         break;\r
1096                                 case DataControlRowType.Pager:\r
1097                                         if (pagerStyle != null && !pagerStyle.IsEmpty)\r
1098                                                 row.ControlStyle.CopyFrom (pagerStyle);\r
1099                                         break;\r
1100                                 case DataControlRowType.EmptyDataRow:\r
1101                                         if (emptyDataRowStyle != null && !emptyDataRowStyle.IsEmpty)\r
1102                                                 row.ControlStyle.CopyFrom (emptyDataRowStyle);\r
1103                                         break;\r
1104                                 case DataControlRowType.DataRow:\r
1105                                         if (rowStyle != null && !rowStyle.IsEmpty)\r
1106                                                 row.ControlStyle.CopyFrom (rowStyle);\r
1107                                         if ((row.RowState & (DataControlRowState.Edit | DataControlRowState.Insert)) != 0 && editRowStyle != null && !editRowStyle.IsEmpty)\r
1108                                                 row.ControlStyle.CopyFrom (editRowStyle);\r
1109                                         if ((row.RowState & DataControlRowState.Insert) != 0 && insertRowStyle != null && !insertRowStyle.IsEmpty)\r
1110                                                 row.ControlStyle.CopyFrom (insertRowStyle);\r
1111                                         break;\r
1112                                 default:\r
1113                                         break;\r
1114                                 }\r
1115                         }\r
1116                 }\r
1117                 \r
1118                 protected internal override void OnInit (EventArgs e)\r
1119                 {\r
1120                         Page.RegisterRequiresControlState (this);\r
1121                         base.OnInit (e);\r
1122                 }\r
1123                 \r
1124                 protected override bool OnBubbleEvent (object source, EventArgs e)\r
1125                 {\r
1126                         FormViewCommandEventArgs args = e as FormViewCommandEventArgs;\r
1127                         if (args != null) {\r
1128                                 OnItemCommand (args);\r
1129                                 ProcessEvent (args.CommandName, args.CommandArgument as string);\r
1130                                 return true;\r
1131                         }\r
1132                         return base.OnBubbleEvent (source, e);\r
1133                 }\r
1134                 \r
1135                 void IPostBackEventHandler.RaisePostBackEvent(string eventArgument)\r
1136                 {\r
1137                         RaisePostBackEvent (eventArgument);\r
1138                 }\r
1139 \r
1140                 protected virtual void RaisePostBackEvent (string eventArgument)\r
1141                 {\r
1142                         int i = eventArgument.IndexOf ('$');\r
1143                         if (i != -1)\r
1144                                 ProcessEvent (eventArgument.Substring (0, i), eventArgument.Substring (i + 1));\r
1145                         else\r
1146                                 ProcessEvent (eventArgument, null);\r
1147                 }\r
1148                 \r
1149                 void ProcessEvent (string eventName, string param)\r
1150                 {\r
1151                         switch (eventName)\r
1152                         {\r
1153                         case DataControlCommands.PageCommandName:\r
1154                                 int newIndex = -1;\r
1155                                 switch (param) {\r
1156                                 case DataControlCommands.FirstPageCommandArgument:\r
1157                                         newIndex = 0;\r
1158                                         break;\r
1159                                 case DataControlCommands.LastPageCommandArgument:\r
1160                                         newIndex = PageCount - 1;\r
1161                                         break;\r
1162                                 case DataControlCommands.NextPageCommandArgument:\r
1163                                         newIndex = PageIndex + 1;\r
1164                                         break;\r
1165                                 case DataControlCommands.PreviousPageCommandArgument:\r
1166                                         newIndex = PageIndex - 1;\r
1167                                         break;\r
1168                                 default:\r
1169                                         int paramIndex = 0;\r
1170                                         int.TryParse (param, out paramIndex);\r
1171                                         newIndex = paramIndex - 1;\r
1172                                         break;\r
1173                                 }\r
1174                                 ShowPage (newIndex);\r
1175                                 break;\r
1176                                         \r
1177                         case DataControlCommands.FirstPageCommandArgument:\r
1178                                 ShowPage (0);\r
1179                                 break;\r
1180 \r
1181                         case DataControlCommands.LastPageCommandArgument:\r
1182                                 ShowPage (PageCount - 1);\r
1183                                 break;\r
1184                                         \r
1185                         case DataControlCommands.NextPageCommandArgument:\r
1186                                 if (PageIndex < PageCount - 1)\r
1187                                         ShowPage (PageIndex + 1);\r
1188                                 break;\r
1189 \r
1190                         case DataControlCommands.PreviousPageCommandArgument:\r
1191                                 if (PageIndex > 0)\r
1192                                         ShowPage (PageIndex - 1);\r
1193                                 break;\r
1194                                         \r
1195                         case DataControlCommands.EditCommandName:\r
1196                                 ChangeMode (FormViewMode.Edit);\r
1197                                 break;\r
1198                                         \r
1199                         case DataControlCommands.NewCommandName:\r
1200                                 ChangeMode (FormViewMode.Insert);\r
1201                                 break;\r
1202                                         \r
1203                         case DataControlCommands.UpdateCommandName:\r
1204                                 UpdateItem (param, true);\r
1205                                 break;\r
1206                                         \r
1207                         case DataControlCommands.CancelCommandName:\r
1208                                 CancelEdit ();\r
1209                                 break;\r
1210                                         \r
1211                         case DataControlCommands.DeleteCommandName:\r
1212                                 DeleteItem ();\r
1213                                 break;\r
1214                                         \r
1215                         case DataControlCommands.InsertCommandName:\r
1216                                 InsertItem (true);\r
1217                                 break;\r
1218                         }\r
1219                 }\r
1220                 \r
1221                 void ShowPage (int index)\r
1222                 {\r
1223                         FormViewPageEventArgs args = new FormViewPageEventArgs (index);\r
1224                         OnPageIndexChanging (args);\r
1225                         if (!args.Cancel) {\r
1226                                 int newIndex = args.NewPageIndex;\r
1227                                 if (newIndex < 0 || newIndex >= PageCount)\r
1228                                         return;\r
1229                                 EndRowEdit (false);\r
1230                                 PageIndex = newIndex;\r
1231                                 OnPageIndexChanged (EventArgs.Empty);\r
1232                         }\r
1233                 }\r
1234                 \r
1235                 public void ChangeMode (FormViewMode newMode)\r
1236                 {\r
1237                         FormViewModeEventArgs args = new FormViewModeEventArgs (newMode, false);\r
1238                         OnModeChanging (args);\r
1239                         if (!args.Cancel) {\r
1240                                 CurrentMode = args.NewMode;\r
1241                                 OnModeChanged (EventArgs.Empty);\r
1242                                 RequireBinding ();\r
1243                         }\r
1244                 }\r
1245                 \r
1246                 void CancelEdit ()\r
1247                 {\r
1248                         FormViewModeEventArgs args = new FormViewModeEventArgs (FormViewMode.ReadOnly, true);\r
1249                         OnModeChanging (args);\r
1250                         if (!args.Cancel) {\r
1251                                 EndRowEdit ();\r
1252                         }\r
1253                 }\r
1254 \r
1255                 public virtual void UpdateItem (bool causesValidation)\r
1256                 {\r
1257                         UpdateItem (null, causesValidation);\r
1258                 }\r
1259                 \r
1260                 void UpdateItem (string param, bool causesValidation)\r
1261                 {\r
1262                         if (causesValidation && Page != null)\r
1263                                 Page.Validate ();\r
1264                         \r
1265                         if (currentMode != FormViewMode.Edit) throw new HttpException ("Must be in Edit mode");\r
1266 \r
1267                         currentEditOldValues = OldEditValues.Values;\r
1268                         currentEditRowKeys = DataKey.Values;\r
1269                         currentEditNewValues = GetRowValues (false);\r
1270                         \r
1271                         FormViewUpdateEventArgs args = new FormViewUpdateEventArgs (param, currentEditRowKeys, currentEditOldValues, currentEditNewValues);\r
1272                         OnItemUpdating (args);\r
1273                         if (!args.Cancel) {\r
1274                                 DataSourceView view = GetData ();\r
1275                                 if (view == null)\r
1276                                         throw new HttpException ("The DataSourceView associated to data bound control was null");\r
1277                                 if (view.CanUpdate)\r
1278                                         view.Update (currentEditRowKeys, currentEditNewValues, currentEditOldValues, new DataSourceViewOperationCallback (UpdateCallback));\r
1279                         }\r
1280                         else\r
1281                                 EndRowEdit ();\r
1282                 }\r
1283 \r
1284                 bool UpdateCallback (int recordsAffected, Exception exception)\r
1285                 {\r
1286                         FormViewUpdatedEventArgs dargs = new FormViewUpdatedEventArgs (recordsAffected, exception, currentEditRowKeys, currentEditOldValues, currentEditNewValues);\r
1287                         OnItemUpdated (dargs);\r
1288 \r
1289                         if (!dargs.KeepInEditMode)                              \r
1290                                 EndRowEdit ();\r
1291 \r
1292                         return dargs.ExceptionHandled;\r
1293                 }\r
1294 \r
1295                 public virtual void InsertItem (bool causesValidation)\r
1296                 {\r
1297                         InsertItem (null, causesValidation);\r
1298                 }\r
1299                 \r
1300                 void InsertItem (string param, bool causesValidation)\r
1301                 {\r
1302                         if (causesValidation && Page != null)\r
1303                                 Page.Validate ();\r
1304                         \r
1305                         if (currentMode != FormViewMode.Insert) throw new HttpException ("Must be in Insert mode");\r
1306                         \r
1307                         currentEditNewValues = GetRowValues (true);\r
1308                         FormViewInsertEventArgs args = new FormViewInsertEventArgs (param, currentEditNewValues);\r
1309                         OnItemInserting (args);\r
1310                         if (!args.Cancel) {\r
1311                                 DataSourceView view = GetData ();\r
1312                                 if (view == null)\r
1313                                         throw new HttpException ("The DataSourceView associated to data bound control was null");\r
1314                                 if (view.CanInsert)\r
1315                                         view.Insert (currentEditNewValues, new DataSourceViewOperationCallback (InsertCallback));\r
1316                         }\r
1317                         else\r
1318                                 EndRowEdit ();\r
1319                 }\r
1320                 \r
1321                 bool InsertCallback (int recordsAffected, Exception exception)\r
1322                 {\r
1323                         FormViewInsertedEventArgs dargs = new FormViewInsertedEventArgs (recordsAffected, exception, currentEditNewValues);\r
1324                         OnItemInserted (dargs);\r
1325 \r
1326                         if (!dargs.KeepInInsertMode)                            \r
1327                                 EndRowEdit ();\r
1328 \r
1329                         return dargs.ExceptionHandled;\r
1330                 }\r
1331 \r
1332                 public virtual void DeleteItem ()\r
1333                 {\r
1334                         currentEditRowKeys = DataKey.Values;\r
1335                         currentEditNewValues = GetRowValues (true);\r
1336                         \r
1337                         FormViewDeleteEventArgs args = new FormViewDeleteEventArgs (PageIndex, currentEditRowKeys, currentEditNewValues);\r
1338                         OnItemDeleting (args);\r
1339 \r
1340                         if (!args.Cancel) {\r
1341                                 if (PageIndex > 0 && PageIndex == PageCount - 1)\r
1342                                         PageIndex--;\r
1343                                         \r
1344                                 RequireBinding ();\r
1345                                         \r
1346                                 DataSourceView view = GetData ();\r
1347                                 if (view != null && view.CanDelete)\r
1348                                         view.Delete (currentEditRowKeys, currentEditNewValues, new DataSourceViewOperationCallback (DeleteCallback));\r
1349                                 else {\r
1350                                         FormViewDeletedEventArgs dargs = new FormViewDeletedEventArgs (0, null, currentEditRowKeys, currentEditNewValues);\r
1351                                         OnItemDeleted (dargs);\r
1352                                 }\r
1353                         }\r
1354                 }\r
1355 \r
1356                 bool DeleteCallback (int recordsAffected, Exception exception)\r
1357                 {\r
1358                         FormViewDeletedEventArgs dargs = new FormViewDeletedEventArgs (recordsAffected, exception, currentEditRowKeys, currentEditNewValues);\r
1359                         OnItemDeleted (dargs);\r
1360                         return dargs.ExceptionHandled;\r
1361                 }\r
1362                 \r
1363                 void EndRowEdit ()\r
1364                 {\r
1365                         EndRowEdit (true);\r
1366                 }\r
1367 \r
1368                 void EndRowEdit (bool switchToDefaultMode) \r
1369                 {\r
1370                         if (switchToDefaultMode)\r
1371                                 ChangeMode (DefaultMode);\r
1372                         oldEditValues = new DataKey (new OrderedDictionary ());\r
1373                         currentEditRowKeys = null;\r
1374                         currentEditOldValues = null;\r
1375                         currentEditNewValues = null;\r
1376                         RequireBinding ();\r
1377                 }\r
1378 \r
1379                 protected internal override void LoadControlState (object ob)\r
1380                 {\r
1381                         if (ob == null) return;\r
1382                         object[] state = (object[]) ob;\r
1383                         base.LoadControlState (state[0]);\r
1384                         pageIndex = (int) state[1];\r
1385                         pageCount = (int) state[2];\r
1386                         CurrentMode = (FormViewMode) state[3];\r
1387                         defaultMode = (FormViewMode) state[4];\r
1388                         dataKeyNames = (string[]) state[5];\r
1389                         if (state [6] != null)\r
1390                                 ((IStateManager) DataKey).LoadViewState (state [6]);\r
1391                         if (state [7] != null)\r
1392                                 ((IStateManager) OldEditValues).LoadViewState (state [7]);\r
1393                 }\r
1394                 \r
1395                 protected internal override object SaveControlState ()\r
1396                 {\r
1397                         object bstate = base.SaveControlState ();\r
1398                         return new object [] {\r
1399                                 bstate, \r
1400                                 pageIndex, \r
1401                                 pageCount, \r
1402                                 CurrentMode, \r
1403                                 defaultMode, \r
1404                                 dataKeyNames,\r
1405                                 (key == null ? null : ((IStateManager)key).SaveViewState()),\r
1406                                 (oldEditValues == null ? null : ((IStateManager) oldEditValues).SaveViewState ())\r
1407                         };\r
1408                 }\r
1409                 \r
1410                 protected override void TrackViewState()\r
1411                 {\r
1412                         base.TrackViewState();\r
1413                         if (pagerSettings != null) ((IStateManager)pagerSettings).TrackViewState();\r
1414                         if (footerStyle != null) ((IStateManager)footerStyle).TrackViewState();\r
1415                         if (headerStyle != null) ((IStateManager)headerStyle).TrackViewState();\r
1416                         if (pagerStyle != null) ((IStateManager)pagerStyle).TrackViewState();\r
1417                         if (rowStyle != null) ((IStateManager)rowStyle).TrackViewState();\r
1418                         if (editRowStyle != null) ((IStateManager)editRowStyle).TrackViewState();\r
1419                         if (insertRowStyle != null) ((IStateManager)insertRowStyle).TrackViewState();\r
1420                         if (emptyDataRowStyle != null) ((IStateManager)emptyDataRowStyle).TrackViewState();\r
1421                 }\r
1422 \r
1423                 protected override object SaveViewState()\r
1424                 {\r
1425                         object[] states = new object [10];\r
1426                         states[0] = base.SaveViewState();\r
1427                         states[1] = (pagerSettings == null ? null : ((IStateManager)pagerSettings).SaveViewState());\r
1428                         states[2] = (footerStyle == null ? null : ((IStateManager)footerStyle).SaveViewState());\r
1429                         states[3] = (headerStyle == null ? null : ((IStateManager)headerStyle).SaveViewState());\r
1430                         states[4] = (pagerStyle == null ? null : ((IStateManager)pagerStyle).SaveViewState());\r
1431                         states[5] = (rowStyle == null ? null : ((IStateManager)rowStyle).SaveViewState());\r
1432                         states[6] = (insertRowStyle == null ? null : ((IStateManager)insertRowStyle).SaveViewState());\r
1433                         states[7] = (editRowStyle == null ? null : ((IStateManager)editRowStyle).SaveViewState());\r
1434                         states[8] = (emptyDataRowStyle == null ? null : ((IStateManager)emptyDataRowStyle).SaveViewState());\r
1435                         \r
1436                         for (int i = states.Length - 1; i >= 0; i--) {\r
1437                                 if (states [i] != null)\r
1438                                         return states;\r
1439                         }\r
1440 \r
1441                         return null;\r
1442                 }\r
1443 \r
1444                 protected override void LoadViewState (object savedState)\r
1445                 {\r
1446                         if (savedState == null) {\r
1447                                 base.LoadViewState (null);\r
1448                                 return;\r
1449                         }\r
1450 \r
1451                         object [] states = (object []) savedState;\r
1452                         \r
1453                         base.LoadViewState (states[0]);\r
1454                         \r
1455                         if (states[1] != null) ((IStateManager)PagerSettings).LoadViewState (states[1]);\r
1456                         if (states[2] != null) ((IStateManager)FooterStyle).LoadViewState (states[2]);\r
1457                         if (states[3] != null) ((IStateManager)HeaderStyle).LoadViewState (states[3]);\r
1458                         if (states[4] != null) ((IStateManager)PagerStyle).LoadViewState (states[4]);\r
1459                         if (states[5] != null) ((IStateManager)RowStyle).LoadViewState (states[5]);\r
1460                         if (states[6] != null) ((IStateManager)InsertRowStyle).LoadViewState (states[6]);\r
1461                         if (states[7] != null) ((IStateManager)EditRowStyle).LoadViewState (states[7]);\r
1462                         if (states[8] != null) ((IStateManager)EmptyDataRowStyle).LoadViewState (states[8]);\r
1463                 }\r
1464                 \r
1465                 protected internal override void Render (HtmlTextWriter writer)\r
1466                 {\r
1467                         PrepareControlHierarchy ();\r
1468                         \r
1469                         if (table == null)\r
1470                                 return;\r
1471 \r
1472                         table.Render (writer);\r
1473                 }\r
1474 \r
1475                 PostBackOptions IPostBackContainer.GetPostBackOptions (IButtonControl control)\r
1476                 {\r
1477                         if (control == null)\r
1478                                 throw new ArgumentNullException ("control");\r
1479 \r
1480                         if (control.CausesValidation)\r
1481                                 throw new InvalidOperationException ("A button that causes validation in FormView '" + ID + "' is attempting to use the container GridView as the post back target.  The button should either turn off validation or use itself as the post back container.");\r
1482 \r
1483                         PostBackOptions options = new PostBackOptions (this);\r
1484                         options.Argument = control.CommandName + "$" + control.CommandArgument;\r
1485                         options.RequiresJavaScriptProtocol = true;\r
1486 \r
1487                         return options;\r
1488                 }\r
1489 \r
1490         }\r
1491 }\r
1492 \r
1493 #endif\r