示例#1
0
文件: CMath.cs 项目: doctorgu/MadeIn9
        public static SizeF GetPaperSize(PaperKind Kind, bool Rotated, ScaleModeConstants Mode)
        {
            if (Kind.ToString().EndsWith("Rotated"))
            {
                throw new Exception(string.Format("Kind:{0} has 'Rotated' value", Kind));
            }

            PaperKind KindNew = Kind;

            if (Rotated)
            {
                switch (Kind)
                {
                case PaperKind.Letter: KindNew = PaperKind.LetterRotated; break;

                case PaperKind.B4: KindNew = PaperKind.B4JisRotated; break;

                case PaperKind.B5: KindNew = PaperKind.B5JisRotated; break;

                case PaperKind.A3: KindNew = PaperKind.A3Rotated; break;

                case PaperKind.A4: KindNew = PaperKind.A4Rotated; break;

                case PaperKind.A5: KindNew = PaperKind.A5Rotated; break;

                case PaperKind.A6: KindNew = PaperKind.A6Rotated; break;

                default:
                    throw new Exception(string.Format("Wrong PaperKind:{0}", Kind));
                }
            }

            return(GetPaperSize(KindNew, Mode));
        }
示例#2
0
文件: CMath.cs 项目: doctorgu/MadeIn9
        public static float ConvertUnit(ScaleModeConstants FromMode, float FromValue, ScaleModeConstants ToMode)
        {
            //C#에서 테스트 결과 해상도를 바꿔도 항상 96이므로 고정함.
            int DpiXOrY = 96;

            return(ConvertUnit(FromMode, FromValue, ToMode, DpiXOrY));
        }
