| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_vcl.hxx" |
| |
| #include <stdlib.h> |
| #include <stdio.h> |
| |
| #include <hash_map> |
| |
| #include "vcl/ppdparser.hxx" |
| #include "vcl/strhelper.hxx" |
| #include "vcl/helper.hxx" |
| #include "vcl/svapp.hxx" |
| #include "cupsmgr.hxx" |
| #include "tools/debug.hxx" |
| #include "tools/urlobj.hxx" |
| #include "tools/stream.hxx" |
| #include "tools/zcodec.hxx" |
| #include "osl/mutex.hxx" |
| #include "osl/file.hxx" |
| #include "osl/process.h" |
| #include "osl/thread.h" |
| #include "rtl/strbuf.hxx" |
| #include "rtl/ustrbuf.hxx" |
| |
| #include "com/sun/star/lang/Locale.hpp" |
| |
| namespace psp |
| { |
| class PPDTranslator |
| { |
| struct LocaleEqual |
| { |
| bool operator()(const com::sun::star::lang::Locale& i_rLeft, |
| const com::sun::star::lang::Locale& i_rRight) const |
| { |
| return i_rLeft.Language.equals( i_rRight.Language ) && |
| i_rLeft.Country.equals( i_rRight.Country ) && |
| i_rLeft.Variant.equals( i_rRight.Variant ); |
| } |
| }; |
| |
| struct LocaleHash |
| { |
| size_t operator()(const com::sun::star::lang::Locale& rLocale) const |
| { return |
| (size_t)rLocale.Language.hashCode() |
| ^ (size_t)rLocale.Country.hashCode() |
| ^ (size_t)rLocale.Variant.hashCode() |
| ; |
| } |
| }; |
| |
| typedef std::hash_map< com::sun::star::lang::Locale, rtl::OUString, LocaleHash, LocaleEqual > translation_map; |
| typedef std::hash_map< rtl::OUString, translation_map, rtl::OUStringHash > key_translation_map; |
| |
| key_translation_map m_aTranslations; |
| public: |
| PPDTranslator() {} |
| ~PPDTranslator() {} |
| |
| |
| void insertValue( |
| const rtl::OUString& i_rKey, |
| const rtl::OUString& i_rOption, |
| const rtl::OUString& i_rValue, |
| const rtl::OUString& i_rTranslation, |
| const com::sun::star::lang::Locale& i_rLocale = com::sun::star::lang::Locale() |
| ); |
| |
| void insertOption( const rtl::OUString& i_rKey, |
| const rtl::OUString& i_rOption, |
| const rtl::OUString& i_rTranslation, |
| const com::sun::star::lang::Locale& i_rLocale = com::sun::star::lang::Locale() ) |
| { |
| insertValue( i_rKey, i_rOption, rtl::OUString(), i_rTranslation, i_rLocale ); |
| } |
| |
| void insertKey( const rtl::OUString& i_rKey, |
| const rtl::OUString& i_rTranslation, |
| const com::sun::star::lang::Locale& i_rLocale = com::sun::star::lang::Locale() ) |
| { |
| insertValue( i_rKey, rtl::OUString(), rtl::OUString(), i_rTranslation, i_rLocale ); |
| } |
| |
| rtl::OUString translateValue( |
| const rtl::OUString& i_rKey, |
| const rtl::OUString& i_rOption, |
| const rtl::OUString& i_rValue, |
| const com::sun::star::lang::Locale& i_rLocale = com::sun::star::lang::Locale() |
| ) const; |
| |
| rtl::OUString translateOption( const rtl::OUString& i_rKey, |
| const rtl::OUString& i_rOption, |
| const com::sun::star::lang::Locale& i_rLocale = com::sun::star::lang::Locale() ) const |
| { |
| return translateValue( i_rKey, i_rOption, rtl::OUString(), i_rLocale ); |
| } |
| |
| rtl::OUString translateKey( const rtl::OUString& i_rKey, |
| const com::sun::star::lang::Locale& i_rLocale = com::sun::star::lang::Locale() ) const |
| { |
| return translateValue( i_rKey, rtl::OUString(), rtl::OUString(), i_rLocale ); |
| } |
| }; |
| |
| static com::sun::star::lang::Locale normalizeInputLocale( |
| const com::sun::star::lang::Locale& i_rLocale, |
| bool bInsertDefault = false |
| ) |
| { |
| com::sun::star::lang::Locale aLoc( i_rLocale ); |
| if( bInsertDefault && aLoc.Language.getLength() == 0 ) |
| { |
| // empty locale requested, fill in application UI locale |
| aLoc = Application::GetSettings().GetUILocale(); |
| |
| #if OSL_DEBUG_LEVEL > 1 |
| static const char* pEnvLocale = getenv( "SAL_PPDPARSER_LOCALE" ); |
| if( pEnvLocale && *pEnvLocale ) |
| { |
| rtl::OString aStr( pEnvLocale ); |
| sal_Int32 nLen = aStr.getLength(); |
| aLoc.Language = rtl::OStringToOUString( aStr.copy( 0, nLen > 2 ? 2 : nLen ), RTL_TEXTENCODING_MS_1252 ); |
| if( nLen >=5 && aStr.getStr()[2] == '_' ) |
| aLoc.Country = rtl::OStringToOUString( aStr.copy( 3, 2 ), RTL_TEXTENCODING_MS_1252 ); |
| else |
| aLoc.Country = rtl::OUString(); |
| aLoc.Variant = rtl::OUString(); |
| } |
| #endif |
| } |
| aLoc.Language = aLoc.Language.toAsciiLowerCase(); |
| aLoc.Country = aLoc.Country.toAsciiUpperCase(); |
| aLoc.Variant = aLoc.Variant.toAsciiUpperCase(); |
| |
| return aLoc; |
| } |
| |
| void PPDTranslator::insertValue( |
| const rtl::OUString& i_rKey, |
| const rtl::OUString& i_rOption, |
| const rtl::OUString& i_rValue, |
| const rtl::OUString& i_rTranslation, |
| const com::sun::star::lang::Locale& i_rLocale |
| ) |
| { |
| rtl::OUStringBuffer aKey( i_rKey.getLength() + i_rOption.getLength() + i_rValue.getLength() + 2 ); |
| aKey.append( i_rKey ); |
| if( i_rOption.getLength() || i_rValue.getLength() ) |
| { |
| aKey.append( sal_Unicode( ':' ) ); |
| aKey.append( i_rOption ); |
| } |
| if( i_rValue.getLength() ) |
| { |
| aKey.append( sal_Unicode( ':' ) ); |
| aKey.append( i_rValue ); |
| } |
| if( aKey.getLength() && i_rTranslation.getLength() ) |
| { |
| rtl::OUString aK( aKey.makeStringAndClear() ); |
| com::sun::star::lang::Locale aLoc; |
| aLoc.Language = i_rLocale.Language.toAsciiLowerCase(); |
| aLoc.Country = i_rLocale.Country.toAsciiUpperCase(); |
| aLoc.Variant = i_rLocale.Variant.toAsciiUpperCase(); |
| m_aTranslations[ aK ][ aLoc ] = i_rTranslation; |
| } |
| } |
| |
| rtl::OUString PPDTranslator::translateValue( |
| const rtl::OUString& i_rKey, |
| const rtl::OUString& i_rOption, |
| const rtl::OUString& i_rValue, |
| const com::sun::star::lang::Locale& i_rLocale |
| ) const |
| { |
| rtl::OUString aResult; |
| |
| rtl::OUStringBuffer aKey( i_rKey.getLength() + i_rOption.getLength() + i_rValue.getLength() + 2 ); |
| aKey.append( i_rKey ); |
| if( i_rOption.getLength() || i_rValue.getLength() ) |
| { |
| aKey.append( sal_Unicode( ':' ) ); |
| aKey.append( i_rOption ); |
| } |
| if( i_rValue.getLength() ) |
| { |
| aKey.append( sal_Unicode( ':' ) ); |
| aKey.append( i_rValue ); |
| } |
| if( aKey.getLength() ) |
| { |
| rtl::OUString aK( aKey.makeStringAndClear() ); |
| key_translation_map::const_iterator it = m_aTranslations.find( aK ); |
| if( it != m_aTranslations.end() ) |
| { |
| const translation_map& rMap( it->second ); |
| |
| com::sun::star::lang::Locale aLoc( normalizeInputLocale( i_rLocale, true ) ); |
| for( int nTry = 0; nTry < 4; nTry++ ) |
| { |
| translation_map::const_iterator tr = rMap.find( aLoc ); |
| if( tr != rMap.end() ) |
| { |
| aResult = tr->second; |
| break; |
| } |
| switch( nTry ) |
| { |
| case 0: aLoc.Variant = rtl::OUString();break; |
| case 1: aLoc.Country = rtl::OUString();break; |
| case 2: aLoc.Language = rtl::OUString();break; |
| } |
| } |
| } |
| } |
| return aResult; |
| } |
| } |
| |
| using namespace psp; |
| using namespace rtl; |
| |
| #undef DBG_ASSERT |
| #if defined DBG_UTIL || (OSL_DEBUG_LEVEL > 1) |
| #define BSTRING(x) ByteString( x, osl_getThreadTextEncoding() ) |
| #define DBG_ASSERT( x, y ) { if( ! (x) ) fprintf( stderr, (y) ); } |
| #else |
| #define DBG_ASSERT( x, y ) |
| #endif |
| |
| std::list< PPDParser* > PPDParser::aAllParsers; |
| std::hash_map< OUString, OUString, OUStringHash >* PPDParser::pAllPPDFiles = NULL; |
| |
| class PPDDecompressStream |
| { |
| SvFileStream* mpFileStream; |
| SvMemoryStream* mpMemStream; |
| rtl::OUString maFileName; |
| |
| // forbid copying |
| PPDDecompressStream( const PPDDecompressStream& ); |
| PPDDecompressStream& operator=(const PPDDecompressStream& ); |
| |
| public: |
| PPDDecompressStream( const rtl::OUString& rFile ); |
| ~PPDDecompressStream(); |
| |
| bool IsOpen() const; |
| bool IsEof() const; |
| void ReadLine( ByteString& o_rLine); |
| void Open( const rtl::OUString& i_rFile ); |
| void Close(); |
| const rtl::OUString& GetFileName() const { return maFileName; } |
| }; |
| |
| PPDDecompressStream::PPDDecompressStream( const rtl::OUString& i_rFile ) : |
| mpFileStream( NULL ), |
| mpMemStream( NULL ) |
| { |
| Open( i_rFile ); |
| } |
| |
| PPDDecompressStream::~PPDDecompressStream() |
| { |
| Close(); |
| } |
| |
| void PPDDecompressStream::Open( const rtl::OUString& i_rFile ) |
| { |
| Close(); |
| |
| mpFileStream = new SvFileStream( i_rFile, STREAM_READ ); |
| maFileName = mpFileStream->GetFileName(); |
| |
| if( ! mpFileStream->IsOpen() ) |
| { |
| Close(); |
| return; |
| } |
| |
| ByteString aLine; |
| mpFileStream->ReadLine( aLine ); |
| mpFileStream->Seek( 0 ); |
| |
| // check for compress'ed or gzip'ed file |
| sal_uLong nCompressMethod = 0; |
| if( aLine.Len() > 1 && static_cast<unsigned char>(aLine.GetChar( 0 )) == 0x1f ) |
| { |
| if( static_cast<unsigned char>(aLine.GetChar( 1 )) == 0x8b ) // check for gzip |
| nCompressMethod = ZCODEC_DEFAULT | ZCODEC_GZ_LIB; |
| } |
| |
| if( nCompressMethod != 0 ) |
| { |
| // so let's try to decompress the stream |
| mpMemStream = new SvMemoryStream( 4096, 4096 ); |
| ZCodec aCodec; |
| aCodec.BeginCompression( nCompressMethod ); |
| long nComp = aCodec.Decompress( *mpFileStream, *mpMemStream ); |
| aCodec.EndCompression(); |
| if( nComp < 0 ) |
| { |
| // decompression failed, must be an uncompressed stream after all |
| delete mpMemStream, mpMemStream = NULL; |
| mpFileStream->Seek( 0 ); |
| } |
| else |
| { |
| // compression successfull, can get rid of file stream |
| delete mpFileStream, mpFileStream = NULL; |
| mpMemStream->Seek( 0 ); |
| } |
| } |
| } |
| |
| void PPDDecompressStream::Close() |
| { |
| delete mpMemStream, mpMemStream = NULL; |
| delete mpFileStream, mpFileStream = NULL; |
| } |
| |
| bool PPDDecompressStream::IsOpen() const |
| { |
| return (mpMemStream || (mpFileStream && mpFileStream->IsOpen())); |
| } |
| |
| bool PPDDecompressStream::IsEof() const |
| { |
| return ( mpMemStream ? mpMemStream->IsEof() : ( mpFileStream ? mpFileStream->IsEof() : true ) ); |
| } |
| |
| void PPDDecompressStream::ReadLine( ByteString& o_rLine ) |
| { |
| if( mpMemStream ) |
| mpMemStream->ReadLine( o_rLine ); |
| else if( mpFileStream ) |
| mpFileStream->ReadLine( o_rLine ); |
| } |
| |
| static osl::FileBase::RC resolveLink( const rtl::OUString& i_rURL, rtl::OUString& o_rResolvedURL, rtl::OUString& o_rBaseName, osl::FileStatus::Type& o_rType, int nLinkLevel = 10 ) |
| { |
| osl::DirectoryItem aLinkItem; |
| osl::FileBase::RC aRet = osl::FileBase::E_None; |
| |
| if( ( aRet = osl::DirectoryItem::get( i_rURL, aLinkItem ) ) == osl::FileBase::E_None ) |
| { |
| osl::FileStatus aStatus( FileStatusMask_FileName | FileStatusMask_Type | FileStatusMask_LinkTargetURL ); |
| if( ( aRet = aLinkItem.getFileStatus( aStatus ) ) == osl::FileBase::E_None ) |
| { |
| if( aStatus.getFileType() == osl::FileStatus::Link ) |
| { |
| if( nLinkLevel > 0 ) |
| aRet = resolveLink( aStatus.getLinkTargetURL(), o_rResolvedURL, o_rBaseName, o_rType, nLinkLevel-1 ); |
| else |
| aRet = osl::FileBase::E_MULTIHOP; |
| } |
| else |
| { |
| o_rResolvedURL = i_rURL; |
| o_rBaseName = aStatus.getFileName(); |
| o_rType = aStatus.getFileType(); |
| } |
| } |
| } |
| return aRet; |
| } |
| |
| void PPDParser::scanPPDDir( const String& rDir ) |
| { |
| static struct suffix_t |
| { |
| const sal_Char* pSuffix; |
| const sal_Int32 nSuffixLen; |
| } const pSuffixes[] = |
| { { ".PS", 3 }, { ".PPD", 4 }, { ".PS.GZ", 6 }, { ".PPD.GZ", 7 } }; |
| |
| const int nSuffixes = sizeof(pSuffixes)/sizeof(pSuffixes[0]); |
| |
| osl::Directory aDir( rDir ); |
| if ( aDir.open() == osl::FileBase::E_None ) |
| { |
| osl::DirectoryItem aItem; |
| |
| INetURLObject aPPDDir(rDir); |
| while( aDir.getNextItem( aItem ) == osl::FileBase::E_None ) |
| { |
| osl::FileStatus aStatus( FileStatusMask_FileName ); |
| if( aItem.getFileStatus( aStatus ) == osl::FileBase::E_None ) |
| { |
| rtl::OUStringBuffer aURLBuf( rDir.Len() + 64 ); |
| aURLBuf.append( rDir ); |
| aURLBuf.append( sal_Unicode( '/' ) ); |
| aURLBuf.append( aStatus.getFileName() ); |
| |
| rtl::OUString aFileURL, aFileName; |
| osl::FileStatus::Type eType = osl::FileStatus::Unknown; |
| |
| if( resolveLink( aURLBuf.makeStringAndClear(), aFileURL, aFileName, eType ) == osl::FileBase::E_None ) |
| { |
| if( eType == osl::FileStatus::Regular ) |
| { |
| INetURLObject aPPDFile = aPPDDir; |
| aPPDFile.Append( aFileName ); |
| |
| // match extension |
| for( int nSuffix = 0; nSuffix < nSuffixes; nSuffix++ ) |
| { |
| if( aFileName.getLength() > pSuffixes[nSuffix].nSuffixLen ) |
| { |
| if( aFileName.endsWithIgnoreAsciiCaseAsciiL( pSuffixes[nSuffix].pSuffix, pSuffixes[nSuffix].nSuffixLen ) ) |
| { |
| (*pAllPPDFiles)[ aFileName.copy( 0, aFileName.getLength() - pSuffixes[nSuffix].nSuffixLen ) ] = aPPDFile.PathToFileName(); |
| break; |
| } |
| } |
| } |
| } |
| else if( eType == osl::FileStatus::Directory ) |
| { |
| scanPPDDir( aFileURL ); |
| } |
| } |
| } |
| } |
| aDir.close(); |
| } |
| } |
| |
| void PPDParser::initPPDFiles() |
| { |
| if( pAllPPDFiles ) |
| return; |
| |
| pAllPPDFiles = new std::hash_map< OUString, OUString, OUStringHash >(); |
| |
| // check installation directories |
| std::list< OUString > aPathList; |
| psp::getPrinterPathList( aPathList, PRINTER_PPDDIR ); |
| for( std::list< OUString >::const_iterator ppd_it = aPathList.begin(); ppd_it != aPathList.end(); ++ppd_it ) |
| { |
| INetURLObject aPPDDir( *ppd_it, INET_PROT_FILE, INetURLObject::ENCODE_ALL ); |
| scanPPDDir( aPPDDir.GetMainURL( INetURLObject::NO_DECODE ) ); |
| } |
| if( pAllPPDFiles->find( OUString( RTL_CONSTASCII_USTRINGPARAM( "SGENPRT" ) ) ) == pAllPPDFiles->end() ) |
| { |
| // last try: search in directory of executable (mainly for setup) |
| OUString aExe; |
| if( osl_getExecutableFile( &aExe.pData ) == osl_Process_E_None ) |
| { |
| INetURLObject aDir( aExe ); |
| aDir.removeSegment(); |
| #ifdef DEBUG |
| fprintf( stderr, "scanning last chance dir: %s\n", OUStringToOString( aDir.GetMainURL( INetURLObject::NO_DECODE ), osl_getThreadTextEncoding() ).getStr() ); |
| #endif |
| scanPPDDir( aDir.GetMainURL( INetURLObject::NO_DECODE ) ); |
| #ifdef DEBUG |
| fprintf( stderr, "SGENPRT %s\n", pAllPPDFiles->find( OUString( RTL_CONSTASCII_USTRINGPARAM( "SGENPRT" ) ) ) == pAllPPDFiles->end() ? "not found" : "found" ); |
| #endif |
| } |
| } |
| } |
| |
| void PPDParser::getKnownPPDDrivers( std::list< rtl::OUString >& o_rDrivers, bool bRefresh ) |
| { |
| if( bRefresh ) |
| { |
| delete pAllPPDFiles; |
| pAllPPDFiles = NULL; |
| } |
| |
| initPPDFiles(); |
| o_rDrivers.clear(); |
| |
| std::hash_map< OUString, OUString, OUStringHash >::const_iterator it; |
| for( it = pAllPPDFiles->begin(); it != pAllPPDFiles->end(); ++it ) |
| o_rDrivers.push_back( it->first ); |
| } |
| |
| String PPDParser::getPPDFile( const String& rFile ) |
| { |
| INetURLObject aPPD( rFile, INET_PROT_FILE, INetURLObject::ENCODE_ALL ); |
| // someone might enter a full qualified name here |
| PPDDecompressStream aStream( aPPD.PathToFileName() ); |
| if( ! aStream.IsOpen() ) |
| { |
| std::hash_map< OUString, OUString, OUStringHash >::const_iterator it; |
| |
| bool bRetry = true; |
| do |
| { |
| initPPDFiles(); |
| // some PPD files contain dots beside the extension, so try name first |
| // and cut of points after that |
| rtl::OUString aBase( rFile ); |
| sal_Int32 nLastIndex = aBase.lastIndexOf( sal_Unicode( '/' ) ); |
| if( nLastIndex >= 0 ) |
| aBase = aBase.copy( nLastIndex+1 ); |
| do |
| { |
| it = pAllPPDFiles->find( aBase ); |
| nLastIndex = aBase.lastIndexOf( sal_Unicode( '.' ) ); |
| if( nLastIndex > 0 ) |
| aBase = aBase.copy( 0, nLastIndex ); |
| } while( it == pAllPPDFiles->end() && nLastIndex > 0 ); |
| |
| if( it == pAllPPDFiles->end() && bRetry ) |
| { |
| // a new file ? rehash |
| delete pAllPPDFiles; pAllPPDFiles = NULL; |
| bRetry = false; |
| // note this is optimized for office start where |
| // no new files occur and initPPDFiles is called only once |
| } |
| } while( ! pAllPPDFiles ); |
| |
| if( it != pAllPPDFiles->end() ) |
| aStream.Open( it->second ); |
| } |
| |
| String aRet; |
| if( aStream.IsOpen() ) |
| { |
| ByteString aLine; |
| aStream.ReadLine( aLine ); |
| if( aLine.Search( "*PPD-Adobe" ) == 0 ) |
| aRet = aStream.GetFileName(); |
| else |
| { |
| // our *Include hack does usually not begin |
| // with *PPD-Adobe, so try some lines for *Include |
| int nLines = 10; |
| while( aLine.Search( "*Include" ) != 0 && --nLines ) |
| aStream.ReadLine( aLine ); |
| if( nLines ) |
| aRet = aStream.GetFileName(); |
| } |
| } |
| |
| return aRet; |
| } |
| |
| String PPDParser::getPPDPrinterName( const String& rFile ) |
| { |
| String aPath = getPPDFile( rFile ); |
| String aName; |
| |
| // read in the file |
| PPDDecompressStream aStream( aPath ); |
| if( aStream.IsOpen() ) |
| { |
| String aCurLine; |
| while( ! aStream.IsEof() && aStream.IsOpen() ) |
| { |
| ByteString aByteLine; |
| aStream.ReadLine( aByteLine ); |
| aCurLine = String( aByteLine, RTL_TEXTENCODING_MS_1252 ); |
| if( aCurLine.CompareIgnoreCaseToAscii( "*include:", 9 ) == COMPARE_EQUAL ) |
| { |
| aCurLine.Erase( 0, 9 ); |
| aCurLine.EraseLeadingChars( ' ' ); |
| aCurLine.EraseTrailingChars( ' ' ); |
| aCurLine.EraseLeadingChars( '\t' ); |
| aCurLine.EraseTrailingChars( '\t' ); |
| aCurLine.EraseTrailingChars( '\r' ); |
| aCurLine.EraseTrailingChars( '\n' ); |
| aCurLine.EraseLeadingChars( '"' ); |
| aCurLine.EraseTrailingChars( '"' ); |
| aStream.Close(); |
| aStream.Open( getPPDFile( aCurLine ) ); |
| continue; |
| } |
| if( aCurLine.CompareToAscii( "*ModelName:", 11 ) == COMPARE_EQUAL ) |
| { |
| aName = aCurLine.GetToken( 1, '"' ); |
| break; |
| } |
| else if( aCurLine.CompareToAscii( "*NickName:", 10 ) == COMPARE_EQUAL ) |
| aName = aCurLine.GetToken( 1, '"' ); |
| } |
| } |
| return aName; |
| } |
| |
| const PPDParser* PPDParser::getParser( const String& rFile ) |
| { |
| static ::osl::Mutex aMutex; |
| ::osl::Guard< ::osl::Mutex > aGuard( aMutex ); |
| |
| String aFile = rFile; |
| if( rFile.CompareToAscii( "CUPS:", 5 ) != COMPARE_EQUAL ) |
| aFile = getPPDFile( rFile ); |
| if( ! aFile.Len() ) |
| { |
| #if OSL_DEBUG_LEVEL > 1 |
| fprintf( stderr, "Could not get printer PPD file \"%s\" !\n", OUStringToOString( rFile, osl_getThreadTextEncoding() ).getStr() ); |
| #endif |
| return NULL; |
| } |
| |
| for( ::std::list< PPDParser* >::const_iterator it = aAllParsers.begin(); it != aAllParsers.end(); ++it ) |
| if( (*it)->m_aFile == aFile ) |
| return *it; |
| |
| PPDParser* pNewParser = NULL; |
| if( aFile.CompareToAscii( "CUPS:", 5 ) != COMPARE_EQUAL ) |
| pNewParser = new PPDParser( aFile ); |
| else |
| { |
| PrinterInfoManager& rMgr = PrinterInfoManager::get(); |
| if( rMgr.getType() == PrinterInfoManager::CUPS ) |
| { |
| pNewParser = const_cast<PPDParser*>(static_cast<CUPSManager&>(rMgr).createCUPSParser( aFile )); |
| } |
| } |
| if( pNewParser ) |
| { |
| // this may actually be the SGENPRT parser, |
| // so ensure uniquness here |
| aAllParsers.remove( pNewParser ); |
| // insert new parser to list |
| aAllParsers.push_front( pNewParser ); |
| } |
| return pNewParser; |
| } |
| |
| void PPDParser::freeAll() |
| { |
| while( aAllParsers.begin() != aAllParsers.end() ) |
| { |
| delete aAllParsers.front(); |
| aAllParsers.pop_front(); |
| } |
| delete pAllPPDFiles; |
| pAllPPDFiles = NULL; |
| } |
| |
| PPDParser::PPDParser( const String& rFile ) : |
| m_aFile( rFile ), |
| m_bType42Capable( false ), |
| m_aFileEncoding( RTL_TEXTENCODING_MS_1252 ), |
| m_pDefaultImageableArea( NULL ), |
| m_pImageableAreas( NULL ), |
| m_pDefaultPaperDimension( NULL ), |
| m_pPaperDimensions( NULL ), |
| m_pDefaultInputSlot( NULL ), |
| m_pInputSlots( NULL ), |
| m_pDefaultResolution( NULL ), |
| m_pResolutions( NULL ), |
| m_pDefaultDuplexType( NULL ), |
| m_pDuplexTypes( NULL ), |
| m_pFontList( NULL ), |
| m_pTranslator( new PPDTranslator() ) |
| { |
| // read in the file |
| std::list< ByteString > aLines; |
| PPDDecompressStream aStream( m_aFile ); |
| bool bLanguageEncoding = false; |
| if( aStream.IsOpen() ) |
| { |
| ByteString aCurLine; |
| while( ! aStream.IsEof() ) |
| { |
| aStream.ReadLine( aCurLine ); |
| if( aCurLine.GetChar( 0 ) == '*' ) |
| { |
| if( aCurLine.CompareIgnoreCaseToAscii( "*include:", 9 ) == COMPARE_EQUAL ) |
| { |
| aCurLine.Erase( 0, 9 ); |
| aCurLine.EraseLeadingChars( ' ' ); |
| aCurLine.EraseTrailingChars( ' ' ); |
| aCurLine.EraseLeadingChars( '\t' ); |
| aCurLine.EraseTrailingChars( '\t' ); |
| aCurLine.EraseTrailingChars( '\r' ); |
| aCurLine.EraseTrailingChars( '\n' ); |
| aCurLine.EraseLeadingChars( '"' ); |
| aCurLine.EraseTrailingChars( '"' ); |
| aStream.Close(); |
| aStream.Open( getPPDFile( String( aCurLine, m_aFileEncoding ) ) ); |
| continue; |
| } |
| else if( ! bLanguageEncoding && |
| aCurLine.CompareIgnoreCaseToAscii( "*languageencoding", 17 ) == COMPARE_EQUAL ) |
| { |
| bLanguageEncoding = true; // generally only the first one counts |
| ByteString aLower = aCurLine; |
| aLower.ToLowerAscii(); |
| if( aLower.Search( "isolatin1", 17 ) != STRING_NOTFOUND || |
| aLower.Search( "windowsansi", 17 ) != STRING_NOTFOUND ) |
| m_aFileEncoding = RTL_TEXTENCODING_MS_1252; |
| else if( aLower.Search( "isolatin2", 17 ) != STRING_NOTFOUND ) |
| m_aFileEncoding = RTL_TEXTENCODING_ISO_8859_2; |
| else if( aLower.Search( "isolatin5", 17 ) != STRING_NOTFOUND ) |
| m_aFileEncoding = RTL_TEXTENCODING_ISO_8859_5; |
| else if( aLower.Search( "jis83-rksj", 17 ) != STRING_NOTFOUND ) |
| m_aFileEncoding = RTL_TEXTENCODING_SHIFT_JIS; |
| else if( aLower.Search( "macstandard", 17 ) != STRING_NOTFOUND ) |
| m_aFileEncoding = RTL_TEXTENCODING_APPLE_ROMAN; |
| else if( aLower.Search( "utf-8", 17 ) != STRING_NOTFOUND ) |
| m_aFileEncoding = RTL_TEXTENCODING_UTF8; |
| } |
| } |
| aLines.push_back( aCurLine ); |
| } |
| } |
| aStream.Close(); |
| |
| // now get the Values |
| parse( aLines ); |
| #if OSL_DEBUG_LEVEL > 2 |
| fprintf( stderr, "acquired %d Keys from PPD %s:\n", m_aKeys.size(), BSTRING( m_aFile ).GetBuffer() ); |
| for( PPDParser::hash_type::const_iterator it = m_aKeys.begin(); it != m_aKeys.end(); ++it ) |
| { |
| const PPDKey* pKey = it->second; |
| char* pSetupType = "<unknown>"; |
| switch( pKey->m_eSetupType ) |
| { |
| case PPDKey::ExitServer: pSetupType = "ExitServer";break; |
| case PPDKey::Prolog: pSetupType = "Prolog";break; |
| case PPDKey::DocumentSetup: pSetupType = "DocumentSetup";break; |
| case PPDKey::PageSetup: pSetupType = "PageSetup";break; |
| case PPDKey::JCLSetup: pSetupType = "JCLSetup";break; |
| case PPDKey::AnySetup: pSetupType = "AnySetup";break; |
| default: break; |
| }; |
| fprintf( stderr, "\t\"%s\" (\"%s\") (%d values) OrderDependency: %d %s\n", |
| BSTRING( pKey->getKey() ).GetBuffer(), |
| BSTRING( pKey->m_aUITranslation ).GetBuffer(), |
| pKey->countValues(), |
| pKey->m_nOrderDependency, |
| pSetupType ); |
| for( int j = 0; j < pKey->countValues(); j++ ) |
| { |
| fprintf( stderr, "\t\t" ); |
| const PPDValue* pValue = pKey->getValue( j ); |
| if( pValue == pKey->m_pDefaultValue ) |
| fprintf( stderr, "(Default:) " ); |
| char* pVType = "<unknown>"; |
| switch( pValue->m_eType ) |
| { |
| case eInvocation: pVType = "invocation";break; |
| case eQuoted: pVType = "quoted";break; |
| case eString: pVType = "string";break; |
| case eSymbol: pVType = "symbol";break; |
| case eNo: pVType = "no";break; |
| default: break; |
| }; |
| fprintf( stderr, "option: \"%s\" (\"%s\"), value: type %s \"%s\" (\"%s\")\n", |
| BSTRING( pValue->m_aOption ).GetBuffer(), |
| BSTRING( pValue->m_aOptionTranslation ).GetBuffer(), |
| pVType, |
| BSTRING( pValue->m_aValue ).GetBuffer(), |
| BSTRING( pValue->m_aValueTranslation ).GetBuffer() ); |
| } |
| } |
| fprintf( stderr, "constraints: (%d found)\n", m_aConstraints.size() ); |
| for( std::list< PPDConstraint >::const_iterator cit = m_aConstraints.begin(); cit != m_aConstraints.end(); ++cit ) |
| { |
| fprintf( stderr, "*\"%s\" \"%s\" *\"%s\" \"%s\"\n", |
| BSTRING( cit->m_pKey1->getKey() ).GetBuffer(), |
| cit->m_pOption1 ? BSTRING( cit->m_pOption1->m_aOption ).GetBuffer() : "<nil>", |
| BSTRING( cit->m_pKey2->getKey() ).GetBuffer(), |
| cit->m_pOption2 ? BSTRING( cit->m_pOption2->m_aOption ).GetBuffer() : "<nil>" |
| ); |
| } |
| #endif |
| |
| // fill in shortcuts |
| const PPDKey* pKey; |
| |
| m_pImageableAreas = getKey( String( RTL_CONSTASCII_USTRINGPARAM( "ImageableArea" ) ) ); |
| if( m_pImageableAreas ) |
| m_pDefaultImageableArea = m_pImageableAreas->getDefaultValue(); |
| DBG_ASSERT( m_pImageableAreas, "Warning: no ImageableArea in PPD\n" ); |
| DBG_ASSERT( m_pDefaultImageableArea, "Warning: no DefaultImageableArea in PPD\n" ); |
| |
| m_pPaperDimensions = getKey( String( RTL_CONSTASCII_USTRINGPARAM( "PaperDimension" ) ) ); |
| if( m_pPaperDimensions ) |
| m_pDefaultPaperDimension = m_pPaperDimensions->getDefaultValue(); |
| DBG_ASSERT( m_pPaperDimensions, "Warning: no PaperDimension in PPD\n" ); |
| DBG_ASSERT( m_pDefaultPaperDimension, "Warning: no DefaultPaperDimension in PPD\n" ); |
| |
| m_pResolutions = getKey( String( RTL_CONSTASCII_USTRINGPARAM( "Resolution" ) ) ); |
| if( m_pResolutions ) |
| m_pDefaultResolution = m_pResolutions->getDefaultValue(); |
| DBG_ASSERT( m_pResolutions, "Warning: no Resolution in PPD\n" ); |
| DBG_ASSERT( m_pDefaultResolution, "Warning: no DefaultResolution in PPD\n" ); |
| |
| m_pInputSlots = getKey( String( RTL_CONSTASCII_USTRINGPARAM( "InputSlot" ) ) ); |
| if( m_pInputSlots ) |
| m_pDefaultInputSlot = m_pInputSlots->getDefaultValue(); |
| DBG_ASSERT( m_pPaperDimensions, "Warning: no InputSlot in PPD\n" ); |
| DBG_ASSERT( m_pDefaultPaperDimension, "Warning: no DefaultInputSlot in PPD\n" ); |
| |
| m_pDuplexTypes = getKey( String( RTL_CONSTASCII_USTRINGPARAM( "Duplex" ) ) ); |
| if( m_pDuplexTypes ) |
| m_pDefaultDuplexType = m_pDuplexTypes->getDefaultValue(); |
| |
| m_pFontList = getKey( String( RTL_CONSTASCII_USTRINGPARAM( "Font" ) ) ); |
| DBG_ASSERT( m_pFontList, "Warning: no Font in PPD\n" ); |
| |
| // fill in direct values |
| if( (pKey = getKey( String( RTL_CONSTASCII_USTRINGPARAM( "ModelName" ) ) )) ) |
| m_aPrinterName = pKey->getValue( 0 )->m_aValue; |
| if( (pKey = getKey( String( RTL_CONSTASCII_USTRINGPARAM( "NickName" ) ) )) ) |
| m_aNickName = pKey->getValue( 0 )->m_aValue; |
| if( (pKey = getKey( String( RTL_CONSTASCII_USTRINGPARAM( "ColorDevice" ) ) )) ) |
| m_bColorDevice = pKey->getValue( 0 )->m_aValue.CompareIgnoreCaseToAscii( "true", 4 ) == COMPARE_EQUAL ? true : false; |
| |
| if( (pKey = getKey( String( RTL_CONSTASCII_USTRINGPARAM( "LanguageLevel" ) ) )) ) |
| m_nLanguageLevel = pKey->getValue( 0 )->m_aValue.ToInt32(); |
| if( (pKey = getKey( String( RTL_CONSTASCII_USTRINGPARAM( "TTRasterizer" ) ) )) ) |
| m_bType42Capable = pKey->getValue( 0 )->m_aValue.EqualsIgnoreCaseAscii( "Type42" ) ? true : false; |
| } |
| |
| PPDParser::~PPDParser() |
| { |
| for( PPDParser::hash_type::iterator it = m_aKeys.begin(); it != m_aKeys.end(); ++it ) |
| delete it->second; |
| delete m_pTranslator; |
| } |
| |
| void PPDParser::insertKey( const String& rKey, PPDKey* pKey ) |
| { |
| m_aKeys[ rKey ] = pKey; |
| m_aOrderedKeys.push_back( pKey ); |
| } |
| |
| const PPDKey* PPDParser::getKey( int n ) const |
| { |
| return ((unsigned int)n < m_aOrderedKeys.size() && n >= 0) ? m_aOrderedKeys[n] : NULL; |
| } |
| |
| const PPDKey* PPDParser::getKey( const String& rKey ) const |
| { |
| PPDParser::hash_type::const_iterator it = m_aKeys.find( rKey ); |
| return it != m_aKeys.end() ? it->second : NULL; |
| } |
| |
| bool PPDParser::hasKey( const PPDKey* pKey ) const |
| { |
| return |
| pKey ? |
| ( m_aKeys.find( pKey->getKey() ) != m_aKeys.end() ? true : false ) : |
| false; |
| } |
| |
| static sal_uInt8 getNibble( sal_Char cChar ) |
| { |
| sal_uInt8 nRet = 0; |
| if( cChar >= '0' && cChar <= '9' ) |
| nRet = sal_uInt8( cChar - '0' ); |
| else if( cChar >= 'A' && cChar <= 'F' ) |
| nRet = 10 + sal_uInt8( cChar - 'A' ); |
| else if( cChar >= 'a' && cChar <= 'f' ) |
| nRet = 10 + sal_uInt8( cChar - 'a' ); |
| return nRet; |
| } |
| |
| String PPDParser::handleTranslation( const ByteString& i_rString, bool bIsGlobalized ) |
| { |
| int nOrigLen = i_rString.Len(); |
| OStringBuffer aTrans( nOrigLen ); |
| const sal_Char* pStr = i_rString.GetBuffer(); |
| const sal_Char* pEnd = pStr + nOrigLen; |
| while( pStr < pEnd ) |
| { |
| if( *pStr == '<' ) |
| { |
| pStr++; |
| sal_Char cChar; |
| while( *pStr != '>' && pStr < pEnd-1 ) |
| { |
| cChar = getNibble( *pStr++ ) << 4; |
| cChar |= getNibble( *pStr++ ); |
| aTrans.append( cChar ); |
| } |
| pStr++; |
| } |
| else |
| aTrans.append( *pStr++ ); |
| } |
| return OStringToOUString( aTrans.makeStringAndClear(), bIsGlobalized ? RTL_TEXTENCODING_UTF8 : m_aFileEncoding ); |
| } |
| |
| void PPDParser::parse( ::std::list< ByteString >& rLines ) |
| { |
| std::list< ByteString >::iterator line = rLines.begin(); |
| PPDParser::hash_type::const_iterator keyit; |
| while( line != rLines.end() ) |
| { |
| ByteString aCurrentLine( *line ); |
| ++line; |
| if( aCurrentLine.GetChar(0) != '*' ) |
| continue; |
| if( aCurrentLine.GetChar(1) == '%' ) |
| continue; |
| |
| ByteString aKey = GetCommandLineToken( 0, aCurrentLine.GetToken( 0, ':' ) ); |
| int nPos = aKey.Search( '/' ); |
| if( nPos != STRING_NOTFOUND ) |
| aKey.Erase( nPos ); |
| aKey.Erase( 0, 1 ); // remove the '*' |
| |
| if( aKey.Equals( "CloseUI" ) || aKey.Equals( "OpenGroup" ) || aKey.Equals( "CloseGroup" ) || aKey.Equals( "End" ) || aKey.Equals( "OpenSubGroup" ) || aKey.Equals( "CloseSubGroup" ) ) |
| continue; |
| |
| if( aKey.Equals( "OpenUI" ) ) |
| { |
| parseOpenUI( aCurrentLine ); |
| continue; |
| } |
| else if( aKey.Equals( "OrderDependency" ) ) |
| { |
| parseOrderDependency( aCurrentLine ); |
| continue; |
| } |
| else if( aKey.Equals( "UIConstraints" ) || aKey.Equals( "NonUIConstraints" ) ) |
| continue; // parsed in pass 2 |
| else if( aKey.Equals( "CustomPageSize" ) ) // currently not handled |
| continue; |
| |
| // default values are parsed in pass 2 |
| if( aKey.CompareTo( "Default", 7 ) == COMPARE_EQUAL ) |
| continue; |
| |
| bool bQuery = false; |
| if( aKey.GetChar( 0 ) == '?' ) |
| { |
| aKey.Erase( 0, 1 ); |
| bQuery = true; |
| } |
| |
| String aUniKey( aKey, RTL_TEXTENCODING_MS_1252 ); |
| // handle CUPS extension for globalized PPDs |
| bool bIsGlobalizedLine = false; |
| com::sun::star::lang::Locale aTransLocale; |
| if( ( aUniKey.Len() > 3 && aUniKey.GetChar( 2 ) == '.' ) || |
| ( aUniKey.Len() > 5 && aUniKey.GetChar( 2 ) == '_' && aUniKey.GetChar( 5 ) == '.' ) ) |
| { |
| if( aUniKey.GetChar( 2 ) == '.' ) |
| { |
| aTransLocale.Language = aUniKey.Copy( 0, 2 ); |
| aUniKey = aUniKey.Copy( 3 ); |
| } |
| else |
| { |
| aTransLocale.Language = aUniKey.Copy( 0, 2 ); |
| aTransLocale.Country = aUniKey.Copy( 3, 2 ); |
| aUniKey = aUniKey.Copy( 6 ); |
| } |
| bIsGlobalizedLine = true; |
| } |
| |
| String aOption; |
| nPos = aCurrentLine.Search( ':' ); |
| if( nPos != STRING_NOTFOUND ) |
| { |
| aOption = String( aCurrentLine.Copy( 1, nPos-1 ), RTL_TEXTENCODING_MS_1252 ); |
| aOption = GetCommandLineToken( 1, aOption ); |
| int nTransPos = aOption.Search( '/' ); |
| if( nTransPos != STRING_NOTFOUND ) |
| aOption.Erase( nTransPos ); |
| } |
| |
| PPDValueType eType = eNo; |
| String aValue; |
| rtl::OUString aOptionTranslation; |
| rtl::OUString aValueTranslation; |
| if( nPos != STRING_NOTFOUND ) |
| { |
| // found a colon, there may be an option |
| ByteString aLine = aCurrentLine.Copy( 1, nPos-1 ); |
| aLine = WhitespaceToSpace( aLine ); |
| int nTransPos = aLine.Search( '/' ); |
| if( nTransPos != STRING_NOTFOUND ) |
| aOptionTranslation = handleTranslation( aLine.Copy( nTransPos+1 ), bIsGlobalizedLine ); |
| |
| // read in more lines if necessary for multiline values |
| aLine = aCurrentLine.Copy( nPos+1 ); |
| if( aLine.Len() ) |
| { |
| while( ! ( aLine.GetTokenCount( '"' ) & 1 ) && |
| line != rLines.end() ) |
| // while there is an even number of tokens; that means |
| // an odd number of doubleqoutes |
| { |
| // copy the newlines also |
| aLine += '\n'; |
| aLine += *line; |
| ++line; |
| } |
| } |
| aLine = WhitespaceToSpace( aLine ); |
| |
| // #i100644# handle a missing value (actually a broken PPD) |
| if( ! aLine.Len() ) |
| { |
| if( aOption.Len() && |
| aUniKey.CompareToAscii( "JCL", 3 ) != COMPARE_EQUAL ) |
| eType = eInvocation; |
| else |
| eType = eQuoted; |
| } |
| // check for invocation or quoted value |
| else if( aLine.GetChar(0) == '"' ) |
| { |
| aLine.Erase( 0, 1 ); |
| nTransPos = aLine.Search( '"' ); |
| aValue = String( aLine.Copy( 0, nTransPos ), RTL_TEXTENCODING_MS_1252 ); |
| // after the second doublequote can follow a / and a translation |
| aValueTranslation = handleTranslation( aLine.Copy( nTransPos+2 ), bIsGlobalizedLine ); |
| // check for quoted value |
| if( aOption.Len() && |
| aUniKey.CompareToAscii( "JCL", 3 ) != COMPARE_EQUAL ) |
| eType = eInvocation; |
| else |
| eType = eQuoted; |
| } |
| // check for symbol value |
| else if( aLine.GetChar(0) == '^' ) |
| { |
| aLine.Erase( 0, 1 ); |
| aValue = String( aLine, RTL_TEXTENCODING_MS_1252 ); |
| eType = eSymbol; |
| } |
| else |
| { |
| // must be a string value then |
| // strictly this is false because string values |
| // can contain any whitespace which is reduced |
| // to one space by now |
| // who cares ... |
| nTransPos = aLine.Search( '/' ); |
| if( nTransPos == STRING_NOTFOUND ) |
| nTransPos = aLine.Len(); |
| aValue = String( aLine.Copy( 0, nTransPos ), RTL_TEXTENCODING_MS_1252 ); |
| aValueTranslation = handleTranslation( aLine.Copy( nTransPos+1 ), bIsGlobalizedLine ); |
| eType = eString; |
| } |
| } |
| |
| // handle globalized PPD entries |
| if( bIsGlobalizedLine ) |
| { |
| // handle main key translations of form: |
| // *ll_CC.Translation MainKeyword/translated text: "" |
| if( aUniKey.EqualsAscii( "Translation" ) ) |
| { |
| m_pTranslator->insertKey( aOption, aOptionTranslation, aTransLocale ); |
| } |
| // handle options translations of for: |
| // *ll_CC.MainKeyword OptionKeyword/translated text: "" |
| else |
| { |
| m_pTranslator->insertOption( aUniKey, aOption, aOptionTranslation, aTransLocale ); |
| } |
| continue; |
| } |
| |
| PPDKey* pKey = NULL; |
| keyit = m_aKeys.find( aUniKey ); |
| if( keyit == m_aKeys.end() ) |
| { |
| pKey = new PPDKey( aUniKey ); |
| insertKey( aUniKey, pKey ); |
| } |
| else |
| pKey = keyit->second; |
| |
| if( eType == eNo && bQuery ) |
| continue; |
| |
| PPDValue* pValue = pKey->insertValue( aOption ); |
| if( ! pValue ) |
| continue; |
| pValue->m_eType = eType; |
| pValue->m_aValue = aValue; |
| |
| if( aOptionTranslation.getLength() ) |
| m_pTranslator->insertOption( aUniKey, aOption, aOptionTranslation, aTransLocale ); |
| if( aValueTranslation.getLength() ) |
| m_pTranslator->insertValue( aUniKey, aOption, aValue, aValueTranslation, aTransLocale ); |
| |
| // eventually update query and remove from option list |
| if( bQuery && pKey->m_bQueryValue == sal_False ) |
| { |
| pKey->m_aQueryValue = *pValue; |
| pKey->m_bQueryValue = true; |
| pKey->eraseValue( pValue->m_aOption ); |
| } |
| } |
| |
| // second pass: fill in defaults |
| for( line = rLines.begin(); line != rLines.end(); ++line ) |
| { |
| ByteString aLine( *line ); |
| if( aLine.CompareTo( "*Default", 8 ) == COMPARE_EQUAL ) |
| { |
| String aKey( aLine.Copy( 8 ), RTL_TEXTENCODING_MS_1252 ); |
| sal_uInt16 nPos = aKey.Search( ':' ); |
| if( nPos != STRING_NOTFOUND ) |
| { |
| aKey.Erase( nPos ); |
| String aOption( WhitespaceToSpace( aLine.Copy( nPos+9 ) ), RTL_TEXTENCODING_MS_1252 ); |
| keyit = m_aKeys.find( aKey ); |
| if( keyit != m_aKeys.end() ) |
| { |
| PPDKey* pKey = keyit->second; |
| const PPDValue* pDefValue = pKey->getValue( aOption ); |
| if( pKey->m_pDefaultValue == NULL ) |
| pKey->m_pDefaultValue = pDefValue; |
| } |
| else |
| { |
| // some PPDs contain defaults for keys that |
| // do not exist otherwise |
| // (example: DefaultResolution) |
| // so invent that key here and have a default value |
| PPDKey* pKey = new PPDKey( aKey ); |
| PPDValue* pNewValue = pKey->insertValue( aOption ); |
| pNewValue->m_eType = eInvocation; // or what ? |
| insertKey( aKey, pKey ); |
| } |
| } |
| } |
| else if( aLine.CompareTo( "*UIConstraints", 14 ) == COMPARE_EQUAL || |
| aLine.CompareTo( "*NonUIConstraints", 17 ) == COMPARE_EQUAL ) |
| parseConstraint( aLine ); |
| |
| } |
| } |
| |
| void PPDParser::parseOpenUI( const ByteString& rLine ) |
| { |
| String aTranslation; |
| ByteString aKey = rLine; |
| |
| int nPos = aKey.Search( ':' ); |
| if( nPos != STRING_NOTFOUND ) |
| aKey.Erase( nPos ); |
| nPos = aKey.Search( '/' ); |
| if( nPos != STRING_NOTFOUND ) |
| { |
| aTranslation = handleTranslation( aKey.Copy( nPos + 1 ), false ); |
| aKey.Erase( nPos ); |
| } |
| aKey = GetCommandLineToken( 1, aKey ); |
| aKey.Erase( 0, 1 ); |
| |
| String aUniKey( aKey, RTL_TEXTENCODING_MS_1252 ); |
| PPDParser::hash_type::const_iterator keyit = m_aKeys.find( aUniKey ); |
| PPDKey* pKey; |
| if( keyit == m_aKeys.end() ) |
| { |
| pKey = new PPDKey( aUniKey ); |
| insertKey( aUniKey, pKey ); |
| } |
| else |
| pKey = keyit->second; |
| |
| pKey->m_bUIOption = true; |
| m_pTranslator->insertKey( pKey->getKey(), aTranslation ); |
| |
| ByteString aValue = WhitespaceToSpace( rLine.GetToken( 1, ':' ) ); |
| if( aValue.CompareIgnoreCaseToAscii( "boolean" ) == COMPARE_EQUAL ) |
| pKey->m_eUIType = PPDKey::Boolean; |
| else if( aValue.CompareIgnoreCaseToAscii( "pickmany" ) == COMPARE_EQUAL ) |
| pKey->m_eUIType = PPDKey::PickMany; |
| else |
| pKey->m_eUIType = PPDKey::PickOne; |
| } |
| |
| void PPDParser::parseOrderDependency( const ByteString& rLine ) |
| { |
| ByteString aLine( rLine ); |
| int nPos = aLine.Search( ':' ); |
| if( nPos != STRING_NOTFOUND ) |
| aLine.Erase( 0, nPos+1 ); |
| |
| int nOrder = GetCommandLineToken( 0, aLine ).ToInt32(); |
| ByteString aSetup = GetCommandLineToken( 1, aLine ); |
| String aKey( GetCommandLineToken( 2, aLine ), RTL_TEXTENCODING_MS_1252 ); |
| if( aKey.GetChar( 0 ) != '*' ) |
| return; // invalid order depency |
| aKey.Erase( 0, 1 ); |
| |
| PPDKey* pKey; |
| PPDParser::hash_type::const_iterator keyit = m_aKeys.find( aKey ); |
| if( keyit == m_aKeys.end() ) |
| { |
| pKey = new PPDKey( aKey ); |
| insertKey( aKey, pKey ); |
| } |
| else |
| pKey = keyit->second; |
| |
| pKey->m_nOrderDependency = nOrder; |
| if( aSetup.Equals( "ExitServer" ) ) |
| pKey->m_eSetupType = PPDKey::ExitServer; |
| else if( aSetup.Equals( "Prolog" ) ) |
| pKey->m_eSetupType = PPDKey::Prolog; |
| else if( aSetup.Equals( "DocumentSetup" ) ) |
| pKey->m_eSetupType = PPDKey::DocumentSetup; |
| else if( aSetup.Equals( "PageSetup" ) ) |
| pKey->m_eSetupType = PPDKey::PageSetup; |
| else if( aSetup.Equals( "JCLSetup" ) ) |
| pKey->m_eSetupType = PPDKey::JCLSetup; |
| else |
| pKey->m_eSetupType = PPDKey::AnySetup; |
| } |
| |
| void PPDParser::parseConstraint( const ByteString& rLine ) |
| { |
| bool bFailed = false; |
| |
| String aLine( rLine, RTL_TEXTENCODING_MS_1252 ); |
| aLine.Erase( 0, rLine.Search( ':' )+1 ); |
| PPDConstraint aConstraint; |
| int nTokens = GetCommandLineTokenCount( aLine ); |
| for( int i = 0; i < nTokens; i++ ) |
| { |
| String aToken = GetCommandLineToken( i, aLine ); |
| if( aToken.GetChar( 0 ) == '*' ) |
| { |
| aToken.Erase( 0, 1 ); |
| if( aConstraint.m_pKey1 ) |
| aConstraint.m_pKey2 = getKey( aToken ); |
| else |
| aConstraint.m_pKey1 = getKey( aToken ); |
| } |
| else |
| { |
| if( aConstraint.m_pKey2 ) |
| { |
| if( ! ( aConstraint.m_pOption2 = aConstraint.m_pKey2->getValue( aToken ) ) ) |
| bFailed = true; |
| } |
| else if( aConstraint.m_pKey1 ) |
| { |
| if( ! ( aConstraint.m_pOption1 = aConstraint.m_pKey1->getValue( aToken ) ) ) |
| bFailed = true; |
| } |
| else |
| // constraint for nonexistent keys; this happens |
| // e.g. in HP4PLUS3 (#75636#) |
| bFailed = true; |
| } |
| } |
| // there must be two keywords |
| if( ! aConstraint.m_pKey1 || ! aConstraint.m_pKey2 || bFailed ) |
| { |
| #ifdef __DEBUG |
| fprintf( stderr, "Warning: constraint \"%s\" is invalid\n", rLine.GetStr() ); |
| #endif |
| } |
| else |
| m_aConstraints.push_back( aConstraint ); |
| } |
| |
| String PPDParser::getDefaultPaperDimension() const |
| { |
| if( m_pDefaultPaperDimension ) |
| return m_pDefaultPaperDimension->m_aOption; |
| |
| return String(); |
| } |
| |
| bool PPDParser::getMargins( |
| const String& rPaperName, |
| int& rLeft, int& rRight, |
| int& rUpper, int& rLower ) const |
| { |
| if( ! m_pImageableAreas || ! m_pPaperDimensions ) |
| return false; |
| |
| int nPDim=-1, nImArea=-1, i; |
| for( i = 0; i < m_pImageableAreas->countValues(); i++ ) |
| if( rPaperName == m_pImageableAreas->getValue( i )->m_aOption ) |
| nImArea = i; |
| for( i = 0; i < m_pPaperDimensions->countValues(); i++ ) |
| if( rPaperName == m_pPaperDimensions->getValue( i )->m_aOption ) |
| nPDim = i; |
| if( nPDim == -1 || nImArea == -1 ) |
| return false; |
| |
| double ImLLx, ImLLy, ImURx, ImURy; |
| double PDWidth, PDHeight; |
| String aArea = m_pImageableAreas->getValue( nImArea )->m_aValue; |
| ImLLx = StringToDouble( GetCommandLineToken( 0, aArea ) ); |
| ImLLy = StringToDouble( GetCommandLineToken( 1, aArea ) ); |
| ImURx = StringToDouble( GetCommandLineToken( 2, aArea ) ); |
| ImURy = StringToDouble( GetCommandLineToken( 3, aArea ) ); |
| // sscanf( m_pImageableAreas->getValue( nImArea )->m_aValue.GetStr(), |
| // "%lg%lg%lg%lg", &ImLLx, &ImLLy, &ImURx, &ImURy ); |
| aArea = m_pPaperDimensions->getValue( nPDim )->m_aValue; |
| PDWidth = StringToDouble( GetCommandLineToken( 0, aArea ) ); |
| PDHeight = StringToDouble( GetCommandLineToken( 1, aArea ) ); |
| // sscanf( m_pPaperDimensions->getValue( nPDim )->m_aValue.GetStr(), |
| // "%lg%lg", &PDWidth, &PDHeight ); |
| rLeft = (int)(ImLLx + 0.5); |
| rLower = (int)(ImLLy + 0.5); |
| rUpper = (int)(PDHeight - ImURy + 0.5); |
| rRight = (int)(PDWidth - ImURx + 0.5); |
| |
| return true; |
| } |
| |
| bool PPDParser::getPaperDimension( |
| const String& rPaperName, |
| int& rWidth, int& rHeight ) const |
| { |
| if( ! m_pPaperDimensions ) |
| return false; |
| |
| int nPDim=-1; |
| for( int i = 0; i < m_pPaperDimensions->countValues(); i++ ) |
| if( rPaperName == m_pPaperDimensions->getValue( i )->m_aOption ) |
| nPDim = i; |
| if( nPDim == -1 ) |
| return false; |
| |
| double PDWidth, PDHeight; |
| String aArea = m_pPaperDimensions->getValue( nPDim )->m_aValue; |
| PDWidth = StringToDouble( GetCommandLineToken( 0, aArea ) ); |
| PDHeight = StringToDouble( GetCommandLineToken( 1, aArea ) ); |
| rHeight = (int)(PDHeight + 0.5); |
| rWidth = (int)(PDWidth + 0.5); |
| |
| return true; |
| } |
| |
| String PPDParser::matchPaper( int nWidth, int nHeight ) const |
| { |
| if( ! m_pPaperDimensions ) |
| return String(); |
| |
| int nPDim = -1; |
| double PDWidth, PDHeight; |
| double fSort = 2e36, fNewSort; |
| |
| for( int i = 0; i < m_pPaperDimensions->countValues(); i++ ) |
| { |
| String aArea = m_pPaperDimensions->getValue( i )->m_aValue; |
| PDWidth = StringToDouble( GetCommandLineToken( 0, aArea ) ); |
| PDHeight = StringToDouble( GetCommandLineToken( 1, aArea ) ); |
| PDWidth /= (double)nWidth; |
| PDHeight /= (double)nHeight; |
| if( PDWidth >= 0.9 && PDWidth <= 1.1 && |
| PDHeight >= 0.9 && PDHeight <= 1.1 ) |
| { |
| fNewSort = |
| (1.0-PDWidth)*(1.0-PDWidth) + (1.0-PDHeight)*(1.0-PDHeight); |
| if( fNewSort == 0.0 ) // perfect match |
| return m_pPaperDimensions->getValue( i )->m_aOption; |
| |
| if( fNewSort < fSort ) |
| { |
| fSort = fNewSort; |
| nPDim = i; |
| } |
| } |
| } |
| |
| static bool bDontSwap = false; |
| if( nPDim == -1 && ! bDontSwap ) |
| { |
| // swap portrait/landscape and try again |
| bDontSwap = true; |
| String rRet = matchPaper( nHeight, nWidth ); |
| bDontSwap = false; |
| return rRet; |
| } |
| |
| return nPDim != -1 ? m_pPaperDimensions->getValue( nPDim )->m_aOption : String(); |
| } |
| |
| String PPDParser::getDefaultInputSlot() const |
| { |
| if( m_pDefaultInputSlot ) |
| return m_pDefaultInputSlot->m_aValue; |
| return String(); |
| } |
| |
| String PPDParser::getSlot( int nSlot ) const |
| { |
| if( ! m_pInputSlots ) |
| return String(); |
| |
| if( nSlot > 0 && nSlot < m_pInputSlots->countValues() ) |
| return m_pInputSlots->getValue( nSlot )->m_aOption; |
| else if( m_pInputSlots->countValues() > 0 ) |
| return m_pInputSlots->getValue( (sal_uLong)0 )->m_aOption; |
| |
| return String(); |
| } |
| |
| String PPDParser::getSlotCommand( int nSlot ) const |
| { |
| if( ! m_pInputSlots ) |
| return String(); |
| |
| if( nSlot > 0 && nSlot < m_pInputSlots->countValues() ) |
| return m_pInputSlots->getValue( nSlot )->m_aValue; |
| else if( m_pInputSlots->countValues() > 0 ) |
| return m_pInputSlots->getValue( (sal_uLong)0 )->m_aValue; |
| |
| return String(); |
| } |
| |
| String PPDParser::getSlotCommand( const String& rSlot ) const |
| { |
| if( ! m_pInputSlots ) |
| return String(); |
| |
| for( int i=0; i < m_pInputSlots->countValues(); i++ ) |
| { |
| const PPDValue* pValue = m_pInputSlots->getValue( i ); |
| if( pValue->m_aOption == rSlot ) |
| return pValue->m_aValue; |
| } |
| return String(); |
| } |
| |
| String PPDParser::getPaperDimension( int nPaperDimension ) const |
| { |
| if( ! m_pPaperDimensions ) |
| return String(); |
| |
| if( nPaperDimension > 0 && nPaperDimension < m_pPaperDimensions->countValues() ) |
| return m_pPaperDimensions->getValue( nPaperDimension )->m_aOption; |
| else if( m_pPaperDimensions->countValues() > 0 ) |
| return m_pPaperDimensions->getValue( (sal_uLong)0 )->m_aOption; |
| |
| return String(); |
| } |
| |
| String PPDParser::getPaperDimensionCommand( int nPaperDimension ) const |
| { |
| if( ! m_pPaperDimensions ) |
| return String(); |
| |
| if( nPaperDimension > 0 && nPaperDimension < m_pPaperDimensions->countValues() ) |
| return m_pPaperDimensions->getValue( nPaperDimension )->m_aValue; |
| else if( m_pPaperDimensions->countValues() > 0 ) |
| return m_pPaperDimensions->getValue( (sal_uLong)0 )->m_aValue; |
| |
| return String(); |
| } |
| |
| String PPDParser::getPaperDimensionCommand( const String& rPaperDimension ) const |
| { |
| if( ! m_pPaperDimensions ) |
| return String(); |
| |
| for( int i=0; i < m_pPaperDimensions->countValues(); i++ ) |
| { |
| const PPDValue* pValue = m_pPaperDimensions->getValue( i ); |
| if( pValue->m_aOption == rPaperDimension ) |
| return pValue->m_aValue; |
| } |
| return String(); |
| } |
| |
| void PPDParser::getResolutionFromString( |
| const String& rString, |
| int& rXRes, int& rYRes ) const |
| { |
| int nPos = 0, nDPIPos; |
| |
| rXRes = rYRes = 300; |
| |
| nDPIPos = rString.SearchAscii( "dpi" ); |
| if( nDPIPos != STRING_NOTFOUND ) |
| { |
| if( ( nPos = rString.Search( 'x' ) ) != STRING_NOTFOUND ) |
| { |
| rXRes = rString.Copy( 0, nPos ).ToInt32(); |
| rYRes = rString.GetToken( 1, 'x' ).Erase( nDPIPos - nPos - 1 ).ToInt32(); |
| } |
| else |
| rXRes = rYRes = rString.Copy( 0, nDPIPos ).ToInt32(); |
| } |
| } |
| |
| void PPDParser::getDefaultResolution( int& rXRes, int& rYRes ) const |
| { |
| if( m_pDefaultResolution ) |
| { |
| getResolutionFromString( m_pDefaultResolution->m_aValue, rXRes, rYRes ); |
| return; |
| } |
| |
| rXRes = 300; |
| rYRes = 300; |
| } |
| |
| int PPDParser::getResolutions() const |
| { |
| if( ( ! m_pResolutions || m_pResolutions->countValues() == 0 ) && |
| m_pDefaultResolution ) |
| return 1; |
| return m_pResolutions ? m_pResolutions->countValues() : 0; |
| } |
| |
| void PPDParser::getResolution( int nNr, int& rXRes, int& rYRes ) const |
| { |
| if( ( ! m_pResolutions || m_pResolutions->countValues() == 0 ) && m_pDefaultResolution && nNr == 0 ) |
| { |
| getDefaultResolution( rXRes, rYRes ); |
| return; |
| } |
| if( ! m_pResolutions ) |
| return; |
| |
| getResolutionFromString( m_pResolutions->getValue( nNr )->m_aOption, |
| rXRes, rYRes ); |
| } |
| |
| String PPDParser::getResolutionCommand( int nXRes, int nYRes ) const |
| { |
| if( ( ! m_pResolutions || m_pResolutions->countValues() == 0 ) && m_pDefaultResolution ) |
| return m_pDefaultResolution->m_aValue; |
| |
| if( ! m_pResolutions ) |
| return String(); |
| |
| int nX, nY; |
| for( int i = 0; i < m_pResolutions->countValues(); i++ ) |
| { |
| getResolutionFromString( m_pResolutions->getValue( i )->m_aOption, |
| nX, nY ); |
| if( nX == nXRes && nY == nYRes ) |
| return m_pResolutions->getValue( i )->m_aValue; |
| } |
| return String(); |
| } |
| |
| String PPDParser::getDefaultDuplexType() const |
| { |
| if( m_pDefaultDuplexType ) |
| return m_pDefaultDuplexType->m_aValue; |
| return String(); |
| } |
| |
| String PPDParser::getDuplex( int nDuplex ) const |
| { |
| if( ! m_pDuplexTypes ) |
| return String(); |
| |
| if( nDuplex > 0 && nDuplex < m_pDuplexTypes->countValues() ) |
| return m_pDuplexTypes->getValue( nDuplex )->m_aOption; |
| else if( m_pDuplexTypes->countValues() > 0 ) |
| return m_pDuplexTypes->getValue( (sal_uLong)0 )->m_aOption; |
| |
| return String(); |
| } |
| |
| String PPDParser::getDuplexCommand( int nDuplex ) const |
| { |
| if( ! m_pDuplexTypes ) |
| return String(); |
| |
| if( nDuplex > 0 && nDuplex < m_pDuplexTypes->countValues() ) |
| return m_pDuplexTypes->getValue( nDuplex )->m_aValue; |
| else if( m_pDuplexTypes->countValues() > 0 ) |
| return m_pDuplexTypes->getValue( (sal_uLong)0 )->m_aValue; |
| |
| return String(); |
| } |
| |
| String PPDParser::getDuplexCommand( const String& rDuplex ) const |
| { |
| if( ! m_pDuplexTypes ) |
| return String(); |
| |
| for( int i=0; i < m_pDuplexTypes->countValues(); i++ ) |
| { |
| const PPDValue* pValue = m_pDuplexTypes->getValue( i ); |
| if( pValue->m_aOption == rDuplex ) |
| return pValue->m_aValue; |
| } |
| return String(); |
| } |
| |
| void PPDParser::getFontAttributes( |
| int nFont, |
| String& rEncoding, |
| String& rCharset ) const |
| { |
| if( m_pFontList && nFont >= 0 && nFont < m_pFontList->countValues() ) |
| { |
| String aAttribs = |
| WhitespaceToSpace( m_pFontList->getValue( nFont )->m_aValue ); |
| rEncoding = GetCommandLineToken( 0, aAttribs ); |
| rCharset = GetCommandLineToken( 2, aAttribs ); |
| } |
| } |
| |
| void PPDParser::getFontAttributes( |
| const String& rFont, |
| String& rEncoding, |
| String& rCharset ) const |
| { |
| if( m_pFontList ) |
| { |
| for( int i = 0; i < m_pFontList->countValues(); i++ ) |
| if( m_pFontList->getValue( i )->m_aOption == rFont ) |
| getFontAttributes( i, rEncoding, rCharset ); |
| } |
| } |
| |
| String PPDParser::getFont( int nFont ) const |
| { |
| if( ! m_pFontList ) |
| return String(); |
| |
| if( nFont >=0 && nFont < m_pFontList->countValues() ) |
| return m_pFontList->getValue( nFont )->m_aOption; |
| return String(); |
| } |
| |
| rtl::OUString PPDParser::translateKey( const rtl::OUString& i_rKey, |
| const com::sun::star::lang::Locale& i_rLocale ) const |
| { |
| rtl::OUString aResult( m_pTranslator->translateKey( i_rKey, i_rLocale ) ); |
| if( aResult.getLength() == 0 ) |
| aResult = i_rKey; |
| return aResult; |
| } |
| |
| rtl::OUString PPDParser::translateOption( const rtl::OUString& i_rKey, |
| const rtl::OUString& i_rOption, |
| const com::sun::star::lang::Locale& i_rLocale ) const |
| { |
| rtl::OUString aResult( m_pTranslator->translateOption( i_rKey, i_rOption, i_rLocale ) ); |
| if( aResult.getLength() == 0 ) |
| aResult = i_rOption; |
| return aResult; |
| } |
| |
| rtl::OUString PPDParser::translateValue( const rtl::OUString& i_rKey, |
| const rtl::OUString& i_rOption, |
| const rtl::OUString& i_rValue, |
| const com::sun::star::lang::Locale& i_rLocale ) const |
| { |
| rtl::OUString aResult( m_pTranslator->translateValue( i_rKey, i_rOption, i_rValue, i_rLocale ) ); |
| if( aResult.getLength() == 0 ) |
| aResult = i_rValue; |
| return aResult; |
| } |
| |
| /* |
| * PPDKey |
| */ |
| |
| PPDKey::PPDKey( const String& rKey ) : |
| m_aKey( rKey ), |
| m_pDefaultValue( NULL ), |
| m_bQueryValue( false ), |
| m_bUIOption( false ), |
| m_eUIType( PickOne ), |
| m_nOrderDependency( 100 ), |
| m_eSetupType( AnySetup ) |
| { |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| PPDKey::~PPDKey() |
| { |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| const PPDValue* PPDKey::getValue( int n ) const |
| { |
| return ((unsigned int)n < m_aOrderedValues.size() && n >= 0) ? m_aOrderedValues[n] : NULL; |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| const PPDValue* PPDKey::getValue( const String& rOption ) const |
| { |
| PPDKey::hash_type::const_iterator it = m_aValues.find( rOption ); |
| return it != m_aValues.end() ? &it->second : NULL; |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| const PPDValue* PPDKey::getValueCaseInsensitive( const String& rOption ) const |
| { |
| const PPDValue* pValue = getValue( rOption ); |
| if( ! pValue ) |
| { |
| for( size_t n = 0; n < m_aOrderedValues.size() && ! pValue; n++ ) |
| if( m_aOrderedValues[n]->m_aOption.EqualsIgnoreCaseAscii( rOption ) ) |
| pValue = m_aOrderedValues[n]; |
| } |
| |
| return pValue; |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| void PPDKey::eraseValue( const String& rOption ) |
| { |
| PPDKey::hash_type::iterator it = m_aValues.find( rOption ); |
| if( it == m_aValues.end() ) |
| return; |
| |
| for( PPDKey::value_type::iterator vit = m_aOrderedValues.begin(); vit != m_aOrderedValues.end(); ++vit ) |
| { |
| if( *vit == &(it->second ) ) |
| { |
| m_aOrderedValues.erase( vit ); |
| break; |
| } |
| } |
| m_aValues.erase( it ); |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| PPDValue* PPDKey::insertValue( const String& rOption ) |
| { |
| if( m_aValues.find( rOption ) != m_aValues.end() ) |
| return NULL; |
| |
| PPDValue aValue; |
| aValue.m_aOption = rOption; |
| m_aValues[ rOption ] = aValue; |
| PPDValue* pValue = &m_aValues[rOption]; |
| m_aOrderedValues.push_back( pValue ); |
| return pValue; |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| /* |
| * PPDContext |
| */ |
| |
| PPDContext::PPDContext( const PPDParser* pParser ) : |
| m_pParser( pParser ) |
| { |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| PPDContext& PPDContext::operator=( const PPDContext& rCopy ) |
| { |
| m_pParser = rCopy.m_pParser; |
| m_aCurrentValues = rCopy.m_aCurrentValues; |
| return *this; |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| PPDContext::~PPDContext() |
| { |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| const PPDKey* PPDContext::getModifiedKey( int n ) const |
| { |
| hash_type::const_iterator it; |
| for( it = m_aCurrentValues.begin(); it != m_aCurrentValues.end() && n--; ++it ) |
| ; |
| return it != m_aCurrentValues.end() ? it->first : NULL; |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| void PPDContext::setParser( const PPDParser* pParser ) |
| { |
| if( pParser != m_pParser ) |
| { |
| m_aCurrentValues.clear(); |
| m_pParser = pParser; |
| } |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| const PPDValue* PPDContext::getValue( const PPDKey* pKey ) const |
| { |
| if( ! m_pParser ) |
| return NULL; |
| |
| hash_type::const_iterator it; |
| it = m_aCurrentValues.find( pKey ); |
| if( it != m_aCurrentValues.end() ) |
| return it->second; |
| |
| if( ! m_pParser->hasKey( pKey ) ) |
| return NULL; |
| |
| const PPDValue* pValue = pKey->getDefaultValue(); |
| if( ! pValue ) |
| pValue = pKey->getValue( 0 ); |
| |
| return pValue; |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| const PPDValue* PPDContext::setValue( const PPDKey* pKey, const PPDValue* pValue, bool bDontCareForConstraints ) |
| { |
| if( ! m_pParser || ! pKey ) |
| return NULL; |
| |
| // pValue can be NULL - it means ignore this option |
| |
| if( ! m_pParser->hasKey( pKey ) ) |
| return NULL; |
| |
| // check constraints |
| if( pValue ) |
| { |
| if( bDontCareForConstraints ) |
| { |
| m_aCurrentValues[ pKey ] = pValue; |
| } |
| else if( checkConstraints( pKey, pValue, true ) ) |
| { |
| m_aCurrentValues[ pKey ] = pValue; |
| |
| // after setting this value, check all constraints ! |
| hash_type::iterator it = m_aCurrentValues.begin(); |
| while( it != m_aCurrentValues.end() ) |
| { |
| if( it->first != pKey && |
| ! checkConstraints( it->first, it->second, false ) ) |
| { |
| #ifdef __DEBUG |
| fprintf( stderr, "PPDContext::setValue: option %s (%s) is constrained after setting %s to %s\n", |
| it->first->getKey().GetStr(), |
| it->second->m_aOption.GetStr(), |
| pKey->getKey().GetStr(), |
| pValue->m_aOption.GetStr() ); |
| #endif |
| resetValue( it->first, true ); |
| it = m_aCurrentValues.begin(); |
| } |
| else |
| ++it; |
| } |
| } |
| } |
| else |
| m_aCurrentValues[ pKey ] = NULL; |
| |
| return pValue; |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| bool PPDContext::checkConstraints( const PPDKey* pKey, const PPDValue* pValue ) |
| { |
| if( ! m_pParser || ! pKey || ! pValue ) |
| return false; |
| |
| // ensure that this key is already in the list if it exists at all |
| if( m_aCurrentValues.find( pKey ) != m_aCurrentValues.end() ) |
| return checkConstraints( pKey, pValue, false ); |
| |
| // it is not in the list, insert it temporarily |
| bool bRet = false; |
| if( m_pParser->hasKey( pKey ) ) |
| { |
| const PPDValue* pDefValue = pKey->getDefaultValue(); |
| m_aCurrentValues[ pKey ] = pDefValue; |
| bRet = checkConstraints( pKey, pValue, false ); |
| m_aCurrentValues.erase( pKey ); |
| } |
| |
| return bRet; |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| bool PPDContext::resetValue( const PPDKey* pKey, bool bDefaultable ) |
| { |
| if( ! pKey || ! m_pParser || ! m_pParser->hasKey( pKey ) ) |
| return false; |
| |
| const PPDValue* pResetValue = pKey->getValue( String( RTL_CONSTASCII_USTRINGPARAM( "None" ) ) ); |
| if( ! pResetValue ) |
| pResetValue = pKey->getValue( String( RTL_CONSTASCII_USTRINGPARAM( "False" ) ) ); |
| if( ! pResetValue && bDefaultable ) |
| pResetValue = pKey->getDefaultValue(); |
| |
| bool bRet = pResetValue ? ( setValue( pKey, pResetValue ) == pResetValue ? true : false ) : false; |
| |
| return bRet; |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| bool PPDContext::checkConstraints( const PPDKey* pKey, const PPDValue* pNewValue, bool bDoReset ) |
| { |
| if( ! pNewValue ) |
| return true; |
| |
| // sanity checks |
| if( ! m_pParser ) |
| return false; |
| |
| if( pKey->getValue( pNewValue->m_aOption ) != pNewValue ) |
| return false; |
| |
| // None / False and the default can always be set, but be careful ! |
| // setting them might influence constrained values |
| if( pNewValue->m_aOption.EqualsAscii( "None" ) || pNewValue->m_aOption.EqualsAscii( "False" ) || |
| pNewValue == pKey->getDefaultValue() ) |
| return true; |
| |
| const ::std::list< PPDParser::PPDConstraint >& rConstraints( m_pParser->getConstraints() ); |
| for( ::std::list< PPDParser::PPDConstraint >::const_iterator it = rConstraints.begin(); it != rConstraints.end(); ++it ) |
| { |
| const PPDKey* pLeft = it->m_pKey1; |
| const PPDKey* pRight = it->m_pKey2; |
| if( ! pLeft || ! pRight || ( pKey != pLeft && pKey != pRight ) ) |
| continue; |
| |
| const PPDKey* pOtherKey = pKey == pLeft ? pRight : pLeft; |
| const PPDValue* pOtherKeyOption = pKey == pLeft ? it->m_pOption2 : it->m_pOption1; |
| const PPDValue* pKeyOption = pKey == pLeft ? it->m_pOption1 : it->m_pOption2; |
| |
| // syntax *Key1 option1 *Key2 option2 |
| if( pKeyOption && pOtherKeyOption ) |
| { |
| if( pNewValue != pKeyOption ) |
| continue; |
| if( pOtherKeyOption == getValue( pOtherKey ) ) |
| { |
| return false; |
| } |
| } |
| // syntax *Key1 option *Key2 or *Key1 *Key2 option |
| else if( pOtherKeyOption || pKeyOption ) |
| { |
| if( pKeyOption ) |
| { |
| if( ! ( pOtherKeyOption = getValue( pOtherKey ) ) ) |
| continue; // this should not happen, PPD broken |
| |
| if( pKeyOption == pNewValue && |
| ! pOtherKeyOption->m_aOption.EqualsAscii( "None" ) && |
| ! pOtherKeyOption->m_aOption.EqualsAscii( "False" ) ) |
| { |
| // check if the other value can be reset and |
| // do so if possible |
| if( bDoReset && resetValue( pOtherKey ) ) |
| continue; |
| |
| return false; |
| } |
| } |
| else if( pOtherKeyOption ) |
| { |
| if( getValue( pOtherKey ) == pOtherKeyOption && |
| ! pNewValue->m_aOption.EqualsAscii( "None" ) && |
| ! pNewValue->m_aOption.EqualsAscii( "False" ) ) |
| return false; |
| } |
| else |
| { |
| // this should not happen, PPD is broken |
| } |
| } |
| // syntax *Key1 *Key2 |
| else |
| { |
| const PPDValue* pOtherValue = getValue( pOtherKey ); |
| if( ! pOtherValue->m_aOption.EqualsAscii( "None" ) && |
| ! pOtherValue->m_aOption.EqualsAscii( "False" ) && |
| ! pNewValue->m_aOption.EqualsAscii( "None" ) && |
| ! pNewValue->m_aOption.EqualsAscii( "False" ) ) |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| void PPDContext::getUnconstrainedValues( const PPDKey* pKey, ::std::list< const PPDValue* >& rValues ) |
| { |
| rValues.clear(); |
| |
| if( ! m_pParser || ! pKey || ! m_pParser->hasKey( pKey ) ) |
| return; |
| |
| int nValues = pKey->countValues(); |
| for( int i = 0; i < nValues; i++ ) |
| { |
| const PPDValue* pValue = pKey->getValue( i ); |
| if( checkConstraints( pKey, pValue ) ) |
| rValues.push_back( pValue ); |
| } |
| } |
| |
| |
| // ------------------------------------------------------------------- |
| |
| void* PPDContext::getStreamableBuffer( sal_uLong& rBytes ) const |
| { |
| rBytes = 0; |
| if( ! m_aCurrentValues.size() ) |
| return NULL; |
| hash_type::const_iterator it; |
| for( it = m_aCurrentValues.begin(); it != m_aCurrentValues.end(); ++it ) |
| { |
| ByteString aCopy( it->first->getKey(), RTL_TEXTENCODING_MS_1252 ); |
| rBytes += aCopy.Len(); |
| rBytes += 1; // for ':' |
| if( it->second ) |
| { |
| aCopy = ByteString( it->second->m_aOption, RTL_TEXTENCODING_MS_1252 ); |
| rBytes += aCopy.Len(); |
| } |
| else |
| rBytes += 4; |
| rBytes += 1; // for '\0' |
| } |
| rBytes += 1; |
| void* pBuffer = new char[ rBytes ]; |
| memset( pBuffer, 0, rBytes ); |
| char* pRun = (char*)pBuffer; |
| for( it = m_aCurrentValues.begin(); it != m_aCurrentValues.end(); ++it ) |
| { |
| ByteString aCopy( it->first->getKey(), RTL_TEXTENCODING_MS_1252 ); |
| int nBytes = aCopy.Len(); |
| memcpy( pRun, aCopy.GetBuffer(), nBytes ); |
| pRun += nBytes; |
| *pRun++ = ':'; |
| if( it->second ) |
| aCopy = ByteString( it->second->m_aOption, RTL_TEXTENCODING_MS_1252 ); |
| else |
| aCopy = "*nil"; |
| nBytes = aCopy.Len(); |
| memcpy( pRun, aCopy.GetBuffer(), nBytes ); |
| pRun += nBytes; |
| |
| *pRun++ = 0; |
| } |
| return pBuffer; |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| void PPDContext::rebuildFromStreamBuffer( void* pBuffer, sal_uLong nBytes ) |
| { |
| if( ! m_pParser ) |
| return; |
| |
| m_aCurrentValues.clear(); |
| |
| char* pRun = (char*)pBuffer; |
| while( nBytes && *pRun ) |
| { |
| ByteString aLine( pRun ); |
| int nPos = aLine.Search( ':' ); |
| if( nPos != STRING_NOTFOUND ) |
| { |
| const PPDKey* pKey = m_pParser->getKey( String( aLine.Copy( 0, nPos ), RTL_TEXTENCODING_MS_1252 ) ); |
| if( pKey ) |
| { |
| const PPDValue* pValue = NULL; |
| String aOption( aLine.Copy( nPos+1 ), RTL_TEXTENCODING_MS_1252 ); |
| if( ! aOption.EqualsAscii( "*nil" ) ) |
| pValue = pKey->getValue( aOption ); |
| m_aCurrentValues[ pKey ] = pValue; |
| #ifdef __DEBUG |
| fprintf( stderr, "PPDContext::rebuildFromStreamBuffer: read PPDKeyValue { %s, %s }\n", pKV->m_pKey->getKey().GetStr(), pKV->m_pCurrentValue ? pKV->m_pCurrentValue->m_aOption.GetStr() : "<nil>" ); |
| #endif |
| } |
| } |
| nBytes -= aLine.Len()+1; |
| pRun += aLine.Len()+1; |
| } |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| int PPDContext::getRenderResolution() const |
| { |
| // initialize to reasonable default, if parser is not set |
| int nDPI = 300; |
| if( m_pParser ) |
| { |
| int nDPIx = 300, nDPIy = 300; |
| const PPDKey* pKey = m_pParser->getKey( String( RTL_CONSTASCII_USTRINGPARAM( "Resolution" ) ) ); |
| if( pKey ) |
| { |
| const PPDValue* pValue = getValue( pKey ); |
| if( pValue ) |
| m_pParser->getResolutionFromString( pValue->m_aOption, nDPIx, nDPIy ); |
| else |
| m_pParser->getDefaultResolution( nDPIx, nDPIy ); |
| } |
| else |
| m_pParser->getDefaultResolution( nDPIx, nDPIy ); |
| |
| nDPI = (nDPIx > nDPIy) ? nDPIx : nDPIy; |
| } |
| return nDPI; |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| void PPDContext::getPageSize( String& rPaper, int& rWidth, int& rHeight ) const |
| { |
| // initialize to reasonable default, if parser is not set |
| rPaper = String( RTL_CONSTASCII_USTRINGPARAM( "A4" ) ); |
| rWidth = 595; |
| rHeight = 842; |
| if( m_pParser ) |
| { |
| const PPDKey* pKey = m_pParser->getKey( String( RTL_CONSTASCII_USTRINGPARAM( "PageSize" ) ) ); |
| if( pKey ) |
| { |
| const PPDValue* pValue = getValue( pKey ); |
| if( pValue ) |
| { |
| rPaper = pValue->m_aOption; |
| m_pParser->getPaperDimension( rPaper, rWidth, rHeight ); |
| } |
| else |
| { |
| rPaper = m_pParser->getDefaultPaperDimension(); |
| m_pParser->getDefaultPaperDimension( rWidth, rHeight ); |
| } |
| } |
| } |
| } |
