goodies/source/filter.vcl/epgm/epgm.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: epgm.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 "dlgepgm.hrc"
  43 #include "dlgepgm.hxx"
  44
  45 //============================ PGMWriter ==================================
  46
  47 class PGMWriter {
  48
  49 private:
  50
  51     SvStream*                   mpOStm;                         // Die auszugebende PGM-Datei
  52     USHORT                              mpOStmOldModus;
  53
  54     BOOL                                mbStatus;
  55     UINT32                              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                         PGMWriter();
  67                         ~PGMWriter();
  68
  69     BOOL                                WritePGM( const Graphic& rGraphic, SvStream& rPGM, FilterConfigItem* pFilterConfigItem );
  70 };
  71
  72 //=================== Methoden von PGMWriter ==============================
  73
  74 PGMWriter::PGMWriter() :
  75     mbStatus    ( TRUE ),
  76     mpAcc               ( NULL )
  77 {
  78 }
  79
  80 // ------------------------------------------------------------------------
  81
  82 PGMWriter::~PGMWriter()
  83 {
  84 }
  85
  86 // ------------------------------------------------------------------------
  87
  88 BOOL PGMWriter::WritePGM( const Graphic& rGraphic, SvStream& rPGM, FilterConfigItem* pFilterConfigItem )
  89 {
  90
  91     mpOStm = &rPGM;
  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_8BIT_GREYS );
 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 PGMWriter::ImplWriteHeader()
 135 {
 136     mnWidth = mpAcc->Width();
 137     mnHeight = mpAcc->Height();
 138     if ( mnWidth && mnHeight )
 139     {
 140         if ( mnMode == 0 )
 141             *mpOStm << "P5\x0a";
 142         else
 143             *mpOStm << "P2\x0a";
 144
 145         ImplWriteNumber( mnWidth );
 146         *mpOStm << (BYTE)32;
 147         ImplWriteNumber( mnHeight );
 148         *mpOStm << (BYTE)32;
 149         ImplWriteNumber( 255 );                 // max. gray value
 150         *mpOStm << (BYTE)10;
 151     }
 152     else
 153         mbStatus = FALSE;
 154
 155     return mbStatus;
 156 }
 157
 158 // ------------------------------------------------------------------------
 159
 160 void PGMWriter::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                 *mpOStm << (BYTE)( mpAcc->GetPixel( y, x ) );
 169             }
 170         }
 171     }
 172     else
 173     {
 174         for ( ULONG y = 0; y < mnHeight; y++ )
 175         {
 176             int nCount = 70;
 177             for ( ULONG x = 0; x < mnWidth; x++ )
 178             {
 179                 BYTE nDat, nNumb;
 180                 if ( nCount < 0 )
 181                 {
 182                     nCount = 69;
 183                     *mpOStm << (BYTE)10;
 184                 }
 185                 nDat = (BYTE)mpAcc->GetPixel( y, x );
 186                 nNumb = nDat / 100;
 187                 if ( nNumb )
 188                 {
 189                     *mpOStm << (BYTE)( nNumb + '0' );
 190                     nDat -= ( nNumb * 100 );
 191                     nNumb = nDat / 10;
 192                     *mpOStm << (BYTE)( nNumb + '0' );
 193                     nDat -= ( nNumb * 10 );
 194                     *mpOStm << (BYTE)( nDat + '0' );
 195                     nCount -= 4;
 196                 }
 197                 else
 198                 {
 199                     nNumb = nDat / 10;
 200                     if ( nNumb )
 201                     {
 202                         *mpOStm << (BYTE)( nNumb + '0' );
 203                         nDat -= ( nNumb * 10 );
 204                         *mpOStm << (BYTE)( nDat + '0' );
 205                         nCount -= 3;
 206                     }
 207                     else
 208                     {
 209                         *mpOStm << (BYTE)( nDat + '0' );
 210                         nCount -= 2;
 211                     }
 212                 }
 213                 *mpOStm << (BYTE)' ';
 214             }
 215             *mpOStm << (BYTE)10;
 216         }
 217     }
 218 }
 219
 220 // ------------------------------------------------------------------------
 221 // eine Dezimalzahl im ASCII format wird in den Stream geschrieben
 222
 223 void PGMWriter::ImplWriteNumber( sal_Int32 nNumber )
 224 {
 225     const ByteString aNum( ByteString::CreateFromInt32( nNumber ) );
 226
 227     for( sal_Int16 n = 0UL, nLen = aNum.Len(); n < nLen; n++  )
 228         *mpOStm << aNum.GetChar( n );
 229
 230 }
 231
 232 // ------------------------------------------------------------------------
 233
 234 // ---------------------
 235 // - exported function -
 236 // ---------------------
 237
 238 extern "C" BOOL __LOADONCALLAPI GraphicExport( SvStream& rStream, Graphic& rGraphic, FilterConfigItem* pFilterConfigItem, BOOL )
 239 {
 240     PGMWriter aPGMWriter;
 241
 242     return aPGMWriter.WritePGM( rGraphic, rStream, pFilterConfigItem );
 243 }
 244
 245 // ------------------------------------------------------------------------
 246
 247 extern "C" BOOL __LOADONCALLAPI DoExportDialog( FltCallDialogParameter& rPara )
 248 {
 249     BOOL bRet = FALSE;
 250
 251     if ( rPara.pWindow )
 252     {
 253         ByteString      aResMgrName( "epg" );
 254         ResMgr* pResMgr;
 255
 256         pResMgr = ResMgr::CreateResMgr( aResMgrName.GetBuffer(), Application::GetSettings().GetUILocale() );
 257
 258         if( pResMgr )
 259         {
 260             rPara.pResMgr = pResMgr;
 261             bRet = ( DlgExportEPGM( rPara ).Execute() == RET_OK );
 262             delete pResMgr;
 263         }
 264         else
 265             bRet = TRUE;
 266     }
 267
 268     return bRet;
 269 }
 270
 271 // ------------------------------------------------------------------------
 272 #ifndef GCC
 273 #endif
 274
 275 // ---------------
 276 // - Win16 trash -
 277 // ---------------
 278
 279 #ifdef WIN
 280
 281 static HINSTANCE hDLLInst = 0;
 282
 283 extern "C" int CALLBACK LibMain( HINSTANCE hDLL, WORD, WORD nHeap, LPSTR )
 284 {
 285     if ( nHeap )
 286         UnlockData( 0 );
 287
 288     hDLLInst = hDLL;
 289
 290     return TRUE;
 291 }
 292
 293 // ------------------------------------------------------------------------
 294
 295 extern "C" int CALLBACK WEP( int )
 296 {
 297     return 1;
 298 }
 299
 300 #endif