示例#3
0
文件: CMath.cs 项目: doctorgu/MadeIn9
        public static SizeF GetPaperSize(PaperKind Kind, ScaleModeConstants Mode)
        {
            #region GetValues
            if (_dicPaperSize.Count == 0)
            {
                //기본 프린터가 Microsoft XPS Document Writer인 상태에서 다음 코드로 생성함.
                //기본 프린터가 다른 경우엔 종류가 적어지고 값이 최대 10 정도 달라짐.
                //string s = "";
                //PrinterSettings settings = new PrinterSettings();
                //foreach (PaperSize size in settings.PaperSizes)
                //    s += string.Format("_dicPaperSize.Add(PaperKind.{0}, new Size({1}, {2}));\r\n", size.Kind, size.Width, size.Height);

                _dicPaperSize.Add(PaperKind.Letter, new Size(850, 1100));
                _dicPaperSize.Add(PaperKind.LetterSmall, new Size(850, 1100));
                _dicPaperSize.Add(PaperKind.Tabloid, new Size(1100, 1700));
                _dicPaperSize.Add(PaperKind.Ledger, new Size(1700, 1100));
                _dicPaperSize.Add(PaperKind.Legal, new Size(850, 1400));
                _dicPaperSize.Add(PaperKind.Statement, new Size(550, 850));
                _dicPaperSize.Add(PaperKind.Executive, new Size(725, 1050));
                _dicPaperSize.Add(PaperKind.A3, new Size(1169, 1654));
                _dicPaperSize.Add(PaperKind.A4, new Size(827, 1169));
                _dicPaperSize.Add(PaperKind.A4Small, new Size(827, 1169));
                _dicPaperSize.Add(PaperKind.A5, new Size(583, 827));
                _dicPaperSize.Add(PaperKind.B4, new Size(1012, 1433));
                _dicPaperSize.Add(PaperKind.B5, new Size(717, 1012));
                _dicPaperSize.Add(PaperKind.Folio, new Size(850, 1300));
                _dicPaperSize.Add(PaperKind.Quarto, new Size(846, 1083));
                _dicPaperSize.Add(PaperKind.Standard10x14, new Size(1000, 1400));
                _dicPaperSize.Add(PaperKind.Standard11x17, new Size(1100, 1700));
                _dicPaperSize.Add(PaperKind.Note, new Size(850, 1100));
                _dicPaperSize.Add(PaperKind.Number9Envelope, new Size(387, 887));
                _dicPaperSize.Add(PaperKind.Number10Envelope, new Size(412, 950));
                _dicPaperSize.Add(PaperKind.Number11Envelope, new Size(450, 1037));
                _dicPaperSize.Add(PaperKind.Number12Envelope, new Size(475, 1100));
                _dicPaperSize.Add(PaperKind.Number14Envelope, new Size(500, 1150));
                _dicPaperSize.Add(PaperKind.CSheet, new Size(1700, 2200));
                _dicPaperSize.Add(PaperKind.DSheet, new Size(2200, 3400));
                _dicPaperSize.Add(PaperKind.ESheet, new Size(3400, 4400));
                _dicPaperSize.Add(PaperKind.DLEnvelope, new Size(433, 866));
                _dicPaperSize.Add(PaperKind.C5Envelope, new Size(638, 902));
                _dicPaperSize.Add(PaperKind.C3Envelope, new Size(1276, 1803));
                _dicPaperSize.Add(PaperKind.C4Envelope, new Size(902, 1276));
                _dicPaperSize.Add(PaperKind.C6Envelope, new Size(449, 638));
                _dicPaperSize.Add(PaperKind.C65Envelope, new Size(449, 902));
                _dicPaperSize.Add(PaperKind.B4Envelope, new Size(984, 1390));
                _dicPaperSize.Add(PaperKind.B5Envelope, new Size(693, 984));
                _dicPaperSize.Add(PaperKind.B6Envelope, new Size(693, 492));
                _dicPaperSize.Add(PaperKind.ItalyEnvelope, new Size(433, 906));
                _dicPaperSize.Add(PaperKind.MonarchEnvelope, new Size(387, 750));
                _dicPaperSize.Add(PaperKind.PersonalEnvelope, new Size(362, 650));
                _dicPaperSize.Add(PaperKind.USStandardFanfold, new Size(1487, 1100));
                _dicPaperSize.Add(PaperKind.GermanStandardFanfold, new Size(850, 1200));
                _dicPaperSize.Add(PaperKind.GermanLegalFanfold, new Size(850, 1300));
                _dicPaperSize.Add(PaperKind.IsoB4, new Size(984, 1390));
                _dicPaperSize.Add(PaperKind.JapanesePostcard, new Size(394, 583));
                _dicPaperSize.Add(PaperKind.Standard9x11, new Size(900, 1100));
                _dicPaperSize.Add(PaperKind.Standard10x11, new Size(1000, 1100));
                _dicPaperSize.Add(PaperKind.Standard15x11, new Size(1500, 1100));
                _dicPaperSize.Add(PaperKind.InviteEnvelope, new Size(866, 866));
                _dicPaperSize.Add(PaperKind.LetterExtra, new Size(950, 1200));
                _dicPaperSize.Add(PaperKind.LegalExtra, new Size(950, 1500));
                _dicPaperSize.Add(PaperKind.A4Extra, new Size(927, 1269));
                _dicPaperSize.Add(PaperKind.LetterTransverse, new Size(850, 1100));
                _dicPaperSize.Add(PaperKind.A4Transverse, new Size(827, 1169));
                _dicPaperSize.Add(PaperKind.LetterExtraTransverse, new Size(950, 1200));
                _dicPaperSize.Add(PaperKind.APlus, new Size(894, 1402));
                _dicPaperSize.Add(PaperKind.BPlus, new Size(1201, 1917));
                _dicPaperSize.Add(PaperKind.LetterPlus, new Size(850, 1269));
                _dicPaperSize.Add(PaperKind.A4Plus, new Size(827, 1299));
                _dicPaperSize.Add(PaperKind.A5Transverse, new Size(583, 827));
                _dicPaperSize.Add(PaperKind.B5Transverse, new Size(717, 1012));
                _dicPaperSize.Add(PaperKind.A3Extra, new Size(1268, 1752));
                _dicPaperSize.Add(PaperKind.A5Extra, new Size(685, 925));
                _dicPaperSize.Add(PaperKind.B5Extra, new Size(791, 1087));
                _dicPaperSize.Add(PaperKind.A2, new Size(1654, 2339));
                _dicPaperSize.Add(PaperKind.A3Transverse, new Size(1169, 1654));
                _dicPaperSize.Add(PaperKind.A3ExtraTransverse, new Size(1268, 1752));
                _dicPaperSize.Add(PaperKind.JapaneseDoublePostcard, new Size(787, 583));
                _dicPaperSize.Add(PaperKind.A6, new Size(413, 583));
                _dicPaperSize.Add(PaperKind.JapaneseEnvelopeKakuNumber2, new Size(945, 1307));
                _dicPaperSize.Add(PaperKind.JapaneseEnvelopeKakuNumber3, new Size(850, 1091));
                _dicPaperSize.Add(PaperKind.JapaneseEnvelopeChouNumber3, new Size(472, 925));
                _dicPaperSize.Add(PaperKind.JapaneseEnvelopeChouNumber4, new Size(354, 807));
                _dicPaperSize.Add(PaperKind.LetterRotated, new Size(1100, 850));
                _dicPaperSize.Add(PaperKind.A3Rotated, new Size(1654, 1169));
                _dicPaperSize.Add(PaperKind.A4Rotated, new Size(1169, 827));
                _dicPaperSize.Add(PaperKind.A5Rotated, new Size(827, 583));
                _dicPaperSize.Add(PaperKind.B4JisRotated, new Size(1433, 1012));
                _dicPaperSize.Add(PaperKind.B5JisRotated, new Size(1012, 717));
                _dicPaperSize.Add(PaperKind.JapanesePostcardRotated, new Size(583, 394));
                _dicPaperSize.Add(PaperKind.JapaneseDoublePostcardRotated, new Size(583, 787));
                _dicPaperSize.Add(PaperKind.A6Rotated, new Size(583, 413));
                _dicPaperSize.Add(PaperKind.JapaneseEnvelopeKakuNumber2Rotated, new Size(1307, 945));
                _dicPaperSize.Add(PaperKind.JapaneseEnvelopeKakuNumber3Rotated, new Size(1091, 850));
                _dicPaperSize.Add(PaperKind.JapaneseEnvelopeChouNumber3Rotated, new Size(925, 472));
                _dicPaperSize.Add(PaperKind.JapaneseEnvelopeChouNumber4Rotated, new Size(807, 354));
                _dicPaperSize.Add(PaperKind.B6Jis, new Size(504, 717));
                _dicPaperSize.Add(PaperKind.B6JisRotated, new Size(717, 504));
                _dicPaperSize.Add(PaperKind.Standard12x11, new Size(1200, 1100));
                _dicPaperSize.Add(PaperKind.JapaneseEnvelopeYouNumber4, new Size(413, 925));
                _dicPaperSize.Add(PaperKind.JapaneseEnvelopeYouNumber4Rotated, new Size(925, 413));
                _dicPaperSize.Add(PaperKind.PrcEnvelopeNumber1, new Size(402, 650));
                _dicPaperSize.Add(PaperKind.PrcEnvelopeNumber3, new Size(492, 693));
                _dicPaperSize.Add(PaperKind.PrcEnvelopeNumber4, new Size(433, 819));
                _dicPaperSize.Add(PaperKind.PrcEnvelopeNumber5, new Size(433, 866));
                _dicPaperSize.Add(PaperKind.PrcEnvelopeNumber6, new Size(472, 906));
                _dicPaperSize.Add(PaperKind.PrcEnvelopeNumber7, new Size(630, 906));
                _dicPaperSize.Add(PaperKind.PrcEnvelopeNumber8, new Size(472, 1217));
                _dicPaperSize.Add(PaperKind.PrcEnvelopeNumber9, new Size(902, 1276));
                _dicPaperSize.Add(PaperKind.PrcEnvelopeNumber10, new Size(1276, 1803));
                _dicPaperSize.Add(PaperKind.PrcEnvelopeNumber1Rotated, new Size(650, 402));
                _dicPaperSize.Add(PaperKind.PrcEnvelopeNumber3Rotated, new Size(693, 492));
                _dicPaperSize.Add(PaperKind.PrcEnvelopeNumber4Rotated, new Size(819, 433));
                _dicPaperSize.Add(PaperKind.PrcEnvelopeNumber5Rotated, new Size(866, 433));
                _dicPaperSize.Add(PaperKind.PrcEnvelopeNumber6Rotated, new Size(906, 472));
                _dicPaperSize.Add(PaperKind.PrcEnvelopeNumber7Rotated, new Size(906, 630));
                _dicPaperSize.Add(PaperKind.PrcEnvelopeNumber8Rotated, new Size(1217, 472));
                _dicPaperSize.Add(PaperKind.PrcEnvelopeNumber9Rotated, new Size(1276, 902));
            }
            #endregion GetValues

            Size  szInches100 = _dicPaperSize[Kind];
            SizeF szNew       = new SizeF(
                CMath.ConvertUnit(ScaleModeConstants.Inches, szInches100.Width / 100f, Mode),
                CMath.ConvertUnit(ScaleModeConstants.Inches, szInches100.Height / 100f, Mode));

            return(szNew);
        }
