LCOV - code coverage report
Current view: top level - libreoffice/svtools/source/misc - unitconv.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 0 285 0.0 %
Date: 2012-12-27 Functions: 0 41 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include <svtools/unitconv.hxx>
      21             : 
      22             : // -----------------------------------------------------------------------
      23             : 
      24           0 : void SetFieldUnit( MetricField& rField, FieldUnit eUnit, sal_Bool bAll )
      25             : {
      26           0 :     sal_Int64 nFirst    = rField.Denormalize( rField.GetFirst( FUNIT_TWIP ) );
      27           0 :     sal_Int64 nLast = rField.Denormalize( rField.GetLast( FUNIT_TWIP ) );
      28           0 :     sal_Int64 nMin = rField.Denormalize( rField.GetMin( FUNIT_TWIP ) );
      29           0 :     sal_Int64 nMax = rField.Denormalize( rField.GetMax( FUNIT_TWIP ) );
      30             : 
      31           0 :     if ( !bAll )
      32             :     {
      33           0 :         switch ( eUnit )
      34             :         {
      35             :             case FUNIT_M:
      36             :             case FUNIT_KM:
      37           0 :                 eUnit = FUNIT_CM;
      38           0 :                 break;
      39             : 
      40             :             case FUNIT_FOOT:
      41             :             case FUNIT_MILE:
      42           0 :                 eUnit = FUNIT_INCH;
      43           0 :                 break;
      44             :             default: ;//prevent warning
      45             :         }
      46             :     }
      47           0 :     rField.SetUnit( eUnit );
      48           0 :     switch( eUnit )
      49             :     {
      50             :         // _CHAR and _LINE sets the step of "char" and "line" unit, they are same as FUNIT_MM
      51             :         case FUNIT_CHAR:
      52             :         case FUNIT_LINE:
      53             :         case FUNIT_MM:
      54           0 :             rField.SetSpinSize( 50 );
      55           0 :             break;
      56             : 
      57             :         case FUNIT_INCH:
      58           0 :             rField.SetSpinSize( 2 );
      59           0 :             break;
      60             : 
      61             :         default:
      62           0 :             rField.SetSpinSize( 10 );
      63             :     }
      64             : 
      65           0 :     if ( FUNIT_POINT == eUnit )
      66             :     {
      67           0 :         if( rField.GetDecimalDigits() > 1 )
      68           0 :             rField.SetDecimalDigits( 1 );
      69             :     }
      70             :     else
      71           0 :         rField.SetDecimalDigits( 2 );
      72             : 
      73           0 :     if ( !bAll )
      74             :     {
      75           0 :         rField.SetFirst( rField.Normalize( nFirst ), FUNIT_TWIP );
      76           0 :         rField.SetLast( rField.Normalize( nLast ), FUNIT_TWIP );
      77           0 :         rField.SetMin( rField.Normalize( nMin ), FUNIT_TWIP );
      78           0 :         rField.SetMax( rField.Normalize( nMax ), FUNIT_TWIP );
      79             :     }
      80           0 : }
      81             : 
      82             : // -----------------------------------------------------------------------
      83             : 
      84           0 : void SetFieldUnit( MetricBox& rBox, FieldUnit eUnit, sal_Bool bAll )
      85             : {
      86           0 :     sal_Int64 nMin = rBox.Denormalize( rBox.GetMin( FUNIT_TWIP ) );
      87           0 :     sal_Int64 nMax = rBox.Denormalize( rBox.GetMax( FUNIT_TWIP ) );
      88             : 
      89           0 :     if ( !bAll )
      90             :     {
      91           0 :         switch ( eUnit )
      92             :         {
      93             :             case FUNIT_M:
      94             :             case FUNIT_KM:
      95           0 :                 eUnit = FUNIT_CM;
      96           0 :                 break;
      97             : 
      98             :             case FUNIT_FOOT:
      99             :             case FUNIT_MILE:
     100           0 :                 eUnit = FUNIT_INCH;
     101           0 :                 break;
     102             :             default: ;//prevent warning
     103             :         }
     104             :     }
     105           0 :     rBox.SetUnit( eUnit );
     106             : 
     107           0 :     if ( FUNIT_POINT == eUnit && rBox.GetDecimalDigits() > 1 )
     108           0 :         rBox.SetDecimalDigits( 1 );
     109             :     else
     110           0 :         rBox.SetDecimalDigits( 2 );
     111             : 
     112           0 :     if ( !bAll )
     113             :     {
     114           0 :         rBox.SetMin( rBox.Normalize( nMin ), FUNIT_TWIP );
     115           0 :         rBox.SetMax( rBox.Normalize( nMax ), FUNIT_TWIP );
     116             :     }
     117           0 : }
     118             : 
     119             : // -----------------------------------------------------------------------
     120           0 : void SetMetricValue( MetricField& rField, long nCoreValue, SfxMapUnit eUnit )
     121             : {
     122           0 :     sal_Int64 nVal = OutputDevice::LogicToLogic( nCoreValue, (MapUnit)eUnit, MAP_100TH_MM );
     123           0 :     nVal = rField.Normalize( nVal );
     124           0 :     rField.SetValue( nVal, FUNIT_100TH_MM );
     125             : 
     126           0 : }
     127             : 
     128             : // -----------------------------------------------------------------------
     129             : 
     130           0 : long GetCoreValue( const MetricField& rField, SfxMapUnit eUnit )
     131             : {
     132           0 :     sal_Int64 nVal = rField.GetValue( FUNIT_100TH_MM );
     133             :     // avoid rounding issues
     134           0 :     const sal_Int64 nSizeMask = 0xffffffffff000000LL;
     135           0 :     bool bRoundBefore = true;
     136           0 :     if( nVal >= 0 )
     137             :     {
     138           0 :         if( (nVal & nSizeMask) == 0 )
     139           0 :             bRoundBefore = false;
     140             :     }
     141             :     else
     142             :     {
     143           0 :         if( ((-nVal) & nSizeMask ) == 0 )
     144           0 :             bRoundBefore = false;
     145             :     }
     146           0 :     if( bRoundBefore )
     147           0 :         nVal = rField.Denormalize( nVal );
     148           0 :     sal_Int64 nUnitVal = OutputDevice::LogicToLogic( static_cast<long>(nVal), MAP_100TH_MM, (MapUnit)eUnit );
     149           0 :     if( ! bRoundBefore )
     150           0 :         nUnitVal = rField.Denormalize( nUnitVal );
     151           0 :     return static_cast<long>(nUnitVal);
     152             : }
     153             : 
     154             : // -----------------------------------------------------------------------
     155             : 
     156           0 : long CalcToUnit( float nIn, SfxMapUnit eUnit )
     157             : {
     158             :     // nIn ist in Points
     159             : 
     160             :     DBG_ASSERT( eUnit == SFX_MAPUNIT_TWIP       ||
     161             :                 eUnit == SFX_MAPUNIT_100TH_MM   ||
     162             :                 eUnit == SFX_MAPUNIT_10TH_MM    ||
     163             :                 eUnit == SFX_MAPUNIT_MM         ||
     164             :                 eUnit == SFX_MAPUNIT_CM, "this unit is not implemented" );
     165             : 
     166           0 :     float nTmp = nIn;
     167             : 
     168           0 :     if ( SFX_MAPUNIT_TWIP != eUnit )
     169           0 :         nTmp = nIn * 10 / 567;
     170             : 
     171           0 :     switch ( eUnit )
     172             :     {
     173           0 :         case SFX_MAPUNIT_100TH_MM:  nTmp *= 100; break;
     174           0 :         case SFX_MAPUNIT_10TH_MM:   nTmp *= 10;  break;
     175           0 :         case SFX_MAPUNIT_MM:                     break;
     176           0 :         case SFX_MAPUNIT_CM:        nTmp /= 10;  break;
     177             :         default: ;//prevent warning
     178             :     }
     179             : 
     180           0 :     nTmp *= 20;
     181           0 :     long nRet = (long)nTmp;
     182           0 :     return nRet;
     183             : //! return (long)(nTmp * 20);
     184             : }
     185             : 
     186             : // -----------------------------------------------------------------------
     187             : 
     188           0 : long ItemToControl( long nIn, SfxMapUnit eItem, SfxFieldUnit eCtrl )
     189             : {
     190           0 :     long nOut = 0;
     191             : 
     192           0 :     switch ( eItem )
     193             :     {
     194             :         case SFX_MAPUNIT_100TH_MM:
     195             :         case SFX_MAPUNIT_10TH_MM:
     196             :         case SFX_MAPUNIT_MM:
     197             :         {
     198           0 :             if ( eItem == SFX_MAPUNIT_10TH_MM )
     199           0 :                 nIn /= 10;
     200           0 :             else if ( eItem == SFX_MAPUNIT_100TH_MM )
     201           0 :                 nIn /= 100;
     202           0 :             nOut = TransformMetric( nIn, FUNIT_MM, (FieldUnit)eCtrl );
     203             :         }
     204           0 :         break;
     205             : 
     206             :         case SFX_MAPUNIT_CM:
     207             :         {
     208           0 :             nOut = TransformMetric( nIn, FUNIT_CM, (FieldUnit)eCtrl );
     209             :         }
     210           0 :         break;
     211             : 
     212             :         case SFX_MAPUNIT_1000TH_INCH:
     213             :         case SFX_MAPUNIT_100TH_INCH:
     214             :         case SFX_MAPUNIT_10TH_INCH:
     215             :         case SFX_MAPUNIT_INCH:
     216             :         {
     217           0 :             if ( eItem == SFX_MAPUNIT_10TH_INCH )
     218           0 :                 nIn /= 10;
     219           0 :             else if ( eItem == SFX_MAPUNIT_100TH_INCH )
     220           0 :                 nIn /= 100;
     221           0 :             else if ( eItem == SFX_MAPUNIT_1000TH_INCH )
     222           0 :                 nIn /= 1000;
     223           0 :             nOut = TransformMetric( nIn, FUNIT_INCH, (FieldUnit)eCtrl );
     224             :         }
     225           0 :         break;
     226             : 
     227             :         case SFX_MAPUNIT_POINT:
     228             :         {
     229           0 :             nOut = TransformMetric( nIn, FUNIT_POINT, (FieldUnit)eCtrl );
     230             :         }
     231           0 :         break;
     232             : 
     233             :         case SFX_MAPUNIT_TWIP:
     234             :         {
     235           0 :             nOut = TransformMetric( nIn, FUNIT_TWIP, (FieldUnit)eCtrl );
     236             :         }
     237           0 :         break;
     238             :         default: ;//prevent warning
     239             :     }
     240           0 :     return nOut;
     241             : }
     242             : 
     243             : // -----------------------------------------------------------------------
     244             : 
     245           0 : long ControlToItem( long nIn, SfxFieldUnit eCtrl, SfxMapUnit eItem )
     246             : {
     247           0 :     return ItemToControl( nIn, eItem, eCtrl );
     248             : }
     249             : 
     250             : // -----------------------------------------------------------------------
     251             : 
     252           0 : FieldUnit MapToFieldUnit( const SfxMapUnit eUnit )
     253             : {
     254           0 :     switch ( eUnit )
     255             :     {
     256             :         case SFX_MAPUNIT_100TH_MM:
     257             :         case SFX_MAPUNIT_10TH_MM:
     258             :         case SFX_MAPUNIT_MM:
     259           0 :             return FUNIT_MM;
     260             : 
     261             :         case SFX_MAPUNIT_CM:
     262           0 :             return FUNIT_CM;
     263             : 
     264             :         case SFX_MAPUNIT_1000TH_INCH:
     265             :         case SFX_MAPUNIT_100TH_INCH:
     266             :         case SFX_MAPUNIT_10TH_INCH:
     267             :         case SFX_MAPUNIT_INCH:
     268           0 :             return FUNIT_INCH;
     269             : 
     270             :         case SFX_MAPUNIT_POINT:
     271           0 :             return FUNIT_POINT;
     272             : 
     273             :         case SFX_MAPUNIT_TWIP:
     274           0 :             return FUNIT_TWIP;
     275             :         default: ;//prevent warning
     276             :     }
     277           0 :     return FUNIT_NONE;
     278             : }
     279             : 
     280             : // -----------------------------------------------------------------------
     281             : 
     282           0 : long CalcToPoint( long nIn, SfxMapUnit eUnit, sal_uInt16 nFaktor )
     283             : {
     284             :     DBG_ASSERT( eUnit == SFX_MAPUNIT_TWIP       ||
     285             :                 eUnit == SFX_MAPUNIT_100TH_MM   ||
     286             :                 eUnit == SFX_MAPUNIT_10TH_MM    ||
     287             :                 eUnit == SFX_MAPUNIT_MM         ||
     288             :                 eUnit == SFX_MAPUNIT_CM, "this unit is not implemented" );
     289             : 
     290           0 :     long nRet = 0;
     291             : 
     292           0 :     if ( SFX_MAPUNIT_TWIP == eUnit )
     293           0 :         nRet = nIn;
     294             :     else
     295           0 :         nRet = nIn * 567;
     296             : 
     297           0 :     switch ( eUnit )
     298             :     {
     299           0 :         case SFX_MAPUNIT_100TH_MM:  nRet /= 100; break;
     300           0 :         case SFX_MAPUNIT_10TH_MM:   nRet /= 10;  break;
     301           0 :         case SFX_MAPUNIT_MM:                     break;
     302           0 :         case SFX_MAPUNIT_CM:        nRet *= 10;  break;
     303             :         default: ;//prevent warning
     304             :     }
     305             : 
     306             :     // ggf. aufrunden
     307           0 :     if ( SFX_MAPUNIT_TWIP != eUnit )
     308             :     {
     309           0 :         long nMod = 10;
     310           0 :         long nTmp = nRet % nMod;
     311             : 
     312           0 :         if ( nTmp >= 4 )
     313           0 :             nRet += 10 - nTmp;
     314           0 :         nRet /= 10;
     315             :     }
     316           0 :     return nRet * nFaktor / 20;
     317             : }
     318             : 
     319             : // -----------------------------------------------------------------------
     320             : 
     321           0 : long CMToTwips( long nIn )
     322             : {
     323           0 :     long nRet = 0;
     324             : 
     325           0 :     if ( nIn <= ( LONG_MAX / 567 ) && nIn >= ( LONG_MIN / 567 ) )
     326           0 :         nRet = nIn * 567;
     327           0 :     return nRet;
     328             : }
     329             : 
     330             : // -----------------------------------------------------------------------
     331             : 
     332           0 : long MMToTwips( long nIn )
     333             : {
     334           0 :     long nRet = 0;
     335             : 
     336           0 :     if ( nIn <= ( LONG_MAX / 567 ) && nIn >= ( LONG_MIN / 567 ) )
     337           0 :         nRet = nIn * 567 / 10;
     338           0 :     return nRet;
     339             : }
     340             : 
     341             : // -----------------------------------------------------------------------
     342             : 
     343           0 : long InchToTwips( long nIn )
     344             : {
     345           0 :     long nRet = 0;
     346             : 
     347           0 :     if ( nIn <= ( LONG_MAX / 1440 ) && nIn >= ( LONG_MIN / 1440 ) )
     348           0 :         nRet = nIn * 1440;
     349           0 :     return nRet;
     350             : }
     351             : 
     352             : // -----------------------------------------------------------------------
     353             : 
     354           0 : long PointToTwips( long nIn )
     355             : {
     356           0 :     long nRet = 0;
     357             : 
     358           0 :     if ( nIn <= ( LONG_MAX / 20 ) && nIn >= ( LONG_MIN / 20 ) )
     359           0 :         nRet = nIn * 20;
     360           0 :     return nRet;
     361             : }
     362             : 
     363             : // -----------------------------------------------------------------------
     364             : 
     365           0 : long PicaToTwips( long nIn )
     366             : {
     367           0 :     long nRet = 0;
     368             : 
     369           0 :     if ( nIn <= ( LONG_MAX / 240 ) && nIn >= ( LONG_MIN / 240 ) )
     370           0 :         nRet = nIn * 240;
     371           0 :     return nRet;
     372             : }
     373             : 
     374             : // -----------------------------------------------------------------------
     375             : 
     376           0 : long TwipsToCM( long nIn )
     377             : {
     378           0 :     long nRet = nIn / 567;
     379           0 :     return nRet;
     380             : }
     381             : 
     382             : // -----------------------------------------------------------------------
     383             : 
     384           0 : long InchToCM( long nIn )
     385             : {
     386           0 :     long nRet = 0;
     387             : 
     388           0 :     if ( nIn <= ( LONG_MAX / 254 ) && nIn >= ( LONG_MIN / 254 ) )
     389           0 :         nRet = nIn * 254 / 100;
     390           0 :     return nRet;
     391             : }
     392             : 
     393             : // -----------------------------------------------------------------------
     394             : 
     395           0 : long MMToCM( long nIn )
     396             : {
     397           0 :     long nRet = nIn / 10;
     398           0 :     return nRet;
     399             : }
     400             : 
     401             : // -----------------------------------------------------------------------
     402             : 
     403           0 : long PointToCM( long nIn )
     404             : {
     405           0 :     long nRet = 0;
     406             : 
     407           0 :     if ( nIn <= ( LONG_MAX / 20 ) && nIn >= ( LONG_MIN / 20 ) )
     408           0 :         nRet = nIn * 20 / 567;
     409           0 :     return nRet;
     410             : }
     411             : 
     412             : // -----------------------------------------------------------------------
     413             : 
     414           0 : long PicaToCM( long nIn)
     415             : {
     416           0 :     long nRet = 0;
     417             : 
     418           0 :     if ( nIn <= ( LONG_MAX / 12 / 20 ) && nIn >= ( LONG_MIN / 12 / 20 ) )
     419           0 :         nRet = nIn * 12 * 20 / 567;
     420           0 :     return nRet;
     421             : }
     422             : 
     423             : // -----------------------------------------------------------------------
     424             : 
     425           0 : long TwipsToMM( long nIn )
     426             : {
     427           0 :     long nRet = 0;
     428             : 
     429           0 :     if ( nIn <= ( LONG_MAX / 10 ) && nIn >= ( LONG_MIN / 10 ) )
     430           0 :         nRet = nIn * 10 / 566;
     431           0 :     return nRet;
     432             : }
     433             : 
     434             : // -----------------------------------------------------------------------
     435             : 
     436           0 : long CMToMM( long nIn )
     437             : {
     438           0 :     long nRet = 0;
     439             : 
     440           0 :     if ( nIn <= ( LONG_MAX / 10 ) && nIn >= ( LONG_MIN / 10 ) )
     441           0 :         nRet = nIn * 10;
     442           0 :     return nRet;
     443             : }
     444             : 
     445             : // -----------------------------------------------------------------------
     446             : 
     447           0 : long InchToMM( long nIn )
     448             : {
     449           0 :     long nRet = 0;
     450             : 
     451           0 :     if ( nIn <= ( LONG_MAX / 254 ) && nIn >= ( LONG_MIN / 254 ) )
     452           0 :         nRet = nIn * 254 / 10;
     453           0 :     return nRet;
     454             : }
     455             : 
     456             : // -----------------------------------------------------------------------
     457             : 
     458           0 : long PointToMM( long nIn )
     459             : {
     460           0 :     long nRet = 0;
     461             : 
     462           0 :     if ( nIn <= ( LONG_MAX / 200 ) && nIn >= ( LONG_MIN / 200 ) )
     463           0 :         nRet = nIn * 200 / 567;
     464           0 :     return nRet;
     465             : }
     466             : 
     467             : // -----------------------------------------------------------------------
     468             : 
     469           0 : long PicaToMM( long nIn )
     470             : {
     471           0 :     long nRet = 0;
     472             : 
     473           0 :     if ( nIn <= ( LONG_MAX / 12 / 200 ) && nIn >= ( LONG_MIN / 12 / 200 ) )
     474           0 :         nRet = nIn * 12 * 200 / 567;
     475           0 :     return nRet;
     476             : }
     477             : 
     478             : // -----------------------------------------------------------------------
     479             : 
     480           0 : long TwipsToInch( long nIn )
     481             : {
     482           0 :     long nRet = nIn / 1440;
     483           0 :     return nRet;
     484             : }
     485             : 
     486             : // -----------------------------------------------------------------------
     487             : 
     488           0 : long CMToInch( long nIn )
     489             : {
     490           0 :     long nRet = 0;
     491             : 
     492           0 :     if ( nIn <= ( LONG_MAX / 100 ) && nIn >= ( LONG_MIN / 100 ) )
     493           0 :         nRet = nIn * 100 / 254;
     494           0 :     return nRet;
     495             : }
     496             : 
     497             : // -----------------------------------------------------------------------
     498             : 
     499           0 : long MMToInch( long nIn )
     500             : {
     501           0 :     long nRet = 0;
     502             : 
     503           0 :     if ( nIn <= ( LONG_MAX / 10 ) && nIn >= ( LONG_MIN / 10 ) )
     504           0 :         nRet = nIn * 10 / 254;
     505           0 :     return nRet;
     506             : }
     507             : 
     508             : // -----------------------------------------------------------------------
     509             : 
     510           0 : long PointToInch( long nIn )
     511             : {
     512           0 :     long nRet = nIn / 72;
     513           0 :     return nRet;
     514             : }
     515             : 
     516             : // -----------------------------------------------------------------------
     517             : 
     518           0 : long PicaToInch( long nIn )
     519             : {
     520           0 :     long nRet = nIn / 6;
     521           0 :     return nRet;
     522             : }
     523             : 
     524             : // -----------------------------------------------------------------------
     525             : 
     526           0 : long TwipsToPoint( long nIn )
     527             : {
     528           0 :     long nRet = nIn / 20;
     529           0 :     return nRet;
     530             : }
     531             : 
     532             : // -----------------------------------------------------------------------
     533             : 
     534           0 : long InchToPoint( long nIn )
     535             : {
     536           0 :     long nRet = 0;
     537             : 
     538           0 :     if ( nIn <= ( LONG_MAX / 72 ) && nIn >= ( LONG_MIN / 72 ) )
     539           0 :         nRet = nIn * 72;
     540           0 :     return nRet;
     541             : }
     542             : 
     543             : // -----------------------------------------------------------------------
     544             : 
     545           0 : long CMToPoint( long nIn )
     546             : {
     547           0 :     long nRet = 0;
     548             : 
     549           0 :     if ( nIn <= ( LONG_MAX / 567 ) && nIn >= ( LONG_MIN / 567 ) )
     550           0 :         nRet = nIn * 567 / 20;
     551           0 :     return nRet;
     552             : }
     553             : 
     554             : // -----------------------------------------------------------------------
     555             : 
     556           0 : long MMToPoint( long nIn )
     557             : {
     558           0 :     long nRet = 0;
     559             : 
     560           0 :     if ( nIn <= ( LONG_MAX / 567 ) && nIn >= ( LONG_MIN / 567 ) )
     561           0 :         nRet = nIn * 567 / 200;
     562           0 :     return nRet;
     563             : }
     564             : 
     565             : // -----------------------------------------------------------------------
     566             : 
     567           0 : long PicaToPoint( long nIn )
     568             : {
     569           0 :     long nRet = nIn / 12;
     570           0 :     return nRet;
     571             : }
     572             : 
     573             : // -----------------------------------------------------------------------
     574             : 
     575           0 : long TwipsToPica( long nIn )
     576             : {
     577           0 :     long nRet = nIn / 240;
     578           0 :     return nRet;
     579             : }
     580             : 
     581             : // -----------------------------------------------------------------------
     582             : 
     583           0 : long InchToPica( long nIn )
     584             : {
     585           0 :     long nRet = 0;
     586             : 
     587           0 :     if ( nIn <= ( LONG_MAX / 6 ) && nIn >= ( LONG_MIN / 6 ) )
     588           0 :         nRet = nIn * 6;
     589           0 :     return nRet;
     590             : }
     591             : 
     592             : // -----------------------------------------------------------------------
     593             : 
     594           0 : long PointToPica( long nIn )
     595             : {
     596           0 :     long nRet = 0;
     597             : 
     598           0 :     if ( nIn <= ( LONG_MAX / 12 ) && nIn >= ( LONG_MIN / 12 ) )
     599           0 :         nRet = nIn * 12;
     600           0 :     return nRet;
     601             : }
     602             : 
     603             : // -----------------------------------------------------------------------
     604             : 
     605           0 : long CMToPica( long nIn )
     606             : {
     607           0 :     long nRet = 0;
     608             : 
     609           0 :     if ( nIn <= ( LONG_MAX / 567 ) && nIn >= ( LONG_MIN / 567 ) )
     610           0 :         nRet = nIn * 567 / 20 / 12;
     611           0 :     return nRet;
     612             : }
     613             : 
     614             : // -----------------------------------------------------------------------
     615             : 
     616           0 : long MMToPica( long nIn )
     617             : {
     618           0 :     long nRet = 0;
     619             : 
     620           0 :     if ( nIn <= ( LONG_MAX / 567 ) && nIn >= ( LONG_MIN / 567 ) )
     621           0 :         nRet = nIn * 567 / 200 / 12;
     622           0 :     return nRet;
     623             : }
     624             : 
     625             : // -----------------------------------------------------------------------
     626             : 
     627           0 : long Nothing( long nIn )
     628             : {
     629           0 :     long nRet = nIn;
     630           0 :     return nRet;
     631             : }
     632             : 
     633             : FUNC_CONVERT ConvertTable[6][6] =
     634             : {
     635             : //  CM,         MM          INCH         POINT        PICAS=32     TWIPS
     636             :     { Nothing,  CMToMM,     CMToInch,    CMToPoint,   CMToPica,    CMToTwips },
     637             :     { MMToCM,       Nothing,    MMToInch,    MMToPoint,   MMToPica,    MMToTwips },
     638             :     { InchToCM, InchToMM,   Nothing,     InchToPoint, InchToPica,  InchToTwips },
     639             :     { PointToCM,    PointToMM,  PointToInch, Nothing,     PointToPica, PointToTwips },
     640             :     { PicaToCM, PicaToMM,   PicaToInch,  PicaToPoint, Nothing,     PicaToTwips },
     641             :     { TwipsToCM,    TwipsToMM,  TwipsToInch, TwipsToPoint,TwipsToPica, Nothing }
     642             : };
     643             : 
     644             : // -----------------------------------------------------------------------
     645             : 
     646           0 : long TransformMetric( long nVal, FieldUnit aOld, FieldUnit aNew )
     647             : {
     648           0 :     if ( aOld == FUNIT_NONE   || aNew == FUNIT_NONE ||
     649             :          aOld == FUNIT_CUSTOM || aNew == FUNIT_CUSTOM )
     650             :     {
     651           0 :         return nVal;
     652             :     }
     653             : 
     654           0 :     sal_uInt16 nOld = 0;
     655           0 :     sal_uInt16 nNew = 0;
     656             : 
     657           0 :     switch ( aOld )
     658             :     {
     659             :         case FUNIT_CM:
     660           0 :             nOld = 0; break;
     661             :         case FUNIT_MM:
     662           0 :             nOld = 1; break;
     663             :         case FUNIT_INCH:
     664           0 :             nOld = 2; break;
     665             :         case FUNIT_POINT:
     666           0 :             nOld = 3; break;
     667             :         case FUNIT_PICA:
     668           0 :             nOld = 4; break;
     669             :         case FUNIT_TWIP:
     670           0 :             nOld = 5; break;
     671             :         default: ;//prevent warning
     672             :     }
     673             : 
     674           0 :     switch ( aNew )
     675             :     {
     676             :         case FUNIT_CM:
     677           0 :             nNew = 0; break;
     678             :         case FUNIT_MM:
     679           0 :             nNew = 1; break;
     680             :         case FUNIT_INCH:
     681           0 :             nNew = 2; break;
     682             :         case FUNIT_POINT:
     683           0 :             nNew = 3; break;
     684             :         case FUNIT_PICA:
     685           0 :             nNew = 4; break;
     686             :         case FUNIT_TWIP:
     687           0 :             nNew = 5; break;
     688             :         default: ;//prevent warning
     689             :     }
     690           0 :     return ConvertTable[nOld][nNew]( nVal );
     691             : }
     692             : 
     693             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10