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, "System.ComponentModel.Design.IDesigner")]
  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                         SetStyle (ControlStyles.Selectable, false);
  54                         SetStyle (ControlStyles.SupportsTransparentBackColor, true);
  55                 }
  56
  57                 [DefaultValue(PictureBoxSizeMode.Normal)]
  58                 [Localizable(true)]
  59                 [RefreshProperties(RefreshProperties.Repaint)]
  60                 public PictureBoxSizeMode SizeMode {
  61                         get { return size_mode; }
  62                         set {
  63                                 if (size_mode == value)
  64                                         return;
  65                                 size_mode = value;
  66                                 UpdateSize ();
  67                                 Redraw (true);
  68                                 Invalidate ();
  69
  70                                 OnSizeModeChanged (EventArgs.Empty);
  71                         }
  72                 }
  73
  74                 [DefaultValue(null)]
  75                 [Localizable(true)]
  76                 public Image Image {
  77                         get { return image; }
  78                         set {
  79                                 StopAnimation ();
  80
  81                                 image = value;
  82                                 UpdateSize ();
  83                                 if (image != null && ImageAnimator.CanAnimate (image)) {
  84                                         frame_handler = new EventHandler (OnAnimateImage);
  85                                         ImageAnimator.Animate (image, frame_handler);
  86                                 }
  87                                 Redraw (true);
  88                                 Invalidate ();
  89                         }
  90                 }
  91
  92                 [DefaultValue(BorderStyle.None)]
  93                 [DispId(-504)]
  94                 public BorderStyle BorderStyle {
  95                         get { return InternalBorderStyle; }
  96                         set { InternalBorderStyle = value; }
  97                 }
  98
  99                 [Browsable(false)]
 100                 [EditorBrowsable(EditorBrowsableState.Never)]
 101                 public new bool CausesValidation {
 102                         get { return base.CausesValidation; }
 103                         set { base.CausesValidation = value; }
 104                 }
 105
 106                 [Browsable(false)]
 107                 [EditorBrowsable(EditorBrowsableState.Never)]
 108                 public new ImeMode ImeMode {
 109                         get { return base.ImeMode; }
 110                         set { base.ImeMode = value; }
 111                 }
 112
 113                 [Browsable(false)]
 114                 [EditorBrowsable(EditorBrowsableState.Never)]
 115                 public override RightToLeft RightToLeft {
 116                         get { return base.RightToLeft; }
 117                         set { base.RightToLeft = value; }
 118                 }
 119
 120                 [Browsable(false)]
 121                 [EditorBrowsable(EditorBrowsableState.Never)]
 122                 public new int TabIndex {
 123                         get { return base.TabIndex; }
 124                         set { base.TabIndex = value; }
 125                 }
 126
 127                 [Browsable(false)]
 128                 [EditorBrowsable(EditorBrowsableState.Never)]
 129                 public new bool TabStop {
 130                         get { return base.TabStop; }
 131                         set { base.TabStop = value; }
 132                 }
 133
 134                 [Bindable(false)]
 135                 [Browsable(false)]
 136                 [EditorBrowsable(EditorBrowsableState.Never)]
 137                 public override string Text {
 138                         get { return base.Text; }
 139                         set { base.Text = value; }
 140                 }
 141
 142                 protected override CreateParams CreateParams {
 143                         get {
 144                                 return base.CreateParams;
 145                         }
 146                 }
 147
 148                 protected override ImeMode DefaultImeMode {
 149                         get { return base.DefaultImeMode; }
 150                 }
 151
 152                 [Browsable(false)]
 153                 [EditorBrowsable(EditorBrowsableState.Never)]
 154                 public override Font Font {
 155                         get { return base.Font; }
 156                         set { base.Font = value; }
 157                 }
 158
 159                 [Browsable(false)]
 160                 [EditorBrowsable(EditorBrowsableState.Never)]
 161                 public override Color ForeColor {
 162                         get { return base.ForeColor; }
 163                         set { base.ForeColor = value; }
 164                 }
 165
 166                 [Browsable(false)]
 167                 [EditorBrowsable(EditorBrowsableState.Never)]
 168                 public override bool AllowDrop {
 169                         get {
 170                                 return allow_drop;
 171                         }
 172                         set {
 173                                 if (allow_drop != value) {
 174                                         allow_drop = value;
 175                                 }
 176                         }
 177                 }
 178
 179                 #region Protected Instance Methods
 180                 protected override Size DefaultSize {
 181                         get { return ThemeEngine.Current.PictureBoxDefaultSize; }
 182                 }
 183
 184                 protected override void Dispose (bool disposing)
 185                 {
 186                         if (image != null) {
 187                                 StopAnimation ();
 188                                 image = null;
 189                         }
 190                         base.Dispose (disposing);
 191                 }
 192
 193                 protected override void OnPaint (PaintEventArgs pe)
 194                 {
 195                         ThemeEngine.Current.DrawPictureBox (pe.Graphics, pe.ClipRectangle, this);
 196                         base.OnPaint (pe);
 197                 }
 198
 199                 protected override void OnVisibleChanged (EventArgs e)
 200                 {
 201                         base.OnVisibleChanged (e);
 202                         Redraw (true);
 203                 }
 204
 205                 protected virtual void OnSizeModeChanged (EventArgs e)
 206                 {
 207                         if (SizeModeChanged != null)
 208                                 SizeModeChanged (this, e);
 209                 }
 210
 211                 protected override void OnEnabledChanged (EventArgs e)
 212                 {
 213                         base.OnEnabledChanged (e);
 214                 }
 215
 216                 protected override void OnParentChanged (EventArgs e)
 217                 {
 218                         base.OnParentChanged (e);
 219                 }
 220
 221                 protected override void OnResize (EventArgs e)
 222                 {
 223                         base.OnResize (e);
 224                         redraw = true;
 225
 226                         if (size_mode == PictureBoxSizeMode.CenterImage || size_mode == PictureBoxSizeMode.StretchImage)
 227                                 Refresh ();
 228                 }
 229
 230                 protected override void SetBoundsCore (int x, int y, int width, int height, BoundsSpecified specified)
 231                 {
 232                         if (size_mode == PictureBoxSizeMode.AutoSize && image != null) {
 233                                 width = image.Width;
 234                                 height = image.Height;
 235                         }
 236                         base.SetBoundsCore (x, y, width, height, specified);
 237                 }
 238                 #endregion      // Protected Instance Methods
 239
 240                 #region Private Methods
 241                 private void StopAnimation ()
 242                 {
 243                         if (frame_handler == null)
 244                                 return;
 245                         ImageAnimator.StopAnimate (image, frame_handler);
 246                         frame_handler = null;
 247                 }
 248
 249                 private void UpdateSize ()
 250                 {
 251                         if (image == null)
 252                                 return;
 253                         if (size_mode == PictureBoxSizeMode.AutoSize)
 254                                 ClientSize = image.Size;
 255                 }
 256
 257                 private void Redraw (bool recalc)
 258                 {
 259                         redraw = true;
 260                         this.recalc = recalc;
 261                 }
 262
 263                 private void OnAnimateImage (object sender, EventArgs e)
 264                 {
 265                         // This is called from a worker thread,BeginInvoke is used
 266                         // so the control is updated from the correct thread
 267                         BeginInvoke (new EventHandler (UpdateAnimatedImage), new object [] { this, e });
 268                 }
 269
 270                 private void UpdateAnimatedImage (object sender, EventArgs e)
 271                 {
 272                         ImageAnimator.UpdateFrames (image);
 273                         Redraw (false);
 274                         Refresh ();
 275                 }
 276
 277                 #endregion      // Private Methods
 278
 279                 #region Public Instance Methods
 280                 public override string ToString() {
 281                         return base.ToString ();
 282                 }
 283                 #endregion
 284
 285                 #region Events
 286                 [Browsable(false)]
 287                 [EditorBrowsable(EditorBrowsableState.Never)]
 288                 public new event EventHandler CausesValidationChanged {
 289                         add { base.CausesValidationChanged += value; }
 290                         remove { base.CausesValidationChanged -= value; }
 291                 }
 292
 293                 [Browsable(false)]
 294                 [EditorBrowsable(EditorBrowsableState.Never)]
 295                 public new event EventHandler Enter {
 296                         add { base.Enter += value; }
 297                         remove { base.Enter -= value; }
 298                 }
 299
 300                 [Browsable(false)]
 301                 [EditorBrowsable(EditorBrowsableState.Never)]
 302                 public new event EventHandler FontChanged {
 303                         add { base.FontChanged += value; }
 304                         remove { base.FontChanged -= value; }
 305                 }
 306
 307                 [Browsable(false)]
 308                 [EditorBrowsable(EditorBrowsableState.Never)]
 309                 public new event EventHandler ForeColorChanged {
 310                         add { base.ForeColorChanged += value; }
 311                         remove { base.ForeColorChanged -= value; }
 312                 }
 313
 314                 [Browsable(false)]
 315                 [EditorBrowsable(EditorBrowsableState.Never)]
 316                 public new event EventHandler ImeModeChanged {
 317                         add { base.ImeModeChanged += value; }
 318                         remove { base.ImeModeChanged -= value; }
 319                 }
 320
 321                 [Browsable(false)]
 322                 [EditorBrowsable(EditorBrowsableState.Never)]
 323                 public new event KeyEventHandler KeyDown {
 324                         add { base.KeyDown += value; }
 325                         remove { base.KeyDown -= value; }
 326                 }
 327
 328                 [Browsable(false)]
 329                 [EditorBrowsable(EditorBrowsableState.Never)]
 330                 public new event KeyPressEventHandler KeyPress {
 331                         add { base.KeyPress += value; }
 332                         remove { base.KeyPress -= value; }
 333                 }
 334
 335                 [Browsable(false)]
 336                 [EditorBrowsable(EditorBrowsableState.Never)]
 337                 public new event KeyEventHandler KeyUp {
 338                         add { base.KeyUp += value; }
 339                         remove { base.KeyUp -= value; }
 340                 }
 341
 342                 [Browsable(false)]
 343                 [EditorBrowsable(EditorBrowsableState.Never)]
 344                 public new event EventHandler Leave {
 345                         add { base.Leave += value; }
 346                         remove { base.Leave -= value; }
 347                 }
 348
 349                 [Browsable(false)]
 350                 [EditorBrowsable(EditorBrowsableState.Never)]
 351                 public new event EventHandler RightToLeftChanged {
 352                         add { base.RightToLeftChanged += value; }
 353                         remove { base.RightToLeftChanged -= value; }
 354                 }
 355
 356                 [Browsable(false)]
 357                 [EditorBrowsable(EditorBrowsableState.Never)]
 358                 public new event EventHandler TabIndexChanged {
 359                         add { base.TabIndexChanged += value; }
 360                         remove { base.TabIndexChanged -= value; }
 361                 }
 362
 363                 [Browsable(false)]
 364                 [EditorBrowsable(EditorBrowsableState.Never)]
 365                 public new event EventHandler TabStopChanged {
 366                         add { base.TabStopChanged += value; }
 367                         remove { base.TabStopChanged -= value; }
 368                 }
 369
 370                 [Browsable(false)]
 371                 [EditorBrowsable(EditorBrowsableState.Never)]
 372                 public new event EventHandler TextChanged {
 373                         add { base.TextChanged += value; }
 374                         remove { base.TextChanged -= value; }
 375                 }
 376
 377                 public event EventHandler SizeModeChanged;
 378                 #endregion      // Events
 379
 380         }
 381 }
 382