示例#4
0
文件: CMath.cs 项目: doctorgu/MadeIn9
        /// <summary>
        /// 다음의 기준에 따라 변환된 값을 리턴함.
        /// 1440 Twips : 1 Inch
        /// 567 Twips : 1 Centimeter
        /// 72 Points : 1 Inch
        /// 2.54 Centemeters : 1 Inch
        /// 10 Millimeters : 1 Centimeter
        /// </summary>
        /// <param name="FromMode">원래 단위</param>
        /// <param name="FromValue">원래 값</param>
        /// <param name="ToMode">변환할 단위</param>
        /// <returns>변환된 값</returns>
        public static float ConvertUnit(ScaleModeConstants FromMode, float FromValue, ScaleModeConstants ToMode,
                                        float DpiXOrY)
        {
            float NewValue = 0;

            //VB에서 테스트 결과 해상도를 바꿔도 항상 15를 리턴하므로 15로 고정시킴.
            float       TwipsPerPixel      = 15;
            const float drMilliPerInch25_4 = 25.4f;
            const float drCentiPerInch2_54 = 2.54f;

            switch (FromMode)
            {
            case ScaleModeConstants.Twips:
                switch (ToMode)
                {
                case ScaleModeConstants.Twips:
                    NewValue = FromValue;
                    break;

                case ScaleModeConstants.Points:
                    NewValue = (FromValue / 1440) * 72;
                    break;

                case ScaleModeConstants.Pixels:
                    NewValue = FromValue / TwipsPerPixel;
                    break;

                case ScaleModeConstants.Inches:
                    NewValue = FromValue / 1440;
                    break;

                case ScaleModeConstants.Millimeters:
                    NewValue = FromValue / 5670;
                    break;

                case ScaleModeConstants.Centimeters:
                    NewValue = FromValue / 567;
                    break;
                }
                break;

            case ScaleModeConstants.Points:
                switch (ToMode)
                {
                case ScaleModeConstants.Twips:
                    NewValue = (FromValue / 72) * 1440;
                    break;

                case ScaleModeConstants.Points:
                    NewValue = FromValue;
                    break;

                case ScaleModeConstants.Pixels:
                    NewValue = ((FromValue / 72) * 1440) / TwipsPerPixel;
                    break;

                case ScaleModeConstants.Inches:
                    NewValue = FromValue / 72;
                    break;

                case ScaleModeConstants.Millimeters:
                    NewValue = (FromValue / 72) * drMilliPerInch25_4;
                    break;

                case ScaleModeConstants.Centimeters:
                    NewValue = (FromValue / 72) * drCentiPerInch2_54;
                    break;
                }
                break;

            case ScaleModeConstants.Pixels:
                switch (ToMode)
                {
                case ScaleModeConstants.Twips:
                    NewValue = FromValue * TwipsPerPixel;
                    break;

                case ScaleModeConstants.Points:
                    NewValue = ((FromValue * TwipsPerPixel) / 1440) * 72;
                    break;

                case ScaleModeConstants.Pixels:
                    NewValue = FromValue;
                    break;

                case ScaleModeConstants.Inches:
                    NewValue = (FromValue * TwipsPerPixel) / 1440;
                    break;

                case ScaleModeConstants.Millimeters:
                    //NewValue = (FromValue * TwipsPerPixel) / 5670;
                    NewValue = FromValue / (DpiXOrY / drMilliPerInch25_4);
                    break;

                case ScaleModeConstants.Centimeters:
                    //NewValue = (FromValue * TwipsPerPixel) / 567;
                    NewValue = FromValue / (DpiXOrY / drCentiPerInch2_54);
                    break;
                }
                break;

            case ScaleModeConstants.Inches:
                switch (ToMode)
                {
                case ScaleModeConstants.Twips:
                    NewValue = FromValue * 1440;
                    break;

                case ScaleModeConstants.Points:
                    NewValue = FromValue * 72;
                    break;

                case ScaleModeConstants.Pixels:
                    NewValue = (FromValue * 1440) / TwipsPerPixel;
                    break;

                case ScaleModeConstants.Inches:
                    NewValue = FromValue;
                    break;

                case ScaleModeConstants.Millimeters:
                    NewValue = FromValue * drMilliPerInch25_4;
                    break;

                case ScaleModeConstants.Centimeters:
                    NewValue = FromValue * drCentiPerInch2_54;
                    break;
                }
                break;

            case ScaleModeConstants.Millimeters:
                switch (ToMode)
                {
                case ScaleModeConstants.Twips:
                    NewValue = FromValue * 5670;
                    break;

                case ScaleModeConstants.Points:
                    NewValue = (FromValue / drMilliPerInch25_4) * 72;
                    break;

                case ScaleModeConstants.Pixels:
                    //NewValue = (FromValue * 5670) / TwipsPerPixel;
                    NewValue = (DpiXOrY / drMilliPerInch25_4) * FromValue;
                    break;

                case ScaleModeConstants.Inches:
                    NewValue = FromValue / drMilliPerInch25_4;
                    break;

                case ScaleModeConstants.Millimeters:
                    NewValue = FromValue;
                    break;

                case ScaleModeConstants.Centimeters:
                    NewValue = FromValue / 10;
                    break;
                }
                break;

            case ScaleModeConstants.Centimeters:
                switch (ToMode)
                {
                case ScaleModeConstants.Twips:
                    NewValue = FromValue * 567;
                    break;

                case ScaleModeConstants.Points:
                    NewValue = (FromValue / drCentiPerInch2_54) * 72;
                    break;

                case ScaleModeConstants.Pixels:
                    //NewValue = (FromValue * 567) / TwipsPerPixel;
                    NewValue = (DpiXOrY / drCentiPerInch2_54) * FromValue;
                    break;

                case ScaleModeConstants.Inches:
                    NewValue = FromValue / drCentiPerInch2_54;
                    break;

                case ScaleModeConstants.Millimeters:
                    NewValue = FromValue * 10;
                    break;

                case ScaleModeConstants.Centimeters:
                    NewValue = FromValue;
                    break;
                }
                break;

            default:
                break;
            }

            return(NewValue);
        }
