mcs/class/Managed.Windows.Forms/System.Windows.Forms/ProgressBar.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-2006 Novell, Inc.
  21 //
  22 // Authors:
  23 //              Jordi Mas i Hernandez   jordi@ximian.com
  24 //              Peter Dennis Bartok     pbartok@novell.com
  25 //
  26 //
  27
  28 using System.Drawing;
  29 using System.ComponentModel;
  30 using System.Drawing.Imaging;
  31 using System.Drawing.Drawing2D;
  32 using System.Runtime.InteropServices;
  33
  34 namespace System.Windows.Forms
  35 {
  36         [DefaultProperty ("Value")]
  37 #if NET_2_0
  38         [DefaultBindingProperty ("Value")]
  39         [ClassInterface (ClassInterfaceType.AutoDispatch)]
  40         [ComVisible (true)]
  41 #endif
  42         public
  43 #if !NET_2_0
  44         sealed
  45 #endif
  46         class ProgressBar : Control
  47         {
  48                 #region Local Variables
  49                 private int maximum;
  50                 private int minimum;
  51                 internal int step;
  52                 internal int val;
  53                 internal DateTime start = DateTime.Now;
  54                 internal Rectangle client_area = new Rectangle ();
  55 #if NET_2_0
  56                 internal ProgressBarStyle style;
  57                 Timer marquee_timer;
  58                 bool right_to_left_layout;
  59 #endif
  60
  61 #if NET_2_0
  62                 private static readonly Color defaultForeColor = SystemColors.Highlight;
  63 #endif
  64                 #endregion      // Local Variables
  65
  66                 #region events
  67
  68 #if NET_2_0
  69                 static object RightToLeftLayoutChangedEvent = new object ();
  70 #endif
  71
  72 #if ONLY_1_1
  73                 [Browsable (false)]
  74                 [EditorBrowsable (EditorBrowsableState.Never)]
  75                 public new event EventHandler BackColorChanged {
  76                         add { base.BackColorChanged += value; }
  77                         remove { base.BackColorChanged -= value; }
  78                 }
  79 #endif
  80
  81                 [Browsable (false)]
  82                 [EditorBrowsable (EditorBrowsableState.Never)]
  83                 public new event EventHandler BackgroundImageChanged {
  84                         add { base.BackgroundImageChanged += value; }
  85                         remove { base.BackgroundImageChanged -= value; }
  86                 }
  87
  88 #if NET_2_0
  89                 [Browsable(false)]
  90                 [EditorBrowsable(EditorBrowsableState.Never)]
  91                 public new event EventHandler BackgroundImageLayoutChanged {
  92                         add     { base.BackgroundImageLayoutChanged += value; }
  93                         remove { base.BackgroundImageLayoutChanged -= value; }
  94                 }
  95 #endif
  96
  97                 [Browsable (false)]
  98                 [EditorBrowsable (EditorBrowsableState.Never)]
  99                 public new event EventHandler CausesValidationChanged {
 100                         add { base.CausesValidationChanged += value; }
 101                         remove { base.CausesValidationChanged -= value; }
 102                 }
 103
 104                 [Browsable (false)]
 105                 [EditorBrowsable (EditorBrowsableState.Never)]
 106                 public new event EventHandler DoubleClick {
 107                         add { base.DoubleClick += value; }
 108                         remove { base.DoubleClick -= value; }
 109                 }
 110
 111                 [Browsable (false)]
 112                 [EditorBrowsable (EditorBrowsableState.Never)]
 113                 public new event EventHandler Enter {
 114                         add { base.Enter += value; }
 115                         remove { base.Enter -= value; }
 116                 }
 117
 118                 [Browsable (false)]
 119                 [EditorBrowsable (EditorBrowsableState.Never)]
 120                 public new event EventHandler FontChanged {
 121                         add { base.FontChanged += value; }
 122                         remove { base.FontChanged -= value; }
 123                 }
 124
 125 #if ONLY_1_1
 126                 [Browsable (false)]
 127                 [EditorBrowsable (EditorBrowsableState.Never)]
 128                 public new event EventHandler ForeColorChanged {
 129                         add { base.ForeColorChanged += value; }
 130                         remove { base.ForeColorChanged -= value; }
 131                 }
 132 #endif
 133
 134                 [Browsable (false)]
 135                 [EditorBrowsable (EditorBrowsableState.Never)]
 136                 public new event EventHandler ImeModeChanged {
 137                         add { base.ImeModeChanged += value; }
 138                         remove { base.ImeModeChanged -= value; }
 139                 }
 140
 141                 [Browsable (false)]
 142                 [EditorBrowsable (EditorBrowsableState.Never)]
 143                 public new event KeyEventHandler KeyDown {
 144                         add { base.KeyDown += value; }
 145                         remove { base.KeyDown -= value; }
 146                 }
 147
 148                 [Browsable (false)]
 149                 [EditorBrowsable (EditorBrowsableState.Never)]
 150                 public new event KeyPressEventHandler KeyPress {
 151                         add { base.KeyPress += value; }
 152                         remove { base.KeyPress -= value; }
 153                 }
 154
 155                 [Browsable (false)]
 156                 [EditorBrowsable (EditorBrowsableState.Never)]
 157                 public new event KeyEventHandler KeyUp {
 158                         add { base.KeyUp += value; }
 159                         remove { base.KeyUp -= value; }
 160                 }
 161
 162                 [Browsable (false)]
 163                 [EditorBrowsable (EditorBrowsableState.Never)]
 164                 public new event EventHandler Leave {
 165                         add { base.Leave += value; }
 166                         remove { base.Leave -= value; }
 167                 }
 168
 169 #if NET_2_0
 170                 [EditorBrowsable(EditorBrowsableState.Never)]
 171                 [Browsable(false)]
 172                 public new event MouseEventHandler MouseDoubleClick {
 173                         add { base.MouseDoubleClick += value; }
 174                         remove { base.MouseDoubleClick -= value; }
 175                 }
 176
 177                 [Browsable(false)]
 178                 [EditorBrowsable(EditorBrowsableState.Never)]
 179                 public new event EventHandler PaddingChanged {
 180                         add { base.PaddingChanged += value; }
 181                         remove { base.PaddingChanged -= value; }
 182                 }
 183 #endif
 184
 185                 [Browsable (false)]
 186                 [EditorBrowsable (EditorBrowsableState.Never)]
 187                 public new event PaintEventHandler Paint {
 188                         add { base.Paint += value; }
 189                         remove { base.Paint -= value; }
 190                 }
 191
 192 #if ONLY_1_1
 193                 [Browsable (false)]
 194                 [EditorBrowsable (EditorBrowsableState.Never)]
 195                 public new event EventHandler RightToLeftChanged {
 196                         add { base.RightToLeftChanged += value; }
 197                         remove { base.RightToLeftChanged -= value; }
 198                 }
 199 #endif
 200 #if NET_2_0
 201                 public new event EventHandler RightToLeftLayoutChanged {
 202                         add { Events.AddHandler (RightToLeftLayoutChangedEvent, value); }
 203                         remove { Events.RemoveHandler (RightToLeftLayoutChangedEvent, value); }
 204                 }
 205 #endif
 206
 207                 [Browsable (false)]
 208                 [EditorBrowsable (EditorBrowsableState.Never)]
 209                 public new event EventHandler TabStopChanged {
 210                         add { base.TabStopChanged += value; }
 211                         remove { base.TabStopChanged -= value; }
 212                 }
 213
 214                 [Browsable (false)]
 215                 [EditorBrowsable (EditorBrowsableState.Never)]
 216                 public new event EventHandler TextChanged {
 217                         add { base.TextChanged += value; }
 218                         remove { base.TextChanged -= value; }
 219                 }
 220                 #endregion Events
 221
 222                 #region Public Constructors
 223                 public ProgressBar()
 224                 {
 225                         maximum = 100;
 226                         minimum = 0;
 227                         step = 10;
 228                         val = 0;
 229
 230                         base.Resize += new EventHandler (OnResizeTB);
 231
 232                         SetStyle (ControlStyles.UserPaint |
 233                                 ControlStyles.Selectable |
 234                                 ControlStyles.ResizeRedraw |
 235                                 ControlStyles.Opaque
 236 #if NET_2_0
 237                                 | ControlStyles.UseTextForAccessibility
 238 #endif
 239                                 , false);
 240
 241 #if NET_2_0
 242                         ForeColor = defaultForeColor;
 243 #endif
 244                 }
 245                 #endregion      // Public Constructors
 246
 247                 #region Public Instance Properties
 248
 249                 [Browsable (false)]
 250                 [EditorBrowsable (EditorBrowsableState.Never)]
 251                 public override bool AllowDrop
 252                 {
 253                         get { return base.AllowDrop; }
 254                         set {
 255                                 base.AllowDrop = value;
 256                         }
 257                 }
 258
 259 #if ONLY_1_1
 260                 // Setting this property in MS .Net 1.1 does not have any visual effect and it
 261                 // does not fire a BackColorChanged event
 262                 [Browsable (false)]
 263                 [EditorBrowsable (EditorBrowsableState.Never)]
 264                 public override Color BackColor
 265                 {
 266                         get { return base.BackColor; }
 267                         set { base.BackColor = value; }
 268                 }
 269 #endif
 270
 271                 // Setting this property in MS .Net 1.1 does not have any visual effect and it
 272                 // does not fire a BackgroundImageChanged event
 273                 [Browsable (false)]
 274                 [EditorBrowsable (EditorBrowsableState.Never)]
 275                 public override Image BackgroundImage
 276                 {
 277                         get { return base.BackgroundImage; }
 278                         set { base.BackgroundImage = value; }
 279                 }
 280
 281 #if NET_2_0
 282                 [Browsable(false)]
 283                 [EditorBrowsable(EditorBrowsableState.Never)]
 284                 public override ImageLayout BackgroundImageLayout {
 285                                 get     { return base.BackgroundImageLayout; }
 286                                 set { base.BackgroundImageLayout = value; }
 287                 }
 288 #endif
 289                 [Browsable (false)]
 290                 [EditorBrowsable (EditorBrowsableState.Never)]
 291                 public new bool CausesValidation
 292                 {
 293                         get { return base.CausesValidation; }
 294                         set { base.CausesValidation = value; }
 295                 }
 296
 297                 protected override CreateParams CreateParams
 298                 {
 299                         get { return base.CreateParams; }
 300                 }
 301
 302                 protected override ImeMode DefaultImeMode
 303                 {
 304                         get { return base.DefaultImeMode; }
 305                 }
 306
 307                 protected override Size DefaultSize
 308                 {
 309                         get { return ThemeEngine.Current.ProgressBarDefaultSize; }
 310                 }
 311
 312 #if NET_2_0
 313                 [EditorBrowsable(EditorBrowsableState.Never)]
 314                 protected override bool DoubleBuffered {
 315                                 get { return base.DoubleBuffered; }
 316                                 set { base.DoubleBuffered = value; }
 317                 }
 318 #endif
 319                 // Setting this property in MS .Net 1.1 does not have any visual effect and it
 320                 // does not fire a FontChanged event
 321                 [Browsable (false)]
 322                 [EditorBrowsable (EditorBrowsableState.Never)]
 323                 public override Font Font
 324                 {
 325                         get { return base.Font; }
 326                         set { base.Font = value; }
 327                 }
 328
 329 #if ONLY_1_1
 330                 // Setting this property in MS .Net 1.1 does not have any visual effect and it
 331                 // does not fire a FontChanged event
 332                 [Browsable (false)]
 333                 [EditorBrowsable (EditorBrowsableState.Never)]
 334                 public override Color ForeColor
 335                 {
 336                         get { return base.ForeColor; }
 337                         set { base.ForeColor = value; }
 338                 }
 339 #endif
 340
 341                 [Browsable (false)]
 342                 [EditorBrowsable (EditorBrowsableState.Never)]
 343                 public new ImeMode ImeMode
 344                 {
 345                         get { return base.ImeMode; }
 346                         set { base.ImeMode = value; }
 347                 }
 348
 349                 [RefreshProperties(RefreshProperties.Repaint)]
 350                 [DefaultValue (100)]
 351                 public int Maximum
 352                 {
 353                         get {
 354                                 return maximum;
 355                         }
 356                         set {
 357                                 if (value < 0)
 358                                         throw new ArgumentException(
 359                                                 string.Format("Value '{0}' must be greater than or equal to 0.", value ));
 360
 361                                 maximum = value;
 362                                 Refresh ();
 363                         }
 364                 }
 365
 366                 [RefreshProperties(RefreshProperties.Repaint)]
 367                 [DefaultValue (0)]
 368                 public int Minimum {
 369                         get {
 370                                 return minimum;
 371                         }
 372                         set {
 373                                 if (value < 0)
 374                                         throw new ArgumentException(
 375                                                 string.Format("Value '{0}' must be greater than or equal to 0.", value ));
 376
 377                                 minimum = value;
 378                                 Refresh ();
 379                         }
 380                 }
 381
 382 #if NET_2_0
 383                 [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
 384                 [Browsable(false)]
 385                 [EditorBrowsable(EditorBrowsableState.Never)]
 386                 public new Padding Padding {
 387                         get { return base.Padding; }
 388                         set { base.Padding = value; }
 389                 }
 390
 391                 [Localizable(true)]
 392                 [DefaultValue(false)]
 393                 [MonoTODO ("Layout is currently always from left to right")]
 394                 public virtual bool RightToLeftLayout {
 395                                 get { return right_to_left_layout;}
 396                                 set     {
 397                                         if (right_to_left_layout != value) {
 398                                                 right_to_left_layout = value;
 399                                                 OnRightToLeftLayoutChanged (EventArgs.Empty);
 400                                         }
 401                                 }
 402                 }
 403 #endif
 404
 405 #if ONLY_1_1
 406                 [Browsable (false)]
 407                 [EditorBrowsable (EditorBrowsableState.Never)]
 408                 public override RightToLeft RightToLeft
 409                 {
 410                         get { return base.RightToLeft; }
 411                         set { base.RightToLeft = value; }
 412                 }
 413 #endif
 414
 415                 [DefaultValue (10)]
 416                 public int Step
 417                 {
 418                         get { return step; }
 419                         set {
 420                                 step = value;
 421                                 Refresh ();
 422                         }
 423                 }
 424
 425 #if NET_2_0
 426                 [Browsable (true)]
 427                 [DefaultValue (ProgressBarStyle.Blocks)]
 428                 [EditorBrowsable (EditorBrowsableState.Always)]
 429                 public ProgressBarStyle Style {
 430                         get {
 431                                 return style;
 432                         }
 433
 434                         set {
 435                                 style = value;
 436
 437                                 if (style == ProgressBarStyle.Marquee) {
 438                                         if (marquee_timer == null) {
 439                                                 marquee_timer = new Timer ();
 440                                                 marquee_timer.Interval = 10;
 441                                                 marquee_timer.Tick += new EventHandler (marquee_timer_Tick);
 442                                         }
 443                                         marquee_timer.Start ();
 444                                 } else {
 445                                         if (marquee_timer != null) {
 446                                                 marquee_timer.Stop ();
 447                                         }
 448                                 }
 449                         }
 450                 }
 451
 452                 void marquee_timer_Tick (object sender, EventArgs e)
 453                 {
 454                         Invalidate ();
 455                 }
 456
 457                 int marquee_animation_speed = 100;
 458                 [DefaultValue (100)]
 459                 public int MarqueeAnimationSpeed {
 460                         get {
 461                                 return marquee_animation_speed;
 462                         }
 463
 464                         set {
 465                                 marquee_animation_speed = value;
 466                         }
 467                 }
 468 #endif
 469
 470                 [Browsable (false)]
 471                 [EditorBrowsable (EditorBrowsableState.Never)]
 472                 public new bool TabStop
 473                 {
 474                         get { return base.TabStop; }
 475                         set { base.TabStop = value; }
 476                 }
 477
 478                 [Browsable (false)]
 479                 [EditorBrowsable (EditorBrowsableState.Never)]
 480                 [Bindable(false)]
 481                 public override string Text
 482                 {
 483                         get { return base.Text; }
 484                         set { base.Text = value; }
 485                 }
 486
 487                 [Bindable(true)]
 488                 [DefaultValue (0)]
 489                 public int Value
 490                 {
 491                         get {
 492                                 return val;
 493                         }
 494                         set {
 495                                 if (value < Minimum || value > Maximum)
 496 #if NET_2_0
 497                                         throw new ArgumentOutOfRangeException ("Value", string.Format("'{0}' is not a valid value for 'Value'. 'Value' should be between 'Minimum' and 'Maximum'", value));
 498 #else
 499                                         throw new ArgumentException(string.Format("'{0}' is not a valid value for 'Value'. 'Value' should be between 'Minimum' and 'Maximum'", value));
 500 #endif
 501                                 val = value;
 502                                 Refresh ();
 503                         }
 504                 }
 505
 506
 507                 #endregion      // Protected Instance Properties
 508
 509                 #region Public Instance Methods
 510
 511                 protected override void CreateHandle ()
 512                 {
 513                         base.CreateHandle ();
 514                 }
 515
 516                 public void Increment (int value)
 517                 {
 518                         int newValue = Value + value;
 519
 520                         if (newValue < Minimum)
 521                                 newValue = Minimum;
 522
 523                         if (newValue > Maximum)
 524                                 newValue = Maximum;
 525
 526                         Value = newValue;
 527                         Refresh ();
 528                 }
 529
 530                 protected override void OnHandleCreated (EventArgs e)
 531                 {
 532                         base.OnHandleCreated (e);
 533
 534                         UpdateAreas ();
 535                 }
 536
 537 #if NET_2_0
 538                 protected override void OnBackColorChanged (EventArgs e)
 539                 {
 540                         base.OnBackColorChanged (e);
 541                 }
 542
 543                 protected override void OnForeColorChanged (EventArgs e)
 544                 {
 545                         base.OnForeColorChanged (e);
 546                 }
 547
 548                 protected override void OnHandleDestroyed (EventArgs e)
 549                 {
 550                         base.OnHandleDestroyed (e);
 551                 }
 552
 553                 [EditorBrowsable(EditorBrowsableState.Advanced)]
 554                 protected virtual void OnRightToLeftLayoutChanged(EventArgs e)
 555                 {
 556                                 EventHandler eh = (EventHandler) Events [RightToLeftLayoutChangedEvent];
 557                                 if (eh != null)
 558                                         eh (this, e);
 559                 }
 560 #endif
 561
 562                 public void PerformStep ()
 563                 {
 564                         if (Value >= Maximum)
 565                                 return;
 566
 567                         Value = Maximum < Value + Step ? Maximum : Value + Step;
 568                         Refresh ();     // FIXME - calculate delta and only expose that
 569                 }
 570
 571 #if NET_2_0
 572                 [EditorBrowsable (EditorBrowsableState.Never)]
 573                 public override void ResetForeColor ()
 574                 {
 575                         ForeColor = defaultForeColor;
 576                 }
 577 #endif
 578
 579                 public override string ToString()
 580                 {
 581                         return string.Format ("{0}, Minimum: {1}, Maximum: {2}, Value: {3}",
 582                                 GetType().FullName,
 583                                 Minimum.ToString (),
 584                                 Maximum.ToString (),
 585                                 Value.ToString () );
 586                 }
 587
 588                 #endregion      // Public Instance Methods
 589
 590                 #region Private Instance Methods
 591
 592                 private void UpdateAreas ()
 593                 {
 594                         client_area.X = client_area.Y = 2;
 595                         client_area.Width = Width - 4;
 596                         client_area.Height = Height - 4;
 597                 }
 598
 599                 private void OnResizeTB (Object o, EventArgs e)
 600                 {
 601                         if (Width <= 0 || Height <= 0)
 602                                 return;
 603
 604                         UpdateAreas ();
 605                         Invalidate();   // Invalidate the full surface, blocks will not match
 606                 }
 607
 608                 internal override void OnPaintInternal (PaintEventArgs pevent)
 609                 {
 610                         ThemeEngine.Current.DrawProgressBar (pevent.Graphics, pevent.ClipRectangle, this);
 611                 }
 612
 613                 #endregion
 614         }
 615 }