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

   1 // Permission is hereby granted, free of charge, to any person obtaining
   2 // a copy of this software and associated documentation files (the
   3 // "Software"), to deal in the Software without restriction, including
   4 // without limitation the rights to use, copy, modify, merge, publish,
   5 // distribute, sublicense, and/or sell copies of the Software, and to
   6 // permit persons to whom the Software is furnished to do so, subject to
   7 // the following conditions:
   8 //
   9 // The above copyright notice and this permission notice shall be
  10 // included in all copies or substantial portions of the Software.
  11 //
  12 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  13 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  14 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  15 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  16 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  17 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  18 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  19 //
  20 // Copyright (c) 2004-2005 Novell, Inc.
  21 //
  22 // Authors:
  23 //      Jackson Harper (jackson@ximian.com)
  24 //
  25
  26 // COMPLETE
  27
  28 using System;
  29 using System.ComponentModel;
  30 using System.ComponentModel.Design;
  31 using System.Drawing;
  32 using System.Drawing.Imaging;
  33 using System.Runtime.InteropServices;
  34
  35 namespace System.Windows.Forms {
  36         [DefaultProperty("Image")]
  37         [Designer("System.Windows.Forms.Design.PictureBoxDesigner, " + Consts.AssemblySystem_Design)]
  38         public class PictureBox : Control {
  39
  40                 private Image image;
  41                 private PictureBoxSizeMode size_mode;
  42                 private bool redraw;
  43                 private bool recalc;
  44                 private bool allow_drop;
  45
  46                 private EventHandler frame_handler;
  47
  48                 public PictureBox ()
  49                 {
  50                         redraw = true;
  51                         recalc = true;
  52                         allow_drop = false;
  53                 }
  54
  55                 [DefaultValue(PictureBoxSizeMode.Normal)]
  56                 [Localizable(true)]
  57                 [RefreshProperties(RefreshProperties.Repaint)]
  58                 public PictureBoxSizeMode SizeMode {
  59                         get { return size_mode; }
  60                         set {
  61                                 if (size_mode == value)
  62                                         return;
  63                                 size_mode = value;
  64                                 UpdateSize ();
  65                                 Redraw (true);
  66                                 Invalidate ();
  67
  68                                 OnSizeModeChanged (EventArgs.Empty);
  69                         }
  70                 }
  71
  72                 [DefaultValue(null)]
  73                 [Localizable(true)]
  74                 public Image Image {
  75                         get { return image; }
  76                         set {
  77                                 StopAnimation ();
  78
  79                                 image = value;
  80                                 UpdateSize ();
  81                                 if (image != null && ImageAnimator.CanAnimate (image)) {
  82                                         frame_handler = new EventHandler (OnAnimateImage);
  83                                         ImageAnimator.Animate (image, frame_handler);
  84                                 }
  85                                 Redraw (true);
  86                                 Invalidate ();
  87                         }
  88                 }
  89
  90                 [DefaultValue(BorderStyle.None)]
  91                 [DispId(-504)]
  92                 public BorderStyle BorderStyle {
  93                         get { return border_style; }
  94                         set {
  95                                 border_style = value;
  96                                 Redraw (true);
  97                         }
  98                 }
  99
 100                 [Browsable(false)]
 101                 [EditorBrowsable(EditorBrowsableState.Never)]
 102                 public new bool CausesValidation {
 103                         get { return base.CausesValidation; }
 104                         set { base.CausesValidation = value; }
 105                 }
 106
 107                 [Browsable(false)]
 108                 [EditorBrowsable(EditorBrowsableState.Never)]
 109                 public new ImeMode ImeMode {
 110                         get { return base.ImeMode; }
 111                         set { base.ImeMode = value; }
 112                 }
 113
 114                 [Browsable(false)]
 115                 [EditorBrowsable(EditorBrowsableState.Never)]
 116                 public override RightToLeft RightToLeft {
 117                         get { return base.RightToLeft; }
 118                         set { base.RightToLeft = value; }
 119                 }
 120
 121                 [Browsable(false)]
 122                 [EditorBrowsable(EditorBrowsableState.Never)]
 123                 public new int TabIndex {
 124                         get { return base.TabIndex; }
 125                         set { base.TabIndex = value; }
 126                 }
 127
 128                 [Browsable(false)]
 129                 [EditorBrowsable(EditorBrowsableState.Never)]
 130                 public new bool TabStop {
 131                         get { return base.TabStop; }
 132                         set { base.TabStop = value; }
 133                 }
 134
 135                 [Bindable(false)]
 136                 [Browsable(false)]
 137                 [EditorBrowsable(EditorBrowsableState.Never)]
 138                 public override string Text {
 139                         get { return base.Text; }
 140                         set { base.Text = value; }
 141                 }
 142
 143                 protected override CreateParams CreateParams {
 144                         get {
 145                                 return base.CreateParams;
 146                         }
 147                 }
 148
 149                 protected override ImeMode DefaultImeMode {
 150                         get { return base.DefaultImeMode; }
 151                 }
 152
 153                 [Browsable(false)]
 154                 [EditorBrowsable(EditorBrowsableState.Never)]
 155                 public override Font Font {
 156                         get { return base.Font; }
 157                         set { base.Font = value; }
 158                 }
 159
 160                 [Browsable(false)]
 161                 [EditorBrowsable(EditorBrowsableState.Never)]
 162                 public override Color ForeColor {
 163                         get { return base.ForeColor; }
 164                         set { base.ForeColor = value; }
 165                 }
 166
 167                 [Browsable(false)]
 168                 [EditorBrowsable(EditorBrowsableState.Never)]
 169                 public override bool AllowDrop {
 170                         get {
 171                                 return allow_drop;
 172                         }
 173                         set {
 174                                 if (allow_drop != value) {
 175                                         allow_drop = value;
 176                                 }
 177                         }
 178                 }
 179
 180                 #region Protected Instance Methods
 181                 protected override Size DefaultSize {
 182                         get { return ThemeEngine.Current.PictureBoxDefaultSize; }
 183                 }
 184
 185                 protected override void Dispose (bool disposing)
 186                 {
 187                         if (image != null) {
 188                                 StopAnimation ();
 189                                 image.Dispose ();
 190                                 image = null;
 191                         }
 192                         base.Dispose (disposing);
 193                 }
 194
 195                 protected override void OnPaint (PaintEventArgs pe)
 196                 {
 197                         if (this.Width <= 0 || this.Height <=  0 || this.Visible == false)
 198                                 return;
 199
 200                         Draw ();
 201                         pe.Graphics.DrawImage (this.ImageBuffer, pe.ClipRectangle, pe.ClipRectangle, GraphicsUnit.Pixel);
 202                 }
 203
 204                 protected override void OnVisibleChanged (EventArgs e)
 205                 {
 206                         base.OnVisibleChanged (e);
 207                         Redraw (true);
 208                 }
 209
 210                 protected virtual void OnSizeModeChanged (EventArgs e)
 211                 {
 212                         if (SizeModeChanged != null)
 213                                 SizeModeChanged (this, e);
 214                 }
 215
 216                 protected override void OnEnabledChanged (EventArgs e)
 217                 {
 218                         base.OnEnabledChanged (e);
 219                 }
 220
 221                 protected override void OnParentChanged (EventArgs e)
 222                 {
 223                         base.OnParentChanged (e);
 224                 }
 225
 226                 protected override void OnResize (EventArgs e)
 227                 {
 228                         base.OnResize (e);
 229                         redraw = true;
 230
 231                         if (size_mode == PictureBoxSizeMode.CenterImage || size_mode == PictureBoxSizeMode.StretchImage)
 232                                 Refresh ();
 233                 }
 234
 235                 protected override void SetBoundsCore (int x, int y, int width, int height, BoundsSpecified specified)
 236                 {
 237                         if (size_mode == PictureBoxSizeMode.AutoSize && image != null) {
 238                                 width = image.Width;
 239                                 height = image.Height;
 240                         }
 241                         base.SetBoundsCore (x, y, width, height, specified);
 242                 }
 243                 #endregion      // Protected Instance Methods
 244
 245                 #region Private Methods
 246                 private void StopAnimation ()
 247                 {
 248                         if (frame_handler == null)
 249                                 return;
 250                         ImageAnimator.StopAnimate (image, frame_handler);
 251                         frame_handler = null;
 252                 }
 253
 254                 private void UpdateSize ()
 255                 {
 256                         if (image == null)
 257                                 return;
 258                         if (size_mode == PictureBoxSizeMode.AutoSize)
 259                                 ClientSize = image.Size;
 260                 }
 261
 262                 private void Redraw (bool recalc)
 263                 {
 264                         redraw = true;
 265                         this.recalc = recalc;
 266                 }
 267
 268                 private void OnAnimateImage (object sender, EventArgs e)
 269                 {
 270                         // This is called from a worker thread,BeginInvoke is used
 271                         // so the control is updated from the correct thread
 272                         BeginInvoke (new EventHandler (UpdateAnimatedImage), new object [] { this, e });
 273                 }
 274
 275                 private void UpdateAnimatedImage (object sender, EventArgs e)
 276                 {
 277                         ImageAnimator.UpdateFrames (image);
 278                         Redraw (false);
 279                         Refresh ();
 280                 }
 281
 282                 [MonoTODO ("Borders and stuff, and move into the Theme")]
 283                 private void Draw ()
 284                 {
 285                         if (redraw) {
 286                                 ThemeEngine.Current.DrawPictureBox (DeviceContext, this);
 287                         }
 288                         redraw = false;
 289                 }
 290                 #endregion      // Private Methods
 291
 292                 #region Public Instance Methods
 293                 public override string ToString() {
 294                         return base.ToString ();
 295                 }
 296                 #endregion
 297
 298                 #region Events
 299                 [Browsable(false)]
 300                 [EditorBrowsable(EditorBrowsableState.Never)]
 301                 public new event EventHandler CausesValidationChanged {
 302                         add { base.CausesValidationChanged += value; }
 303                         remove { base.CausesValidationChanged -= value; }
 304                 }
 305
 306                 [Browsable(false)]
 307                 [EditorBrowsable(EditorBrowsableState.Never)]
 308                 public new event EventHandler Enter {
 309                         add { base.Enter += value; }
 310                         remove { base.Enter -= value; }
 311                 }
 312
 313                 [Browsable(false)]
 314                 [EditorBrowsable(EditorBrowsableState.Never)]
 315                 public new event EventHandler FontChanged {
 316                         add { base.FontChanged += value; }
 317                         remove { base.FontChanged -= value; }
 318                 }
 319
 320                 [Browsable(false)]
 321                 [EditorBrowsable(EditorBrowsableState.Never)]
 322                 public new event EventHandler ForeColorChanged {
 323                         add { base.ForeColorChanged += value; }
 324                         remove { base.ForeColorChanged -= value; }
 325                 }
 326
 327                 [Browsable(false)]
 328                 [EditorBrowsable(EditorBrowsableState.Never)]
 329                 public new event EventHandler ImeModeChanged {
 330                         add { base.ImeModeChanged += value; }
 331                         remove { base.ImeModeChanged -= value; }
 332                 }
 333
 334                 [Browsable(false)]
 335                 [EditorBrowsable(EditorBrowsableState.Never)]
 336                 public new event KeyEventHandler KeyDown {
 337                         add { base.KeyDown += value; }
 338                         remove { base.KeyDown -= value; }
 339                 }
 340
 341                 [Browsable(false)]
 342                 [EditorBrowsable(EditorBrowsableState.Never)]
 343                 public new event KeyPressEventHandler KeyPress {
 344                         add { base.KeyPress += value; }
 345                         remove { base.KeyPress -= value; }
 346                 }
 347
 348                 [Browsable(false)]
 349                 [EditorBrowsable(EditorBrowsableState.Never)]
 350                 public new event KeyEventHandler KeyUp {
 351                         add { base.KeyUp += value; }
 352                         remove { base.KeyUp -= value; }
 353                 }
 354
 355                 [Browsable(false)]
 356                 [EditorBrowsable(EditorBrowsableState.Never)]
 357                 public new event EventHandler Leave {
 358                         add { base.Leave += value; }
 359                         remove { base.Leave -= value; }
 360                 }
 361
 362                 [Browsable(false)]
 363                 [EditorBrowsable(EditorBrowsableState.Never)]
 364                 public new event EventHandler RightToLeftChanged {
 365                         add { base.RightToLeftChanged += value; }
 366                         remove { base.RightToLeftChanged -= value; }
 367                 }
 368
 369                 [Browsable(false)]
 370                 [EditorBrowsable(EditorBrowsableState.Never)]
 371                 public new event EventHandler TabIndexChanged {
 372                         add { base.TabIndexChanged += value; }
 373                         remove { base.TabIndexChanged -= value; }
 374                 }
 375
 376                 [Browsable(false)]
 377                 [EditorBrowsable(EditorBrowsableState.Never)]
 378                 public new event EventHandler TabStopChanged {
 379                         add { base.TabStopChanged += value; }
 380                         remove { base.TabStopChanged -= value; }
 381                 }
 382
 383                 [Browsable(false)]
 384                 [EditorBrowsable(EditorBrowsableState.Never)]
 385                 public new event EventHandler TextChanged {
 386                         add { base.TextChanged += value; }
 387                         remove { base.TextChanged -= value; }
 388                 }
 389
 390                 public event EventHandler SizeModeChanged;
 391                 #endregion      // Events
 392
 393         }
 394 }
 395