示例#5
0
        /// <summary>
        /// Converts the parameter to pixels Y. 
        /// It is assumed that the parameter is given in the units specified by scaleMode
        /// </summary>
        /// <param name="num">The number to convert to pixels Y</param>
        /// <param name="scaleMode">The ScaleMode to use</param>
        /// <returns>The parameter converted to pixels given the value of scaleMode</returns>
        private double ConvertToPixelsY(double num, ScaleModeConstants scaleMode)
        {
            double res;
            switch (scaleMode)
            {
                case ScaleModeConstants.VbTwips:
                    res = Support.TwipsToPixelsY(num);
                    break;
                case ScaleModeConstants.VbPoints:
                    res = Support.ToPixelsY(num, Microsoft.VisualBasic.Compatibility.VB6.ScaleMode.Points);
                    break;
                case ScaleModeConstants.VbCentimeters:
                    res = Support.ToPixelsY(num, Microsoft.VisualBasic.Compatibility.VB6.ScaleMode.Centimeters);
                    break;
                case ScaleModeConstants.VbCharacters:
                    res = Support.ToPixelsY(num, Microsoft.VisualBasic.Compatibility.VB6.ScaleMode.Characters);
                    break;
                case ScaleModeConstants.VbHimetric:
                    res = Support.ToPixelsY(num, Microsoft.VisualBasic.Compatibility.VB6.ScaleMode.Himetric);
                    break;
                case ScaleModeConstants.VbInches:
                    res = Support.ToPixelsY(num, Microsoft.VisualBasic.Compatibility.VB6.ScaleMode.Inches);
                    break;
                case ScaleModeConstants.VbMilimeters:
                    res = Support.ToPixelsY(num, Microsoft.VisualBasic.Compatibility.VB6.ScaleMode.Millimeters);
                    break;
                case ScaleModeConstants.VbPixels:
                    res =
                       (this._innerPrinter.DefaultPageSettings.Landscape ?
                             PrinterGraphics.VisibleClipBounds.Width :
                             PrinterGraphics.VisibleClipBounds.Height)
                        * (num / ScaleHeight);
                    break;
                default:
                    res = num;
                    break;
            }

            return res;
        }
