mcs/class/referencesource/System.Web.DataVisualization/Common/Utilities/ElementPosition.cs

   1 //-------------------------------------------------------------
   2 // <copyright company=’Microsoft Corporation’>
   3 //   Copyright © Microsoft Corporation. All Rights Reserved.
   4 // </copyright>
   5 //-------------------------------------------------------------
   6 // @owner=alexgor, deliant
   7 //=================================================================
   8 //  File:               ElementPosition.cs
   9 //
  10 //  Namespace:  System.Web.UI.WebControls[Windows.Forms].Charting
  11 //
  12 //      Classes:        ElementPosition
  13 //
  14 //  Purpose:    Class is used to store relative position of the chart
  15 //                              elements like Legend, Title and others. It uses
  16 //              relative coordinate system where top left corner is
  17 //              0,0 and bottom right is 100,100.
  18 //
  19 //              If Auto property is set to true, all position properties
  20 //              (X,Y,Width and Height) are ignored and they automatically
  21 //              calculated during chart rendering.
  22 //
  23 //              Note that setting any of the position properties will
  24 //              automatically set Auto property to false.
  25 //
  26 //      Reviewed:       AG - August 7, 2002
  27 //              AG - Microsoft 5, 2007
  28 //
  29 //===================================================================
  30
  31
  32 #region Used Namespaces
  33
  34 using System;
  35 using System.Collections;
  36 using System.Collections.Specialized;
  37 using System.ComponentModel;
  38 using System.ComponentModel.Design;
  39 using System.Data;
  40 using System.Drawing;
  41 using System.Drawing.Design;
  42 using System.Drawing.Drawing2D;
  43 using System.Diagnostics.CodeAnalysis;
  44 using System.Globalization;
  45
  46 #if Microsoft_CONTROL
  47         using System.Windows.Forms.DataVisualization.Charting;
  48         using System.Windows.Forms.DataVisualization.Charting.Data;
  49         using System.Windows.Forms.DataVisualization.Charting.ChartTypes;
  50         using System.Windows.Forms.DataVisualization.Charting.Utilities;
  51         using System.Windows.Forms.DataVisualization.Charting.Borders3D;
  52 #else
  53         using System.Web;
  54         using System.Web.UI;
  55         using System.Web.UI.DataVisualization.Charting;
  56         using System.Web.UI.DataVisualization.Charting.Data;
  57 #endif
  58
  59
  60 #endregion
  61
  62 #if Microsoft_CONTROL
  63         namespace System.Windows.Forms.DataVisualization.Charting
  64 #else
  65 namespace System.Web.UI.DataVisualization.Charting
  66
  67 #endif
  68 {
  69         /// <summary>
  70     /// ElementPosition is the base class for many chart visual
  71     /// elements like Legend, Title and ChartArea. It provides
  72     /// the position of the chart element in relative coordinates,
  73     /// from (0,0) to (100,100).
  74         /// </summary>
  75         [
  76                 SRDescription("DescriptionAttributeElementPosition_ElementPosition"),
  77                 DefaultProperty("Data"),
  78         ]
  79 #if ASPPERM_35
  80         [AspNetHostingPermission(System.Security.Permissions.SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal)]
  81     [AspNetHostingPermission(System.Security.Permissions.SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
  82 #endif
  83     public class ElementPosition : ChartElement
  84         {
  85                 #region Fields
  86
  87                 // Private data members, which store properties values
  88                 private         float   _x = 0;
  89                 private         float   _y = 0;
  90                 private         float   _width = 0;
  91                 private         float   _height = 0;
  92                 internal        bool    _auto = true;
  93
  94                 // Indicates the auto position of all areas must be reset
  95                 internal        bool                    resetAreaAutoPosition = false;
  96
  97                 #endregion
  98
  99                 #region Constructors
 100
 101                 /// <summary>
 102                 /// ElementPosition default constructor
 103                 /// </summary>
 104                 public ElementPosition()
 105                 {
 106                 }
 107
 108         /// <summary>
 109         /// ElementPosition default constructor
 110         /// </summary>
 111         internal ElementPosition(IChartElement parent)
 112             : base(parent)
 113         {
 114         }
 115
 116
 117                 /// <summary>
 118         /// ElementPosition constructor.
 119                 /// </summary>
 120                 /// <param name="x">X position.</param>
 121                 /// <param name="y">Y position.</param>
 122                 /// <param name="width">Width.</param>
 123                 /// <param name="height">Height.</param>
 124         [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly",
 125             Justification = "X and Y are cartesian coordinates and well understood")]
 126                 public ElementPosition(float x, float y, float width, float height)
 127                 {
 128                         this._auto = false;
 129                         this._x = x;
 130                         this._y = y;
 131                         this._width = width;
 132                         this._height = height;
 133                 }
 134
 135                 #endregion
 136
 137                 #region Methods
 138
 139                 /// <summary>
 140                 /// Asks the user at design-time if he wants to change the Auto position
 141                 /// of all areas at the same time.
 142                 /// </summary>
 143                 /// <param name="autoValue">Value to be set for the Auto property.</param>
 144                 private void ResetAllAreasAutoPosition(bool autoValue)
 145                 {
 146                         if(resetAreaAutoPosition)
 147                         {
 148                                 // Proceed only if at design time
 149                                 if(Chart != null && Chart.IsDesignMode() && !Chart.serializing && Chart.Site != null)
 150                                 {
 151                                         // Check if there is more than one area and Auto position set to the same value
 152                                         if(Chart.ChartAreas.Count > 1)
 153                                         {
 154                                                 bool    firstAutoValue = Chart.ChartAreas[0].Position.Auto;
 155                                                 bool    sameAutoValue = true;
 156                                                 foreach(ChartArea area in Chart.ChartAreas)
 157                                                 {
 158                                                         if(area.Position.Auto != firstAutoValue)
 159                                                         {
 160                                                                 sameAutoValue = false;
 161                                                                 break;
 162                                                         }
 163                                                 }
 164
 165                                                 // Proceed only all Auto values are the same
 166                                                 if(sameAutoValue)
 167                                                 {
 168                             string message = SR.MessageChangingChartAreaPositionProperty;
 169                             if (autoValue)
 170                             {
 171                                 message += SR.MessageChangingChartAreaPositionConfirmAutomatic;
 172                             }
 173                             else
 174                             {
 175                                 message += SR.MessageChangingChartAreaPositionConfirmCustom;
 176                             }
 177
 178
 179                             IDesignerMessageBoxDialog confirm = Chart.Site.GetService(typeof(IDesignerMessageBoxDialog)) as IDesignerMessageBoxDialog;
 180                             if (confirm != null && confirm.ShowQuestion(message))
 181                             {
 182                                 foreach (ChartArea area in Chart.ChartAreas)
 183                                 {
 184                                     if (autoValue)
 185                                     {
 186                                         this.SetPositionNoAuto(0f, 0f, 0f, 0f);
 187                                     }
 188                                     area.Position._auto = autoValue;
 189                                 }
 190
 191                             }
 192                                                 }
 193                                         }
 194                                 }
 195                         }
 196                 }
 197
 198                 /// <summary>
 199                 /// Convert element position into RectangleF
 200                 /// </summary>
 201                 /// <returns>RectangleF structure.</returns>
 202                 public RectangleF ToRectangleF()
 203                 {
 204                         return new RectangleF(_x, _y, _width, _height);
 205                 }
 206
 207                 /// <summary>
 208         /// Initializes ElementPosition from RectangleF
 209                 /// </summary>
 210         /// <param name="rect">RectangleF structure.</param>
 211                 public void FromRectangleF(RectangleF rect)
 212                 {
 213             if (rect == null)
 214                 throw new ArgumentNullException("rect");
 215
 216                         this._x = rect.X;
 217                         this._y = rect.Y;
 218                         this._width = rect.Width;
 219                         this._height = rect.Height;
 220                         this._auto = false;
 221                 }
 222
 223                 /// <summary>
 224         /// Gets the size of the ElementPosition object.
 225                 /// </summary>
 226         /// <returns>The size of the ElementPosition object.</returns>
 227                 [Browsable(false)]
 228         [Utilities.SerializationVisibility(Utilities.SerializationVisibility.Hidden)]
 229         public SizeF Size
 230                 {
 231             get { return new SizeF(this._width, this._height); }
 232                 }
 233
 234                 /// <summary>
 235                 /// Gets the bottom position in relative coordinates.
 236                 /// </summary>
 237                 /// <returns>Bottom position.</returns>
 238         [Browsable(false)]
 239         [Utilities.SerializationVisibility(Utilities.SerializationVisibility.Hidden)]
 240         public float Bottom
 241                 {
 242             get { return this._y + this._height; }
 243                 }
 244
 245                 /// <summary>
 246                 /// Gets the right position in relative coordinates.
 247                 /// </summary>
 248                 /// <returns>Right position.</returns>
 249         [Browsable(false)]
 250         [Utilities.SerializationVisibility(Utilities.SerializationVisibility.Hidden)]
 251         public float Right
 252                 {
 253                         get{ return this._x + this._width; }
 254                 }
 255
 256         /// <summary>
 257         /// Determines whether the specified Object is equal to the current Object.
 258         /// </summary>
 259         /// <param name="obj">The Object to compare with the current Object.</param>
 260         /// <returns>true if the specified Object is equal to the current Object; otherwise, false.</returns>
 261                 internal override bool EqualsInternal(object obj)
 262                 {
 263             ElementPosition pos = obj as ElementPosition;
 264                         if(pos != null)
 265                         {
 266                                 if(this._auto == true && this._auto == pos._auto)
 267                                 {
 268                                         return true;
 269                                 }
 270                                 else if(this._x == pos._x && this._y == pos._y &&
 271                                                 this._width == pos._width && this._height == pos._height)
 272                                 {
 273                                         return true;
 274                                 }
 275
 276                         }
 277             return false;
 278                 }
 279
 280                 /// <summary>
 281                 /// Returns a string that represents the element position data.
 282                 /// </summary>
 283                 /// <returns>Element position data as a string.</returns>
 284                 internal override string ToStringInternal()
 285                 {
 286             string posString = Constants.AutoValue;
 287                         if(!this._auto)
 288                         {
 289                                 posString =
 290                                         this._x.ToString(System.Globalization.CultureInfo.CurrentCulture)+", "+
 291                                         this._y.ToString(System.Globalization.CultureInfo.CurrentCulture)+", "+
 292                                         this._width.ToString(System.Globalization.CultureInfo.CurrentCulture)+", "+
 293                                         this._height.ToString(System.Globalization.CultureInfo.CurrentCulture);
 294                         }
 295                         return posString;
 296                 }
 297
 298                 /// <summary>
 299                 /// Set the element position without modifying the "Auto" property
 300                 /// </summary>
 301                 /// <param name="x">X position.</param>
 302                 /// <param name="y">Y position.</param>
 303                 /// <param name="width">Width.</param>
 304                 /// <param name="height">Height.</param>
 305                 internal void SetPositionNoAuto(float x, float y, float width, float height)
 306                 {
 307                         bool oldValue = this._auto;
 308                         this._x = x;
 309                         this._y = y;
 310                         this._width = width;
 311                         this._height = height;
 312                         this._auto = oldValue;
 313                 }
 314
 315                 #endregion
 316
 317                 #region Element Position properties
 318
 319                 /// <summary>
 320                 /// X position of element.
 321                 /// </summary>
 322                 [
 323                 SRCategory("CategoryAttributeMisc"),
 324                 Bindable(true),
 325                 DefaultValue(0.0F),
 326                 SRDescription("DescriptionAttributeElementPosition_X"),
 327                 NotifyParentPropertyAttribute(true),
 328                 RefreshPropertiesAttribute(RefreshProperties.All),
 329                 #if !Microsoft_CONTROL
 330                 PersistenceMode(PersistenceMode.Attribute)
 331                 #endif
 332                 ]
 333         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "X")]
 334                 public float X
 335                 {
 336                         get
 337                         {
 338                                 return _x;
 339                         }
 340                         set
 341                         {
 342                                 if(value < 0.0 || value > 100.0)
 343                                 {
 344                                         throw(new ArgumentOutOfRangeException("value", SR.ExceptionElementPositionArgumentOutOfRange));
 345                                 }
 346                                 _x = value;
 347                                 Auto = false;
 348
 349                                 // Adjust width
 350                                 if( (_x + Width) > 100)
 351                                 {
 352                                         Width = 100 - _x;
 353                                 }
 354
 355                                 this.Invalidate();
 356                         }
 357                 }
 358
 359                 /// <summary>
 360                 /// Y position of element.
 361                 /// </summary>
 362                 [
 363                 SRCategory("CategoryAttributeMisc"),
 364                 Bindable(true),
 365                 DefaultValue(0.0F),
 366                 SRDescription("DescriptionAttributeElementPosition_Y"),
 367                 NotifyParentPropertyAttribute(true),
 368                 RefreshPropertiesAttribute(RefreshProperties.All),
 369                 #if !Microsoft_CONTROL
 370                 PersistenceMode(PersistenceMode.Attribute)
 371                 #endif
 372                 ]
 373         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Y")]
 374                 public float Y
 375                 {
 376                         get
 377                         {
 378                                 return _y;
 379                         }
 380                         set
 381                         {
 382                                 if(value < 0.0 || value > 100.0)
 383                                 {
 384                                         throw(new ArgumentOutOfRangeException("value", SR.ExceptionElementPositionArgumentOutOfRange));
 385                                 }
 386                                 _y = value;
 387                                 Auto = false;
 388
 389                                 // Adjust heigth
 390                                 if( (_y + Height) > 100)
 391                                 {
 392                                         Height = 100 - _y;
 393                                 }
 394
 395                                 this.Invalidate();
 396                         }
 397                 }
 398
 399                 /// <summary>
 400                 /// Width of element.
 401                 /// </summary>
 402                 [
 403                 SRCategory("CategoryAttributeMisc"),
 404                 Bindable(true),
 405                 DefaultValue(0.0F),
 406                 SRDescription("DescriptionAttributeElementPosition_Width"),
 407                 NotifyParentPropertyAttribute(true),
 408                 RefreshPropertiesAttribute(RefreshProperties.All),
 409                 #if !Microsoft_CONTROL
 410                 PersistenceMode(PersistenceMode.Attribute)
 411                 #endif
 412                 ]
 413                 public float Width
 414                 {
 415                         get
 416                         {
 417                                 return _width;
 418                         }
 419                         set
 420                         {
 421                                 if(value < 0.0 || value > 100.0)
 422                                 {
 423                                         throw(new ArgumentOutOfRangeException("value", SR.ExceptionElementPositionArgumentOutOfRange));
 424                                 }
 425                                 _width = value;
 426                                 Auto = false;
 427
 428                                 // Adjust x
 429                                 if( (_x + Width) > 100)
 430                                 {
 431                                         _x = 100 - Width;
 432                                 }
 433
 434                                 this.Invalidate();
 435                         }
 436                 }
 437
 438                 /// <summary>
 439                 /// Height of element.
 440                 /// </summary>
 441                 [
 442                 SRCategory("CategoryAttributeMisc"),
 443                 Bindable(true),
 444                 DefaultValue(0.0F),
 445                 SRDescription("DescriptionAttributeElementPosition_Height"),
 446                 NotifyParentPropertyAttribute(true),
 447                 RefreshPropertiesAttribute(RefreshProperties.All),
 448                 #if !Microsoft_CONTROL
 449                 PersistenceMode(PersistenceMode.Attribute)
 450                 #endif
 451                 ]
 452                 public float Height
 453                 {
 454                         get
 455                         {
 456                                 return _height;
 457                         }
 458                         set
 459                         {
 460                                 if(value < 0.0 || value > 100.0)
 461                                 {
 462                                         throw(new ArgumentOutOfRangeException("value", SR.ExceptionElementPositionArgumentOutOfRange));
 463                                 }
 464                                 _height = value;
 465                                 Auto = false;
 466
 467                                 // Adjust y
 468                                 if( (_y + Height) > 100)
 469                                 {
 470                                         _y = 100 - Height;
 471
 472                                 }
 473
 474                                 this.Invalidate();
 475                         }
 476                 }
 477
 478         /// <summary>
 479         /// Gets or sets a flag which indicates whether positioning is on.
 480         /// </summary>
 481                 [
 482                 SRCategory("CategoryAttributeMisc"),
 483                 Bindable(true),
 484                 DefaultValue(true),
 485                 SRDescription("DescriptionAttributeElementPosition_Auto"),
 486                 NotifyParentPropertyAttribute(true),
 487                 RefreshPropertiesAttribute(RefreshProperties.All),
 488                 #if !Microsoft_CONTROL
 489                 PersistenceMode(PersistenceMode.Attribute)
 490                 #endif
 491                 ]
 492                 public bool Auto
 493                 {
 494                         get
 495                         {
 496                                 return _auto;
 497                         }
 498                         set
 499                         {
 500                                 if(value != _auto)
 501                                 {
 502                                         ResetAllAreasAutoPosition(value);
 503
 504                                         if(value)
 505                                         {
 506                                                 this._x = 0;
 507                                                 this._y = 0;
 508                                                 this._width = 0;
 509                                                 this._height = 0;
 510                                         }
 511                                         _auto = value;
 512
 513                                         this.Invalidate();
 514                                 }
 515                         }
 516                 }
 517
 518                 #endregion
 519         }
 520
 521     /// <summary>
 522     /// Used for invoking windows forms MesageBox dialog.
 523     /// </summary>
 524     internal interface IDesignerMessageBoxDialog
 525     {
 526         /// <summary>
 527         /// Shows Yes/No MessageBox.
 528         /// </summary>
 529         /// <param name="message">The message.</param>
 530         /// <returns>
 531         /// true if user confirms with Yes
 532         /// </returns>
 533         bool ShowQuestion(string message);
 534     }
 535 }