mcs/class/Managed.Windows.Forms/System.Windows.Forms/HtmlWindow.cs

   1 // Permission is hereby granted, free of charge, to any person obtaining\r
   2 // a copy of this software and associated documentation files (the\r
   3 // "Software"), to deal in the Software without restriction, including\r
   4 // without limitation the rights to use, copy, modify, merge, publish,\r
   5 // distribute, sublicense, and/or sell copies of the Software, and to\r
   6 // permit persons to whom the Software is furnished to do so, subject to\r
   7 // the following conditions:\r
   8 // \r
   9 // The above copyright notice and this permission notice shall be\r
  10 // included in all copies or substantial portions of the Software.\r
  11 // \r
  12 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
  13 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
  14 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\r
  15 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE\r
  16 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION\r
  17 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\r
  18 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
  19 //\r
  20 // Copyright (c) 2007, 2008 Novell, Inc.\r
  21 //\r
  22 // Authors:\r
  23 //      Andreia Gaita (avidigal@novell.com)\r
  24 //
  25
  26 #if NET_2_0
  27
  28 using System;
  29 using System.Drawing;
  30 using System.ComponentModel;\r
  31 using Mono.WebBrowser.DOM;
  32
  33 namespace System.Windows.Forms
  34 {
  35         public sealed class HtmlWindow
  36         {
  37                 private EventHandlerList event_handlers;
  38                 private IWindow window;
  39                 private Mono.WebBrowser.IWebBrowser webHost;
  40                 \r
  41                 internal HtmlWindow (Mono.WebBrowser.IWebBrowser webHost, IWindow iWindow)\r
  42                 {\r
  43                         this.window = iWindow;
  44                         this.webHost = webHost;
  45                         event_handlers = null;
  46                         this.window.Load += new EventHandler (OnLoad);\r
  47                         this.window.Unload += new EventHandler (OnUnload);\r
  48                 }\r
  49
  50                 private EventHandlerList Events {
  51                         get {
  52                                 // Note: space vs. time tradeoff
  53                                 // We create the object here if it's never be accessed before.  This potentially
  54                                 // saves space. However, we must check each time the propery is accessed to
  55                                 // determine whether we need to create the object, which increases overhead.
  56                                 // We could put the creation in the contructor, but that would waste space
  57                                 // if it were never used.  However, accessing this property would be faster.
  58                                 if (null == event_handlers)
  59                                         event_handlers = new EventHandlerList();
  60
  61                                 return event_handlers;
  62                         }
  63                 }
  64
  65 #region Properties
  66                 public HtmlDocument Document {
  67                         get { return new HtmlDocument (webHost, this.window.Document); }
  68                 }
  69
  70                 public object DomWindow {
  71                         get { throw new NotImplementedException (); }
  72                 }
  73
  74                 public HtmlWindowCollection Frames {
  75                         get { return new HtmlWindowCollection (webHost, this.window.Frames); }
  76                 }
  77
  78                 public HtmlHistory History {
  79                         get { throw new NotImplementedException (); }
  80                 }
  81
  82                 [MonoTODO ("Windows are always open")]
  83                 public bool IsClosed {
  84                         get { return false; }
  85                 }
  86
  87                 public string Name {
  88                         get { return this.window.Name; }
  89                         set { this.window.Name = value; }
  90                 }
  91
  92                 [MonoTODO ("Separate windows are not supported yet")]
  93                 public HtmlWindow Opener {
  94                         get { return null; }
  95                 }
  96
  97                 public HtmlWindow Parent {
  98                         get { return new HtmlWindow (webHost, this.window.Parent); }
  99                 }
 100
 101                 public Point Position {
 102                         get { throw new NotImplementedException (); }
 103                 }
 104
 105                 public Size Size {
 106                         get { throw new NotImplementedException (); }
 107                         set { throw new NotImplementedException (); }
 108                 }
 109
 110                 public string StatusBarText {
 111                         get { return this.window.StatusText; }
 112                         set { throw new NotImplementedException (); }
 113                 }
 114
 115                 public HtmlElement WindowFrameElement {
 116                         get { throw new NotImplementedException (); }
 117                 }
 118
 119                 public Uri Url {
 120                         get { return this.Document.Url; }
 121                 }\r
 122 #endregion
 123
 124 #region Methods
 125                 public void Alert (string message)
 126                 {
 127                         MessageBox.Show ("Alert", message);
 128                 }
 129
 130                 public bool Confirm (string message)
 131                 {
 132                         DialogResult ret = MessageBox.Show (message, "Confirm", MessageBoxButtons.OKCancel, MessageBoxIcon.Exclamation);\r
 133                         return ret == DialogResult.OK;\r
 134                 }
 135
 136                 public string Prompt (string message, string defaultValue)
 137                 {
 138                         WebBrowserDialogs.Prompt prompt = new WebBrowserDialogs.Prompt ("Prompt", message, defaultValue);\r
 139                         DialogResult ret = prompt.Show ();\r
 140                         return prompt.Text;\r
 141                 }
 142
 143                 public void Navigate (string urlString)\r
 144                 {\r
 145                         webHost.Navigation.Go (urlString);\r
 146                 }\r
 147 \r
 148                 public void Navigate (Uri url)\r
 149                 {\r
 150                         webHost.Navigation.Go (url.ToString ());\r
 151                 }
 152
 153                 public void ScrollTo (Point point)
 154                 {
 155                         ScrollTo (point.X, point.Y);
 156                 }\r
 157
 158                 public void ScrollTo (int x, int y)
 159                 {
 160                         this.window.ScrollTo (x, y);
 161                 }\r
 162
 163                 [MonoTODO("Blank opens in current window at the moment. Missing media and search implementations. No options implemented")]
 164                 public HtmlWindow Open (Uri url, string target, string options, bool replace)
 165                 {
 166                         return Open (url.ToString(), target, options, replace);
 167                 }
 168
 169                 [MonoTODO("Blank opens in current window at the moment. Missing media and search implementations. No options implemented")]
 170                 public HtmlWindow Open (string url, string target, string options, bool replace)
 171                 {
 172                         switch (target) {
 173                                 case "_blank":
 174                                         this.window.Open (url);
 175                                 break;
 176                                 case "_media":
 177                                 break;
 178                                 case "_parent":
 179                                         this.window.Parent.Open (url);
 180                                 break;
 181                                 case "_search":
 182                                 break;
 183                                 case "_self":
 184                                         this.window.Open (url);
 185                                 break;
 186                                 case "_top":
 187                                         this.window.Top.Open (url);
 188                                 break;
 189                         }
 190                         return this;
 191                 }
 192
 193                 [MonoTODO("Opens in current window at the moment.")]
 194                 public HtmlWindow OpenNew (string url, string options)
 195                 {
 196                         return Open (url, "_blank", options, false);
 197                 }
 198
 199                 [MonoTODO("Opens in current window at the moment.")]
 200                 public HtmlWindow OpenNew (Uri url, string options)
 201                 {
 202                         return OpenNew (url.ToString (), options);
 203                 }
 204
 205                 public void AttachEventHandler (string name, EventHandler e)
 206                 {
 207                         throw new NotImplementedException ();
 208                 }
 209
 210                 public void Close ()
 211                 {
 212                         throw new NotImplementedException ();
 213                 }
 214
 215                 public void DetachEventHandler (string name, EventHandler e)
 216                 {
 217                         throw new NotImplementedException ();
 218                 }
 219
 220                 public void Focus ()
 221                 {
 222                         throw new NotImplementedException ();
 223                 }
 224
 225                 public void MoveTo (Point position)
 226                 {
 227                         throw new NotImplementedException ();
 228                 }
 229
 230                 public void MoveTo (int x, int y)
 231                 {
 232                         throw new NotImplementedException ();
 233                 }
 234
 235                 public void RemoveFocus ()
 236                 {
 237                         throw new NotImplementedException ();
 238                 }
 239
 240                 public void ResizeTo (Size size)
 241                 {
 242                         throw new NotImplementedException ();
 243                 }
 244
 245                 public void ResizeTo (int width, int height)
 246                 {
 247                         throw new NotImplementedException ();
 248                 }
 249
 250 #endregion
 251
 252 #region Events
 253                 static object ErrorEvent = new object ();\r
 254                 public event HtmlElementErrorEventHandler Error\r
 255                 {\r
 256                         add { Events.AddHandler (ErrorEvent, value); }\r
 257                         remove { Events.RemoveHandler (ErrorEvent, value); }\r
 258                 }\r
 259
 260                 internal void OnError (object sender, EventArgs ev)
 261                 {
 262                         HtmlElementErrorEventHandler eh = (HtmlElementErrorEventHandler) (Events[ErrorEvent]);\r
 263                         if (eh != null) {\r
 264                                 HtmlElementErrorEventArgs e = new HtmlElementErrorEventArgs (String.Empty, 0, null);\r
 265                                 eh (this, e);\r
 266                         }
 267                 }\r
 268
 269                 static object GotFocusEvent = new object ();\r
 270                 public event HtmlElementEventHandler GotFocus\r
 271                 {\r
 272                         add { Events.AddHandler (GotFocusEvent, value); }\r
 273                         remove { Events.RemoveHandler (GotFocusEvent, value); }\r
 274                 }\r
 275
 276                 internal void OnGotFocus (object sender, EventArgs ev)
 277                 {
 278                         HtmlElementEventHandler eh = (HtmlElementEventHandler) (Events[GotFocusEvent]);\r
 279                         if (eh != null) {\r
 280                                 HtmlElementEventArgs e = new HtmlElementEventArgs ();\r
 281                                 eh (this, e);\r
 282                         }
 283                 }\r
 284
 285                 static object LostFocusEvent = new object ();\r
 286                 public event HtmlElementEventHandler LostFocus\r
 287                 {\r
 288                         add { Events.AddHandler (LostFocusEvent, value); }\r
 289                         remove { Events.RemoveHandler (LostFocusEvent, value); }\r
 290                 }\r
 291
 292                 internal void OnLostFocus (object sender, EventArgs ev)
 293                 {
 294                         HtmlElementEventHandler eh = (HtmlElementEventHandler) (Events[LostFocusEvent]);\r
 295                         if (eh != null) {\r
 296                                 HtmlElementEventArgs e = new HtmlElementEventArgs ();\r
 297                                 eh (this, e);\r
 298                         }
 299                 }\r
 300
 301                 static object LoadEvent = new object ();\r
 302                 public event HtmlElementEventHandler Load\r
 303                 {\r
 304                         add { Events.AddHandler (LoadEvent, value); }\r
 305                         remove { Events.RemoveHandler (LoadEvent, value); }\r
 306                 }\r
 307
 308                 internal void OnLoad (object sender, EventArgs ev)
 309                 {
 310                         HtmlElementEventHandler eh = (HtmlElementEventHandler) (Events[LoadEvent]);\r
 311                         if (eh != null) {\r
 312                                 HtmlElementEventArgs e = new HtmlElementEventArgs ();\r
 313                                 eh (this, e);\r
 314                         }
 315                 }\r
 316
 317                 static object UnloadEvent = new object ();\r
 318                 public event HtmlElementEventHandler Unload\r
 319                 {\r
 320                         add { Events.AddHandler (UnloadEvent, value); }\r
 321                         remove { Events.RemoveHandler (UnloadEvent, value); }\r
 322                 }\r
 323
 324                 internal void OnUnload (object sender, EventArgs ev)
 325                 {
 326                         HtmlElementEventHandler eh = (HtmlElementEventHandler) (Events[UnloadEvent]);\r
 327                         if (eh != null) {\r
 328                                 HtmlElementEventArgs e = new HtmlElementEventArgs ();\r
 329                                 eh (this, e);\r
 330                         }
 331                 }\r
 332
 333                 static object ScrollEvent = new object ();\r
 334                 public event HtmlElementEventHandler Scroll\r
 335                 {\r
 336                         add { Events.AddHandler (ScrollEvent, value); }\r
 337                         remove { Events.RemoveHandler (ScrollEvent, value); }\r
 338                 }\r
 339
 340                 internal void OnScroll (object sender, EventArgs ev)
 341                 {
 342                         HtmlElementEventHandler eh = (HtmlElementEventHandler) (Events[ScrollEvent]);\r
 343                         if (eh != null) {\r
 344                                 HtmlElementEventArgs e = new HtmlElementEventArgs ();\r
 345                                 eh (this, e);\r
 346                         }
 347                 }\r
 348
 349                 static object ResizeEvent = new object ();\r
 350                 public event HtmlElementEventHandler Resize\r
 351                 {\r
 352                         add { Events.AddHandler (ResizeEvent, value); }\r
 353                         remove { Events.RemoveHandler (ResizeEvent, value); }\r
 354                 }\r
 355
 356                 internal void OnResize (object sender, EventArgs ev)
 357                 {
 358                         HtmlElementEventHandler eh = (HtmlElementEventHandler) (Events[ResizeEvent]);\r
 359                         if (eh != null) {\r
 360                                 HtmlElementEventArgs e = new HtmlElementEventArgs ();\r
 361                                 eh (this, e);\r
 362                         }
 363                 }\r
 364
 365 #endregion
 366
 367
 368 #region Standard stuff
 369                 public override int GetHashCode () \r
 370                 { \r
 371                         return window.GetHashCode (); \r
 372                 }\r
 373
 374                 public override bool Equals (object obj) {
 375                         return this == (HtmlWindow) obj;
 376                 }
 377
 378                 public static bool operator ==(HtmlWindow left, HtmlWindow right) {
 379                         if ((object)left == (object)right) {
 380                                 return true;
 381                         }
 382
 383                         if ((object)left == null || (object)right == null) {
 384                                 return false;
 385                         }
 386
 387                         return left.Equals (right);
 388                 }
 389
 390                 public static bool operator !=(HtmlWindow left, HtmlWindow right) {
 391                         return !(left == right);
 392                 }
 393 #endregion
 394         }
 395 }
 396
 397 #endif