示例#6
0
        /// <summary>
        /// Converts the parameter to the new numeric system given by scaleMode.
        /// It is assumed that the parameter represents pixels Y
        /// </summary>
        /// <param name="num">The pixels to convert</param>
        /// <param name="scaleMode">The ScaleMode to use</param>
        /// <returns>The pixels converted according to the scaleMode parameter</returns>
        private static double ConvertFromPixelsY(double num, ScaleModeConstants scaleMode)
        {
            double res;
            switch (scaleMode)
            {
                case ScaleModeConstants.VbTwips:
                    res = Support.PixelsToTwipsY(num);
                    break;
                case ScaleModeConstants.VbPoints:
                    res = Support.FromPixelsY(num, Microsoft.VisualBasic.Compatibility.VB6.ScaleMode.Points);
                    break;
                case ScaleModeConstants.VbCentimeters:
                    res = Support.FromPixelsY(num, Microsoft.VisualBasic.Compatibility.VB6.ScaleMode.Centimeters);
                    break;
                case ScaleModeConstants.VbCharacters:
                    res = Support.FromPixelsY(num, Microsoft.VisualBasic.Compatibility.VB6.ScaleMode.Characters);
                    break;
                case ScaleModeConstants.VbHimetric:
                    res = Support.FromPixelsY(num, Microsoft.VisualBasic.Compatibility.VB6.ScaleMode.Himetric);
                    break;
                case ScaleModeConstants.VbInches:
                    res = Support.FromPixelsY(num, Microsoft.VisualBasic.Compatibility.VB6.ScaleMode.Inches);
                    break;
                case ScaleModeConstants.VbMilimeters:
                    res = Support.FromPixelsY(num, Microsoft.VisualBasic.Compatibility.VB6.ScaleMode.Millimeters);
                    break;
                default:
                    res = num;
                    break;
            }

            return res;
        }
