goodies/source/filter.vcl/eppm/eppm.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: eppm.cxx,v $
  10  * $Revision: 1.12 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_goodies.hxx"
  33
  34 #include <vcl/svapp.hxx>
  35 #include <vcl/graph.hxx>
  36 #include <vcl/bmpacc.hxx>
  37 #include <vcl/msgbox.hxx>
  38 #include <svtools/solar.hrc>
  39 #include <svtools/fltcall.hxx>
  40 #include <svtools/FilterConfigItem.hxx>
  41 #include "strings.hrc"
  42 #include "dlgeppm.hrc"
  43 #include "dlgeppm.hxx"
  44
  45 //============================ PPMWriter ==================================
  46
  47 class PPMWriter {
  48
  49 private:
  50
  51     SvStream*                   mpOStm;                         // Die auszugebende PPM-Datei
  52     USHORT                              mpOStmOldModus;
  53
  54     BOOL                                mbStatus;
  55     sal_Int32                   mnMode;
  56     BitmapReadAccess*   mpAcc;
  57     ULONG                               mnWidth, mnHeight;      // Bildausmass in Pixeln
  58
  59     BOOL                                ImplWriteHeader();
  60     void                                ImplWriteBody();
  61     void                                ImplWriteNumber( sal_Int32 );
  62
  63     com::sun::star::uno::Reference< com::sun::star::task::XStatusIndicator > xStatusIndicator;
  64
  65 public:
  66                         PPMWriter();
  67                         ~PPMWriter();
  68
  69     BOOL                                WritePPM( const Graphic& rGraphic, SvStream& rPPM, FilterConfigItem* pFilterConfigItem );
  70 };
  71
  72 //=================== Methoden von PPMWriter ==============================
  73
  74 PPMWriter::PPMWriter() :
  75     mbStatus    ( TRUE ),
  76     mpAcc               ( NULL )
  77 {
  78 }
  79
  80 // ------------------------------------------------------------------------
  81
  82 PPMWriter::~PPMWriter()
  83 {
  84 }
  85
  86 // ------------------------------------------------------------------------
  87
  88 BOOL PPMWriter::WritePPM( const Graphic& rGraphic, SvStream& rPPM, FilterConfigItem* pFilterConfigItem )
  89 {
  90
  91     mpOStm = &rPPM;
  92
  93     if ( pFilterConfigItem )
  94     {
  95         mnMode = pFilterConfigItem->ReadInt32( String( RTL_CONSTASCII_USTRINGPARAM( "FileFormat" ) ), 0 );
  96
  97         xStatusIndicator = pFilterConfigItem->GetStatusIndicator();
  98         if ( xStatusIndicator.is() )
  99         {
 100             rtl::OUString aMsg;
 101             xStatusIndicator->start( aMsg, 100 );
 102         }
 103     }
 104
 105     BitmapEx    aBmpEx( rGraphic.GetBitmapEx() );
 106     Bitmap              aBmp = aBmpEx.GetBitmap();
 107     aBmp.Convert( BMP_CONVERSION_24BIT );
 108
 109     mpOStmOldModus = mpOStm->GetNumberFormatInt();
 110     mpOStm->SetNumberFormatInt( NUMBERFORMAT_INT_BIGENDIAN );
 111
 112     mpAcc = aBmp.AcquireReadAccess();
 113     if( mpAcc )
 114     {
 115         if ( ImplWriteHeader() )
 116         {
 117             ImplWriteBody();
 118         }
 119         aBmp.ReleaseAccess( mpAcc );
 120     }
 121     else
 122         mbStatus = FALSE;
 123
 124     mpOStm->SetNumberFormatInt( mpOStmOldModus );
 125
 126     if ( xStatusIndicator.is() )
 127         xStatusIndicator->end();
 128
 129     return mbStatus;
 130 }
 131
 132 // ------------------------------------------------------------------------
 133
 134 BOOL PPMWriter::ImplWriteHeader()
 135 {
 136     mnWidth = mpAcc->Width();
 137     mnHeight = mpAcc->Height();
 138     if ( mnWidth && mnHeight )
 139     {
 140         if ( mnMode == 0 )
 141             *mpOStm << "P6\x0a";
 142         else
 143             *mpOStm << "P3\x0a";
 144
 145         ImplWriteNumber( mnWidth );
 146         *mpOStm << (BYTE)32;
 147         ImplWriteNumber( mnHeight );
 148         *mpOStm << (BYTE)32;
 149         ImplWriteNumber( 255 );                 // max. col.
 150         *mpOStm << (BYTE)10;
 151     }
 152     else
 153         mbStatus = FALSE;
 154
 155     return mbStatus;
 156 }
 157
 158 // ------------------------------------------------------------------------
 159
 160 void PPMWriter::ImplWriteBody()
 161 {
 162     if ( mnMode == 0 )
 163     {
 164         for ( ULONG y = 0; y < mnHeight; y++ )
 165         {
 166             for ( ULONG x = 0; x < mnWidth; x++ )
 167             {
 168                 const BitmapColor& rColor = mpAcc->GetPixel( y, x );
 169                 *mpOStm << rColor.GetRed();
 170                 *mpOStm << rColor.GetGreen();
 171                 *mpOStm << rColor.GetBlue();
 172             }
 173         }
 174     }
 175     else
 176     {
 177         for ( ULONG y = 0; y < mnHeight; y++ )
 178         {
 179             int nCount = 70;
 180             for ( ULONG x = 0; x < mnWidth; x++ )
 181             {
 182                 BYTE i, nDat[3], nNumb;
 183                 if ( nCount < 0 )
 184                 {
 185                     nCount = 69;
 186                     *mpOStm << (BYTE)10;
 187                 }
 188                 nDat[0] = mpAcc->GetPixel( y, x ).GetRed();
 189                 nDat[1] = mpAcc->GetPixel( y, x ).GetGreen();
 190                 nDat[2] = mpAcc->GetPixel( y, x ).GetBlue();
 191                 for ( i = 0; i < 3; i++ )
 192                 {
 193                     nNumb = nDat[ i ] / 100;
 194                     if ( nNumb )
 195                     {
 196                         *mpOStm << (BYTE)( nNumb + '0' );
 197                         nDat[ i ] -= ( nNumb * 100 );
 198                         nNumb = nDat[ i ] / 10;
 199                         *mpOStm << (BYTE)( nNumb + '0' );
 200                         nDat[ i ] -= ( nNumb * 10 );
 201                         *mpOStm << (BYTE)( nDat[ i ] + '0' );
 202                         nCount -= 4;
 203                     }
 204                     else
 205                     {
 206                         nNumb = nDat[ i ] / 10;
 207                         if ( nNumb )
 208                         {
 209                             *mpOStm << (BYTE)( nNumb + '0' );
 210                             nDat[ i ] -= ( nNumb * 10 );
 211                             *mpOStm << (BYTE)( nDat[ i ] + '0' );
 212                             nCount -= 3;
 213                         }
 214                         else
 215                         {
 216                             *mpOStm << (BYTE)( nDat[ i ] + '0' );
 217                             nCount -= 2;
 218                         }
 219                     }
 220                     *mpOStm << (BYTE)' ';
 221                 }
 222             }
 223             *mpOStm << (BYTE)10;
 224         }
 225     }
 226 }
 227
 228 // ------------------------------------------------------------------------
 229 // eine Dezimalzahl im ASCII format wird in den Stream geschrieben
 230
 231 void PPMWriter::ImplWriteNumber( sal_Int32 nNumber )
 232 {
 233     const ByteString aNum( ByteString::CreateFromInt32( nNumber ) );
 234
 235     for( sal_Int16 n = 0, nLen = aNum.Len(); n < nLen; n++  )
 236         *mpOStm << aNum.GetChar( n );
 237
 238 }
 239
 240 // ------------------------------------------------------------------------
 241
 242 // ---------------------
 243 // - exported function -
 244 // ---------------------
 245
 246 extern "C" BOOL __LOADONCALLAPI GraphicExport( SvStream& rStream, Graphic& rGraphic, FilterConfigItem* pFilterConfigItem, BOOL )
 247 {
 248     PPMWriter aPPMWriter;
 249     return aPPMWriter.WritePPM( rGraphic, rStream, pFilterConfigItem );
 250 }
 251
 252 // ------------------------------------------------------------------------
 253
 254 extern "C" BOOL __LOADONCALLAPI DoExportDialog( FltCallDialogParameter& rPara )
 255 {
 256     BOOL bRet = FALSE;
 257
 258     if ( rPara.pWindow )
 259     {
 260         ByteString      aResMgrName( "epp" );
 261         ResMgr* pResMgr;
 262
 263         pResMgr = ResMgr::CreateResMgr( aResMgrName.GetBuffer(), Application::GetSettings().GetUILocale() );
 264
 265         if( pResMgr )
 266         {
 267             rPara.pResMgr = pResMgr;
 268             bRet = ( DlgExportEPPM( rPara ).Execute() == RET_OK );
 269             delete pResMgr;
 270         }
 271         else
 272             bRet = TRUE;
 273     }
 274
 275     return bRet;
 276 }
 277
 278 #ifndef GCC
 279 #endif
 280
 281 // ------------------------------------------------------------------------
 282
 283 // ---------------
 284 // - Win16 trash -
 285 // ---------------
 286
 287 #ifdef WIN
 288
 289 static HINSTANCE hDLLInst = 0;
 290
 291 extern "C" int CALLBACK LibMain( HINSTANCE hDLL, WORD, WORD nHeap, LPSTR )
 292 {
 293     if ( nHeap )
 294         UnlockData( 0 );
 295
 296     hDLLInst = hDLL;
 297
 298     return TRUE;
 299 }
 300
 301 // ------------------------------------------------------------------------
 302
 303 extern "C" int CALLBACK WEP( int )
 304 {
 305     return 1;
 306 }
 307
 308 #endif