示例#7
0
 /// <summary>
 /// Converts the paratemer to the new numeric system given by scaleMode.
 /// It is assumed that the parameter is represented in the internal units of the printer
 /// </summary>
 /// <param name="num"></param>
 /// <param name="scaleMode"></param>
 /// <returns></returns>
 private static double ConvertFromPrinterUnitsY(double num, ScaleModeConstants scaleMode)
 {
     return ConvertFromPixelsY(num * (DisplayDpi / 100), scaleMode);
 }
示例#8
0
        /*/// <summary>
        /// Converts the parameter to printer units Y. 
        /// It is assumed that the parameter is given in the units specified by scaleMode
        /// </summary>
        /// <param name="num">The number to convert to printer units Y</param>
        /// <param name="scaleMode">The ScaleMode to use</param>
        /// <returns>The parameter converted to printer units given the value of scaleMode</returns>
 */
        /// <summary>
        /// Converts the paratemer to the new numeric system given by scaleMode.
        /// It is assumed that the parameter is represented in the internal units of the printer
        /// </summary>
        /// <param name="num"></param>
        /// <param name="scaleMode"></param>
        /// <returns></returns>
        private static double ConvertFromPrinterUnitsX(double num, ScaleModeConstants scaleMode)
        {
            //The parameter is converted to pixels then to the internal units given by scaleMode
            return ConvertFromPixelsX(num * (DisplayDpi / 100), scaleMode);
        }
示例#9
0
 /// <summary>
 /// Converts the parameter to printer units X. 
 /// It is assumed that the parameter is given in the units specified by scaleMode
 /// </summary>
 /// <param name="num">The number to convert to printer units X</param>
 /// <param name="scaleMode">The ScaleMode to use</param>
 /// <returns>The parameter converted to printer units given the value of scaleMode</returns>
 private double ConvertToPrinterUnitsX(double num, ScaleModeConstants scaleMode)
 {
     //The parameter is converted to pixels then to the printer units
     //return ConvertToPixelsX(num, scaleMode)///(DisplayDpi/100);
     return ConvertToPixelsX(num, scaleMode);
 }
示例#10
0
 private static RectangleF RectangleFFromPixels(RectangleF rectangleF, ScaleModeConstants scaleMode)
 {
     RectangleF result = new RectangleF();
     result.X = (float)ConvertFromPixelsX(rectangleF.X, scaleMode);
     result.Y = (float)ConvertFromPixelsY(rectangleF.Y, scaleMode);
     result.Width = (float)ConvertFromPixelsY(rectangleF.Width, scaleMode);
     result.Height = (float)ConvertFromPixelsY(rectangleF.Height, scaleMode);
     return result;
 }