xref: /aoo41x/main/vcl/source/gdi/print.cxx (revision 9f62ea84)

/**************************************************************
 *
 * 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"

#define ENABLE_BYTESTRING_STREAM_OPERATORS
#include <list>

#include <tools/debug.hxx>
#include <tools/resary.hxx>
#include <tools/stream.hxx>
#include <tools/vcompat.hxx>

#include <vcl/unohelp.hxx>
#include <vcl/svapp.hxx>
#include <vcl/wrkwin.hxx>
#include <vcl/virdev.hxx>
#include <vcl/window.hxx>
#include <vcl/gdimtf.hxx>
#include <vcl/metaact.hxx>
#include <vcl/print.hxx>

#include <salinst.hxx>
#include <salgdi.hxx>
#include <salptype.hxx>
#include <salprn.hxx>
#include <svdata.hxx>
#include <svids.hrc>
#include <jobset.h>
#include <outdev.h>
#include <print.h>

#include <comphelper/processfactory.hxx>

#include "com/sun/star/beans/XPropertySet.hpp"
#include "com/sun/star/container/XNameAccess.hpp"
#include "com/sun/star/lang/XMultiServiceFactory.hpp"

using namespace com::sun::star::uno;
using namespace com::sun::star::lang;
using namespace com::sun::star::beans;
using namespace com::sun::star::container;

int nImplSysDialog = 0;

// =======================================================================

namespace
{
    static Paper ImplGetPaperFormat( long nWidth100thMM, long nHeight100thMM )
    {
        PaperInfo aInfo(nWidth100thMM, nHeight100thMM);
        aInfo.doSloppyFit();
        return aInfo.getPaper();
    }

// -----------------------------------------------------------------------

    static const PaperInfo& ImplGetEmptyPaper()
    {
        static PaperInfo aInfo(PAPER_USER);
        return aInfo;
    }
}

// =======================================================================

void ImplUpdateJobSetupPaper( JobSetup& rJobSetup )
{
	const ImplJobSetup* pConstData = rJobSetup.ImplGetConstData();

	if ( !pConstData->mnPaperWidth || !pConstData->mnPaperHeight )
	{
		if ( pConstData->mePaperFormat != PAPER_USER )
		{
			ImplJobSetup* pData  = rJobSetup.ImplGetData();
            PaperInfo aInfo(pConstData->mePaperFormat);
			pData->mnPaperWidth  = aInfo.getWidth();
			pData->mnPaperHeight = aInfo.getHeight();
		}
	}
	else if ( pConstData->mePaperFormat == PAPER_USER )
	{
		Paper ePaper = ImplGetPaperFormat( pConstData->mnPaperWidth, pConstData->mnPaperHeight );
		if ( ePaper != PAPER_USER )
			rJobSetup.ImplGetData()->mePaperFormat = ePaper;
	}
}

// ------------------
// - PrinterOptions -
// ------------------

PrinterOptions::PrinterOptions() :
    mbReduceTransparency( sal_False ),
    meReducedTransparencyMode( PRINTER_TRANSPARENCY_AUTO ),
    mbReduceGradients( sal_False ),
    meReducedGradientsMode( PRINTER_GRADIENT_STRIPES ),
    mnReducedGradientStepCount( 64 ),
    mbReduceBitmaps( sal_False ),
    meReducedBitmapMode( PRINTER_BITMAP_NORMAL ),
    mnReducedBitmapResolution( 200 ),
    mbReducedBitmapsIncludeTransparency( sal_True ),
    mbConvertToGreyscales( sal_False )
{
}

// -----------------------------------------------------------------------

PrinterOptions::~PrinterOptions()
{
}

#define	PROPERTYNAME_REDUCETRANSPARENCY	                rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ReduceTransparency"))
#define	PROPERTYNAME_REDUCEDTRANSPARENCYMODE	        rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ReducedTransparencyMode"))
#define	PROPERTYNAME_REDUCEGRADIENTS		            rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ReduceGradients"))
#define	PROPERTYNAME_REDUCEDGRADIENTMODE		        rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ReducedGradientMode"))
#define PROPERTYNAME_REDUCEDGRADIENTSTEPCOUNT           rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ReducedGradientStepCount"))
#define PROPERTYNAME_REDUCEBITMAPS                      rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ReduceBitmaps"))
#define PROPERTYNAME_REDUCEDBITMAPMODE                  rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ReducedBitmapMode"))
#define PROPERTYNAME_REDUCEDBITMAPRESOLUTION            rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ReducedBitmapResolution"))
#define PROPERTYNAME_REDUCEDBITMAPINCLUDESTRANSPARENCY  rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ReducedBitmapIncludesTransparency"))
#define PROPERTYNAME_CONVERTTOGREYSCALES                rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ConvertToGreyscales"))

bool PrinterOptions::ReadFromConfig( bool i_bFile )
{
    bool bSuccess = false;
    // save old state in case something goes wrong
    PrinterOptions aOldValues( *this );

    // get the configuration service
    Reference< XMultiServiceFactory > xConfigProvider;
    Reference< XNameAccess > xConfigAccess;
    try
    {
        // get service provider
        Reference< XMultiServiceFactory > xSMgr( comphelper::getProcessServiceFactory() );
        // create configuration hierachical access name
        if( xSMgr.is() )
        {
            try
            {
                xConfigProvider = Reference< XMultiServiceFactory >(
                        xSMgr->createInstance( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
                                        "com.sun.star.configuration.ConfigurationProvider" ))),
                        UNO_QUERY );
                if( xConfigProvider.is() )
                {
                    Sequence< Any > aArgs(1);
                    PropertyValue aVal;
                    aVal.Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "nodepath" ) );
                    if( i_bFile )
                        aVal.Value <<= rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "/org.openoffice.Office.Common/Print/Option/File" ) );
                    else
                        aVal.Value <<= rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "/org.openoffice.Office.Common/Print/Option/Printer" ) );
                    aArgs.getArray()[0] <<= aVal;
                    xConfigAccess = Reference< XNameAccess >(
                            xConfigProvider->createInstanceWithArguments(
                                rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.configuration.ConfigurationAccess" )), aArgs ),
                                UNO_QUERY );
                    if( xConfigAccess.is() )
                    {
                        Reference< XPropertySet > xSet( xConfigAccess, UNO_QUERY );
                        if( xSet.is() )
                        {
                            sal_Int32 nValue = 0;
                            sal_Bool  bValue = 0;
                            if( xSet->getPropertyValue(PROPERTYNAME_REDUCETRANSPARENCY) >>= bValue )
                                SetReduceTransparency( bValue );
                            if( xSet->getPropertyValue(PROPERTYNAME_REDUCEDTRANSPARENCYMODE) >>= nValue )
                                SetReducedTransparencyMode( (PrinterTransparencyMode)nValue );
                            if( xSet->getPropertyValue(PROPERTYNAME_REDUCEGRADIENTS) >>= bValue )
                                SetReduceGradients( bValue );
                            if( xSet->getPropertyValue(PROPERTYNAME_REDUCEDGRADIENTMODE) >>= nValue )
                                SetReducedGradientMode( (PrinterGradientMode)nValue );
                            if( xSet->getPropertyValue(PROPERTYNAME_REDUCEDGRADIENTSTEPCOUNT) >>= nValue )
                                SetReducedGradientStepCount( (sal_uInt16)nValue );
                            if( xSet->getPropertyValue(PROPERTYNAME_REDUCEBITMAPS) >>= bValue )
                                SetReduceBitmaps( bValue );
                            if( xSet->getPropertyValue(PROPERTYNAME_REDUCEDBITMAPMODE) >>= nValue )
                                SetReducedBitmapMode( (PrinterBitmapMode)nValue );
                            if( xSet->getPropertyValue(PROPERTYNAME_REDUCEDBITMAPRESOLUTION) >>= nValue )
                                SetReducedBitmapResolution( (sal_uInt16)nValue );
                            if( xSet->getPropertyValue(PROPERTYNAME_REDUCEDBITMAPINCLUDESTRANSPARENCY) >>= bValue )
                                SetReducedBitmapIncludesTransparency( bValue );
                            if( xSet->getPropertyValue(PROPERTYNAME_CONVERTTOGREYSCALES) >>= bValue )
                                SetConvertToGreyscales( bValue );

                            bSuccess = true;
                        }
                    }
                }
            }
            catch( Exception& )
            {
            }
        }
    }
    catch( WrappedTargetException& )
    {
    }

    if( ! bSuccess )
        *this = aOldValues;
    return bSuccess;
}

void Printer::SetPrinterOptions( const PrinterOptions& i_rOptions )
{
    *mpPrinterOptions = i_rOptions;
}

// -------------
// - QueueInfo -
// -------------

QueueInfo::QueueInfo()
{
	mnStatus	= 0;
	mnJobs		= 0;
}

// -----------------------------------------------------------------------

QueueInfo::QueueInfo( const QueueInfo& rInfo ) :
	maPrinterName( rInfo.maPrinterName ),
	maDriver( rInfo.maDriver ),
	maLocation( rInfo.maLocation ),
	maComment( rInfo.maComment ),
	mnStatus( rInfo.mnStatus ),
	mnJobs( rInfo.mnJobs )
{
}

// -----------------------------------------------------------------------

QueueInfo::~QueueInfo()
{
}

// -----------------------------------------------------------------------

bool QueueInfo::operator==( const QueueInfo& rInfo ) const
{
	return
		maPrinterName	== rInfo.maPrinterName	&&
		maDriver		== rInfo.maDriver		&&
		maLocation		== rInfo.maLocation		&&
		maComment		== rInfo.maComment		&&
		mnStatus		== rInfo.mnStatus		&&
		mnJobs			== rInfo.mnJobs;
}

// -----------------------------------------------------------------------

SvStream& operator<<( SvStream& rOStream, const QueueInfo& rInfo )
{
	VersionCompat aCompat( rOStream, STREAM_WRITE, 1 );

	rOStream.WriteByteString( rInfo.maPrinterName, RTL_TEXTENCODING_UTF8 );
	rOStream.WriteByteString( rInfo.maDriver, RTL_TEXTENCODING_UTF8 );
	rOStream.WriteByteString( rInfo.maLocation, RTL_TEXTENCODING_UTF8 );
	rOStream.WriteByteString( rInfo.maComment, RTL_TEXTENCODING_UTF8 );
	rOStream << rInfo.mnStatus;
	rOStream << rInfo.mnJobs;

	return rOStream;
}

// -----------------------------------------------------------------------

SvStream& operator>>( SvStream& rIStream, QueueInfo& rInfo )
{
	VersionCompat aCompat( rIStream, STREAM_READ );

	rIStream.ReadByteString( rInfo.maPrinterName, RTL_TEXTENCODING_UTF8 );
	rIStream.ReadByteString( rInfo.maDriver, RTL_TEXTENCODING_UTF8 );
	rIStream.ReadByteString( rInfo.maLocation, RTL_TEXTENCODING_UTF8 );
	rIStream.ReadByteString( rInfo.maComment, RTL_TEXTENCODING_UTF8 );
	rIStream >> rInfo.mnStatus;
	rIStream >> rInfo.mnJobs;

	return rIStream;
}

// =======================================================================

SalPrinterQueueInfo::SalPrinterQueueInfo()
{
	mnStatus	= 0;
	mnJobs		= QUEUE_JOBS_DONTKNOW;
	mpSysData	= NULL;
}

// -----------------------------------------------------------------------

SalPrinterQueueInfo::~SalPrinterQueueInfo()
{
}

// -----------------------------------------------------------------------

ImplPrnQueueList::~ImplPrnQueueList()
{
	ImplSVData* 		pSVData = ImplGetSVData();
    for( unsigned int i = 0; i < m_aQueueInfos.size(); i++ )
    {
        delete m_aQueueInfos[i].mpQueueInfo;
        pSVData->mpDefInst->DeletePrinterQueueInfo( m_aQueueInfos[i].mpSalQueueInfo );
    }
}

// -----------------------------------------------------------------------

void ImplPrnQueueList::Add( SalPrinterQueueInfo* pData )
{
    std::hash_map< rtl::OUString, sal_Int32, rtl::OUStringHash >::iterator it =
        m_aNameToIndex.find( pData->maPrinterName );
    if( it == m_aNameToIndex.end() )
    {
        m_aNameToIndex[ pData->maPrinterName ] = m_aQueueInfos.size();
        m_aQueueInfos.push_back( ImplPrnQueueData() );
        m_aQueueInfos.back().mpQueueInfo = NULL;
        m_aQueueInfos.back().mpSalQueueInfo = pData;
        m_aPrinterList.push_back( pData->maPrinterName );
    }
    else // this should not happen, but ...
    {
        ImplPrnQueueData& rData = m_aQueueInfos[ it->second ];
        delete rData.mpQueueInfo;
        rData.mpQueueInfo = NULL;
        ImplGetSVData()->mpDefInst->DeletePrinterQueueInfo( rData.mpSalQueueInfo );
        rData.mpSalQueueInfo = pData;
    }
}

// -----------------------------------------------------------------------

ImplPrnQueueData* ImplPrnQueueList::Get( const rtl::OUString& rPrinter )
{
    ImplPrnQueueData* pData = NULL;
    std::hash_map<rtl::OUString,sal_Int32,rtl::OUStringHash>::iterator it =
        m_aNameToIndex.find( rPrinter );
    if( it != m_aNameToIndex.end() )
        pData = &m_aQueueInfos[it->second];
    return pData;
}

// =======================================================================

static void ImplInitPrnQueueList()
{
	ImplSVData* pSVData = ImplGetSVData();

	pSVData->maGDIData.mpPrinterQueueList = new ImplPrnQueueList;

    static const char* pEnv = getenv( "SAL_DISABLE_PRINTERLIST" );
    if( !pEnv || !*pEnv )
        pSVData->mpDefInst->GetPrinterQueueInfo( pSVData->maGDIData.mpPrinterQueueList );
}

// -----------------------------------------------------------------------

void ImplDeletePrnQueueList()
{
	ImplSVData* 		pSVData = ImplGetSVData();
	ImplPrnQueueList*	pPrnList = pSVData->maGDIData.mpPrinterQueueList;

	if ( pPrnList )
	{
		delete pPrnList;
		pSVData->maGDIData.mpPrinterQueueList = NULL;
	}
}

// -----------------------------------------------------------------------

const std::vector<rtl::OUString>& Printer::GetPrinterQueues()
{
	ImplSVData* 		pSVData = ImplGetSVData();
	if ( !pSVData->maGDIData.mpPrinterQueueList )
		ImplInitPrnQueueList();
    return pSVData->maGDIData.mpPrinterQueueList->m_aPrinterList;
}

// -----------------------------------------------------------------------
const QueueInfo* Printer::GetQueueInfo( const String& rPrinterName, bool bStatusUpdate )
{
	ImplSVData* pSVData = ImplGetSVData();

	if ( !pSVData->maGDIData.mpPrinterQueueList )
		ImplInitPrnQueueList();

    ImplPrnQueueData* pInfo = pSVData->maGDIData.mpPrinterQueueList->Get( rPrinterName );
    if( pInfo )
    {
        if( !pInfo->mpQueueInfo || bStatusUpdate )
            pSVData->mpDefInst->GetPrinterQueueState( pInfo->mpSalQueueInfo );

        if ( !pInfo->mpQueueInfo )
            pInfo->mpQueueInfo = new QueueInfo;

        pInfo->mpQueueInfo->maPrinterName	= pInfo->mpSalQueueInfo->maPrinterName;
        pInfo->mpQueueInfo->maDriver		= pInfo->mpSalQueueInfo->maDriver;
        pInfo->mpQueueInfo->maLocation		= pInfo->mpSalQueueInfo->maLocation;
        pInfo->mpQueueInfo->maComment		= pInfo->mpSalQueueInfo->maComment;
        pInfo->mpQueueInfo->mnStatus		= pInfo->mpSalQueueInfo->mnStatus;
        pInfo->mpQueueInfo->mnJobs			= pInfo->mpSalQueueInfo->mnJobs;
        return pInfo->mpQueueInfo;
    }
    return NULL;
}

// -----------------------------------------------------------------------

XubString Printer::GetDefaultPrinterName()
{
    static const char* pEnv = getenv( "SAL_DISABLE_DEFAULTPRINTER" );
    if( !pEnv || !*pEnv )
    {
        ImplSVData* pSVData = ImplGetSVData();

        return pSVData->mpDefInst->GetDefaultPrinter();
    }
    return XubString();
}

// =======================================================================

void Printer::ImplInitData()
{
	mbDevOutput 		= sal_False;
	meOutDevType		= OUTDEV_PRINTER;
	mbDefPrinter		= sal_False;
	mnError 			= 0;
	mnCurPage			= 0;
	mnCurPrintPage		= 0;
	mnPageQueueSize 	= 0;
	mnCopyCount 		= 1;
	mbCollateCopy		= sal_False;
	mbPrinting			= sal_False;
	mbJobActive 		= sal_False;
	mbPrintFile 		= sal_False;
	mbInPrintPage		= sal_False;
	mbNewJobSetup		= sal_False;
	mpInfoPrinter		= NULL;
	mpPrinter			= NULL;
	mpDisplayDev		= NULL;
	mbIsQueuePrinter	= sal_False;
    mpPrinterOptions    = new PrinterOptions;

	// Printer in die Liste eintragen
	ImplSVData* pSVData = ImplGetSVData();
	mpNext = pSVData->maGDIData.mpFirstPrinter;
	mpPrev = NULL;
	if ( mpNext )
		mpNext->mpPrev = this;
	else
		pSVData->maGDIData.mpLastPrinter = this;
	pSVData->maGDIData.mpFirstPrinter = this;
}

// -----------------------------------------------------------------------

void Printer::ImplInit( SalPrinterQueueInfo* pInfo )
{
	ImplSVData* pSVData = ImplGetSVData();
    // #i74084# update info for this specific SalPrinterQueueInfo
    pSVData->mpDefInst->GetPrinterQueueState( pInfo );

	// Testen, ob Treiber ueberhaupt mit dem JobSetup uebereinstimmt
	ImplJobSetup* pJobSetup = maJobSetup.ImplGetData();

	if ( pJobSetup->mpDriverData )
	{
		if ( (pJobSetup->maPrinterName != pInfo->maPrinterName) ||
			 (pJobSetup->maDriver != pInfo->maDriver) )
		{
			rtl_freeMemory( pJobSetup->mpDriverData );
			pJobSetup->mpDriverData = NULL;
			pJobSetup->mnDriverDataLen = 0;
		}
	}

	// Printernamen merken
	maPrinterName = pInfo->maPrinterName;
	maDriver = pInfo->maDriver;

	// In JobSetup den Printernamen eintragen
	pJobSetup->maPrinterName = maPrinterName;
	pJobSetup->maDriver = maDriver;

	mpInfoPrinter	= pSVData->mpDefInst->CreateInfoPrinter( pInfo, pJobSetup );
	mpPrinter		= NULL;
	mpJobGraphics	= NULL;
	ImplUpdateJobSetupPaper( maJobSetup );

	if ( !mpInfoPrinter )
	{
		ImplInitDisplay( NULL );
		return;
	}

	// we need a graphics
	if ( !ImplGetGraphics() )
	{
		ImplInitDisplay( NULL );
		return;
	}

	// Daten initialisieren
	ImplUpdatePageData();
	mpFontList = new ImplDevFontList();
	mpFontCache = new ImplFontCache( sal_True );
	mpGraphics->GetDevFontList( mpFontList );
}

// -----------------------------------------------------------------------

void Printer::ImplInitDisplay( const Window* pWindow )
{
	ImplSVData* pSVData = ImplGetSVData();

	mpInfoPrinter		= NULL;
	mpPrinter			= NULL;
	mpJobGraphics		= NULL;

	if ( pWindow )
		mpDisplayDev = new VirtualDevice( *pWindow );
	else
		mpDisplayDev = new VirtualDevice();
	mpFontList			= pSVData->maGDIData.mpScreenFontList;
	mpFontCache 		= pSVData->maGDIData.mpScreenFontCache;
	mnDPIX				= mpDisplayDev->mnDPIX;
	mnDPIY				= mpDisplayDev->mnDPIY;
}

// -----------------------------------------------------------------------

SalPrinterQueueInfo* Printer::ImplGetQueueInfo( const XubString& rPrinterName,
												const XubString* pDriver )
{
	ImplSVData* pSVData = ImplGetSVData();
	if ( !pSVData->maGDIData.mpPrinterQueueList )
		ImplInitPrnQueueList();

	ImplPrnQueueList* pPrnList = pSVData->maGDIData.mpPrinterQueueList;
	if ( pPrnList && pPrnList->m_aQueueInfos.size() )
	{
		// first search for the printer name driectly
		ImplPrnQueueData* pInfo = pPrnList->Get( rPrinterName );
		if( pInfo )
			return pInfo->mpSalQueueInfo;

		// then search case insensitive
        for( unsigned int i = 0; i < pPrnList->m_aQueueInfos.size(); i++ )
        {
            if( pPrnList->m_aQueueInfos[i].mpSalQueueInfo->maPrinterName.EqualsIgnoreCaseAscii( rPrinterName ) )
                return pPrnList->m_aQueueInfos[i].mpSalQueueInfo;
		}

		// then search for driver name
		if ( pDriver )
		{
            for( unsigned int i = 0; i < pPrnList->m_aQueueInfos.size(); i++ )
            {
                if( pPrnList->m_aQueueInfos[i].mpSalQueueInfo->maDriver == *pDriver )
                    return pPrnList->m_aQueueInfos[i].mpSalQueueInfo;
            }
		}

		// then the default printer
		pInfo = pPrnList->Get( GetDefaultPrinterName() );
        if( pInfo )
            return pInfo->mpSalQueueInfo;

        // last chance: the first available printer
        return pPrnList->m_aQueueInfos[0].mpSalQueueInfo;
	}

	return NULL;
}

// -----------------------------------------------------------------------

void Printer::ImplUpdatePageData()
{
	// we need a graphics
	if ( !ImplGetGraphics() )
		return;

	mpGraphics->GetResolution( mnDPIX, mnDPIY );
	mpInfoPrinter->GetPageInfo( maJobSetup.ImplGetConstData(),
								mnOutWidth, mnOutHeight,
								maPageOffset.X(), maPageOffset.Y(),
								maPaperSize.Width(), maPaperSize.Height() );
    static const char* pDebugOffset = getenv( "SAL_DBG_PAGEOFFSET" );
    if( pDebugOffset )
    {
        rtl::OString aLine( pDebugOffset );
        sal_Int32 nIndex = 0;
        rtl::OString aToken( aLine.getToken( 0, ',', nIndex ) );
        sal_Int32 nLeft = aToken.toInt32();
        sal_Int32 nTop = nLeft;
        if( nIndex > 0 )
        {
            aToken = aLine.getToken( 0, ',', nIndex );
            nTop = aToken.toInt32();
        }
        maPageOffset = LogicToPixel( Point( static_cast<long>(nLeft),
                                            static_cast<long>(nTop) ),
                                     MapMode( MAP_100TH_MM )
                                     );
        mnOutWidth = maPaperSize.Width() - 2*maPageOffset.X();
        mnOutWidth = maPaperSize.Width() - 2*maPageOffset.Y();
    }
}

// -----------------------------------------------------------------------

void Printer::ImplUpdateFontList()
{
	ImplUpdateFontData( sal_True );
}

// -----------------------------------------------------------------------

Printer::Printer()
{
	ImplInitData();
	SalPrinterQueueInfo* pInfo = ImplGetQueueInfo( GetDefaultPrinterName(), NULL );
	if ( pInfo )
	{
		ImplInit( pInfo );
		if ( !IsDisplayPrinter() )
			mbDefPrinter = sal_True;
	}
	else
		ImplInitDisplay( NULL );
}

// -----------------------------------------------------------------------

Printer::Printer( const Window* pWindow )
{
	ImplInitData();
	ImplInitDisplay( pWindow );
}

// -----------------------------------------------------------------------

Printer::Printer( const JobSetup& rJobSetup ) :
	maJobSetup( rJobSetup )
{
	ImplInitData();
	SalPrinterQueueInfo* pInfo = ImplGetQueueInfo( rJobSetup.mpData->maPrinterName,
												   &rJobSetup.mpData->maDriver );
	if ( pInfo )
	{
		ImplInit( pInfo );
		SetJobSetup( rJobSetup );
	}
	else
	{
		ImplInitDisplay( NULL );
		maJobSetup = JobSetup();
	}
}

// -----------------------------------------------------------------------

Printer::Printer( const QueueInfo& rQueueInfo )
{
	ImplInitData();
	SalPrinterQueueInfo* pInfo = ImplGetQueueInfo( rQueueInfo.GetPrinterName(),
												   &rQueueInfo.GetDriver() );
	if ( pInfo )
		ImplInit( pInfo );
	else
		ImplInitDisplay( NULL );
}

// -----------------------------------------------------------------------

Printer::Printer( const XubString& rPrinterName )
{
	ImplInitData();
	SalPrinterQueueInfo* pInfo = ImplGetQueueInfo( rPrinterName, NULL );
	if ( pInfo )
		ImplInit( pInfo );
	else
		ImplInitDisplay( NULL );
}

// -----------------------------------------------------------------------

Printer::~Printer()
{
	DBG_ASSERT( !IsPrinting(), "Printer::~Printer() - Job is printing" );
	DBG_ASSERT( !IsJobActive(), "Printer::~Printer() - Job is active" );

    delete mpPrinterOptions;

	ImplReleaseGraphics();
	if ( mpInfoPrinter )
		ImplGetSVData()->mpDefInst->DestroyInfoPrinter( mpInfoPrinter );
	if ( mpDisplayDev )
		delete mpDisplayDev;
	else
	{
		// OutputDevice-Dtor versucht das gleiche, deshalb muss hier
		// der FontEntry auch auf NULL gesetzt werden
        // TODO: consolidate duplicate cleanup by Printer and OutputDevice
		if ( mpFontEntry )
		{
			mpFontCache->Release( mpFontEntry );
			mpFontEntry = NULL;
		}
		if ( mpGetDevFontList )
		{
			delete mpGetDevFontList;
			mpGetDevFontList = NULL;
		}
		if ( mpGetDevSizeList )
		{
			delete mpGetDevSizeList;
			mpGetDevSizeList = NULL;
		}
		delete mpFontCache;
        mpFontCache = NULL;
        // font list deleted by OutputDevice dtor
	}

	// Printer aus der Liste eintragen
	ImplSVData* pSVData = ImplGetSVData();
	if ( mpPrev )
		mpPrev->mpNext = mpNext;
	else
		pSVData->maGDIData.mpFirstPrinter = mpNext;
	if ( mpNext )
		mpNext->mpPrev = mpPrev;
	else
		pSVData->maGDIData.mpLastPrinter = mpPrev;
}

// -----------------------------------------------------------------------
void Printer::Compat_OldPrinterMetrics( bool bSet )
{
    // propagate flag
    if( mpInfoPrinter )
        mpInfoPrinter->m_bCompatMetrics = bSet;

    // get new font data
    ImplUpdateFontData( sal_True );
}

// -----------------------------------------------------------------------

sal_uLong Printer::GetCapabilities( sal_uInt16 nType ) const
{
	if ( IsDisplayPrinter() )
		return sal_False;

    if( mpInfoPrinter )
	    return mpInfoPrinter->GetCapabilities( maJobSetup.ImplGetConstData(), nType );
    else
        return sal_False;
}

// -----------------------------------------------------------------------

sal_Bool Printer::HasSupport( PrinterSupport eFeature ) const
{
	switch ( eFeature )
	{
		case SUPPORT_SET_ORIENTATION:
			return (sal_Bool)GetCapabilities( PRINTER_CAPABILITIES_SETORIENTATION );
		case SUPPORT_SET_PAPERBIN:
			return (sal_Bool)GetCapabilities( PRINTER_CAPABILITIES_SETPAPERBIN );
		case SUPPORT_SET_PAPERSIZE:
			return (sal_Bool)GetCapabilities( PRINTER_CAPABILITIES_SETPAPERSIZE );
		case SUPPORT_SET_PAPER:
			return (sal_Bool)GetCapabilities( PRINTER_CAPABILITIES_SETPAPER );
		case SUPPORT_COPY:
			return (GetCapabilities( PRINTER_CAPABILITIES_COPIES ) != 0);
		case SUPPORT_COLLATECOPY:
			return (GetCapabilities( PRINTER_CAPABILITIES_COLLATECOPIES ) != 0);
		case SUPPORT_SETUPDIALOG:
			return (sal_Bool)GetCapabilities( PRINTER_CAPABILITIES_SUPPORTDIALOG );
		case SUPPORT_FAX:
			return (sal_Bool) GetCapabilities( PRINTER_CAPABILITIES_FAX );
		case SUPPORT_PDF:
			return (sal_Bool) GetCapabilities( PRINTER_CAPABILITIES_PDF );
	}

	return sal_True;
}

// -----------------------------------------------------------------------

sal_Bool Printer::SetJobSetup( const JobSetup& rSetup )
{
	if ( IsDisplayPrinter() || mbInPrintPage )
		return sal_False;

	JobSetup aJobSetup = rSetup;

	ImplReleaseGraphics();
	if ( mpInfoPrinter->SetPrinterData( aJobSetup.ImplGetData() ) )
	{
		ImplUpdateJobSetupPaper( aJobSetup );
		mbNewJobSetup = sal_True;
		maJobSetup = aJobSetup;
		ImplUpdatePageData();
		ImplUpdateFontList();
		return sal_True;
	}

	return sal_False;
}

// -----------------------------------------------------------------------


sal_Bool Printer::Setup( Window* pWindow )
{
	if ( IsDisplayPrinter() )
		return sal_False;

	if ( IsJobActive() || IsPrinting() )
		return sal_False;

	JobSetup aJobSetup = maJobSetup;
	SalFrame* pFrame;
	if ( !pWindow )
        pWindow = ImplGetDefaultWindow();
    if( !pWindow )
        return sal_False;

    pFrame = pWindow->ImplGetFrame();
	ImplReleaseGraphics();
	ImplSVData* pSVData = ImplGetSVData();
	pSVData->maAppData.mnModalMode++;
	nImplSysDialog++;
	sal_Bool bSetup = mpInfoPrinter->Setup( pFrame, aJobSetup.ImplGetData() );
	pSVData->maAppData.mnModalMode--;
	nImplSysDialog--;
	if ( bSetup )
	{
		ImplUpdateJobSetupPaper( aJobSetup );
		mbNewJobSetup = sal_True;
		maJobSetup = aJobSetup;
		ImplUpdatePageData();
		ImplUpdateFontList();
		return sal_True;
	}
	return sal_False;
}

// -----------------------------------------------------------------------

sal_Bool Printer::SetPrinterProps( const Printer* pPrinter )
{
	if ( IsJobActive() || IsPrinting() )
		return sal_False;

	ImplSVData* pSVData = ImplGetSVData();

	mbDefPrinter	    = pPrinter->mbDefPrinter;
	maPrintFile 	    = pPrinter->maPrintFile;
	mbPrintFile 	    = pPrinter->mbPrintFile;
	mnCopyCount 	    = pPrinter->mnCopyCount;
	mbCollateCopy	    = pPrinter->mbCollateCopy;
	mnPageQueueSize     = pPrinter->mnPageQueueSize;
    *mpPrinterOptions   = *pPrinter->mpPrinterOptions;

	if ( pPrinter->IsDisplayPrinter() )
	{
		// Alten Printer zerstoeren
		if ( !IsDisplayPrinter() )
		{
			ImplReleaseGraphics();
			pSVData->mpDefInst->DestroyInfoPrinter( mpInfoPrinter );
			if ( mpFontEntry )
			{
				mpFontCache->Release( mpFontEntry );
				mpFontEntry = NULL;
			}
			if ( mpGetDevFontList )
			{
				delete mpGetDevFontList;
				mpGetDevFontList = NULL;
			}
			if ( mpGetDevSizeList )
			{
				delete mpGetDevSizeList;
				mpGetDevSizeList = NULL;
			}
            // clean up font list
			delete mpFontCache;
			delete mpFontList;
			mpFontCache = NULL;
			mpFontList = NULL;

			mbInitFont = sal_True;
			mbNewFont = sal_True;
			mpInfoPrinter = NULL;
		}

		// Neuen Printer bauen
		ImplInitDisplay( NULL );
		return sal_True;
	}

	// Alten Printer zerstoeren?
	if ( GetName() != pPrinter->GetName() )
	{
		ImplReleaseGraphics();
		if ( mpDisplayDev )
		{
			delete mpDisplayDev;
			mpDisplayDev = NULL;
		}
		else
		{
			pSVData->mpDefInst->DestroyInfoPrinter( mpInfoPrinter );

			if ( mpFontEntry )
			{
				mpFontCache->Release( mpFontEntry );
				mpFontEntry = NULL;
			}
			if ( mpGetDevFontList )
			{
				delete mpGetDevFontList;
				mpGetDevFontList = NULL;
			}
			if ( mpGetDevSizeList )
			{
				delete mpGetDevSizeList;
				mpGetDevSizeList = NULL;
			}
			delete mpFontCache;
			delete mpFontList;
			mpFontCache = NULL;
			mpFontList = NULL;
			mbInitFont = sal_True;
			mbNewFont = sal_True;
			mpInfoPrinter = NULL;
		}

		// Neuen Printer bauen
		XubString aDriver = pPrinter->GetDriverName();
		SalPrinterQueueInfo* pInfo = ImplGetQueueInfo( pPrinter->GetName(), &aDriver );
		if ( pInfo )
		{
			ImplInit( pInfo );
			SetJobSetup( pPrinter->GetJobSetup() );
		}
		else
			ImplInitDisplay( NULL );
	}
	else
		SetJobSetup( pPrinter->GetJobSetup() );

	return sal_False;
}

// -----------------------------------------------------------------------

sal_Bool Printer::SetOrientation( Orientation eOrientation )
{
	if ( mbInPrintPage )
		return sal_False;

	if ( maJobSetup.ImplGetConstData()->meOrientation != eOrientation )
	{
		JobSetup		aJobSetup = maJobSetup;
		ImplJobSetup*	pSetupData = aJobSetup.ImplGetData();
		pSetupData->meOrientation = eOrientation;

		if ( IsDisplayPrinter() )
		{
			mbNewJobSetup = sal_True;
			maJobSetup = aJobSetup;
			return sal_True;
		}

		ImplReleaseGraphics();
		if ( mpInfoPrinter->SetData( SAL_JOBSET_ORIENTATION, pSetupData ) )
		{
			ImplUpdateJobSetupPaper( aJobSetup );
			mbNewJobSetup = sal_True;
			maJobSetup = aJobSetup;
			ImplUpdatePageData();
			ImplUpdateFontList();
			return sal_True;
		}
		else
			return sal_False;
	}

	return sal_True;
}

// -----------------------------------------------------------------------

Orientation Printer::GetOrientation() const
{
	return maJobSetup.ImplGetConstData()->meOrientation;
}

// -----------------------------------------------------------------------

sal_Bool Printer::SetPaperBin( sal_uInt16 nPaperBin )
{
	if ( mbInPrintPage )
		return sal_False;

	if ( (maJobSetup.ImplGetConstData()->mnPaperBin != nPaperBin) &&
		 (nPaperBin < GetPaperBinCount()) )
	{
		JobSetup		aJobSetup = maJobSetup;
		ImplJobSetup*	pSetupData = aJobSetup.ImplGetData();
		pSetupData->mnPaperBin = nPaperBin;

		if ( IsDisplayPrinter() )
		{
			mbNewJobSetup = sal_True;
			maJobSetup = aJobSetup;
			return sal_True;
		}

		ImplReleaseGraphics();
		if ( mpInfoPrinter->SetData( SAL_JOBSET_PAPERBIN, pSetupData ) )
		{
			ImplUpdateJobSetupPaper( aJobSetup );
			mbNewJobSetup = sal_True;
			maJobSetup = aJobSetup;
			ImplUpdatePageData();
			ImplUpdateFontList();
			return sal_True;
		}
		else
			return sal_False;
	}

	return sal_True;
}

// -----------------------------------------------------------------------

sal_uInt16 Printer::GetPaperBin() const
{
	return maJobSetup.ImplGetConstData()->mnPaperBin;
}

// -----------------------------------------------------------------------

// Map user paper format to a available printer paper formats
void Printer::ImplFindPaperFormatForUserSize( JobSetup& aJobSetup, bool bMatchNearest )
{
	ImplJobSetup*	pSetupData = aJobSetup.ImplGetData();

	int		nLandscapeAngle	= GetLandscapeAngle();
	int		nPaperCount		= GetPaperInfoCount();
    bool    bFound = false;

    PaperInfo aInfo(pSetupData->mnPaperWidth, pSetupData->mnPaperHeight);

	// Alle Papierformate vergleichen und ein passendes raussuchen
	for ( int i = 0; i < nPaperCount; i++ )
	{
		const PaperInfo& rPaperInfo = GetPaperInfo( i );

		if ( aInfo.sloppyEqual(rPaperInfo) )
		{
			pSetupData->mePaperFormat = ImplGetPaperFormat( rPaperInfo.getWidth(),
															rPaperInfo.getHeight() );
            pSetupData->meOrientation = ORIENTATION_PORTRAIT;
            bFound = true;
			break;
		}
	}

	// If the printer supports landscape orientation, check paper sizes again
	// with landscape orientation. This is necessary as a printer driver provides
	// all paper sizes with portrait orientation only!!
	if ( pSetupData->mePaperFormat == PAPER_USER &&
		 nLandscapeAngle != 0 &&
		 HasSupport( SUPPORT_SET_ORIENTATION ))
	{

        PaperInfo aRotatedInfo(pSetupData->mnPaperHeight, pSetupData->mnPaperWidth);

		for ( int i = 0; i < nPaperCount; i++ )
		{
			const PaperInfo& rPaperInfo = GetPaperInfo( i );

			if ( aRotatedInfo.sloppyEqual( rPaperInfo ) )
			{
				pSetupData->mePaperFormat = ImplGetPaperFormat( rPaperInfo.getWidth(),
																rPaperInfo.getHeight() );
                pSetupData->meOrientation = ORIENTATION_LANDSCAPE;
                bFound = true;
				break;
			}
		}
	}

    if( ! bFound && bMatchNearest )
    {
         sal_Int64 nBestMatch = SAL_MAX_INT64;
         int nBestIndex = 0;
         Orientation eBestOrientation = ORIENTATION_PORTRAIT;
         for( int i = 0; i < nPaperCount; i++ )
         {
             const PaperInfo& rPaperInfo = GetPaperInfo( i );

             // check protrait match
             sal_Int64 nDX = pSetupData->mnPaperWidth - rPaperInfo.getWidth();
             sal_Int64 nDY = pSetupData->mnPaperHeight - rPaperInfo.getHeight();
             sal_Int64 nMatch = nDX*nDX + nDY*nDY;
             if( nMatch < nBestMatch )
             {
                 nBestMatch = nMatch;
                 nBestIndex = i;
                 eBestOrientation = ORIENTATION_PORTRAIT;
             }

             // check landscape match
             nDX = pSetupData->mnPaperWidth - rPaperInfo.getHeight();
             nDY = pSetupData->mnPaperHeight - rPaperInfo.getWidth();
             nMatch = nDX*nDX + nDY*nDY;
             if( nMatch < nBestMatch )
             {
                 nBestMatch = nMatch;
                 nBestIndex = i;
                 eBestOrientation = ORIENTATION_LANDSCAPE;
             }
         }
         const PaperInfo& rBestInfo = GetPaperInfo( nBestIndex );
         pSetupData->mePaperFormat = ImplGetPaperFormat( rBestInfo.getWidth(),
                                                         rBestInfo.getHeight() );
         pSetupData->meOrientation = eBestOrientation;
    }
}

// -----------------------------------------------------------------------

sal_Bool Printer::SetPaper( Paper ePaper )
{
	if ( mbInPrintPage )
		return sal_False;

	if ( maJobSetup.ImplGetConstData()->mePaperFormat != ePaper )
	{
		JobSetup		aJobSetup = maJobSetup;
		ImplJobSetup*	pSetupData = aJobSetup.ImplGetData();
		pSetupData->mePaperFormat = ePaper;
		if ( ePaper != PAPER_USER )
		{
            PaperInfo aInfo(ePaper);
			pSetupData->mnPaperWidth  = aInfo.getWidth();
			pSetupData->mnPaperHeight = aInfo.getHeight();
		}

		if ( IsDisplayPrinter() )
		{
			mbNewJobSetup = sal_True;
			maJobSetup = aJobSetup;
			return sal_True;
		}

		ImplReleaseGraphics();
		if ( ePaper == PAPER_USER )
			ImplFindPaperFormatForUserSize( aJobSetup, false );
		if ( mpInfoPrinter->SetData( SAL_JOBSET_PAPERSIZE|SAL_JOBSET_ORIENTATION, pSetupData ) )
		{
			ImplUpdateJobSetupPaper( aJobSetup );
			mbNewJobSetup = sal_True;
			maJobSetup = aJobSetup;
			ImplUpdatePageData();
			ImplUpdateFontList();
			return sal_True;
		}
		else
			return sal_False;
	}

	return sal_True;
}

// -----------------------------------------------------------------------

sal_Bool Printer::SetPaperSizeUser( const Size& rSize )
{
    return SetPaperSizeUser( rSize, false );
}

sal_Bool Printer::SetPaperSizeUser( const Size& rSize, bool bMatchNearest )
{
	if ( mbInPrintPage )
		return sal_False;

	Size	aPixSize = LogicToPixel( rSize );
	Size	aPageSize = PixelToLogic( aPixSize, MAP_100TH_MM );
	if ( (maJobSetup.ImplGetConstData()->mePaperFormat != PAPER_USER)		||
		 (maJobSetup.ImplGetConstData()->mnPaperWidth  != aPageSize.Width()) ||
		 (maJobSetup.ImplGetConstData()->mnPaperHeight != aPageSize.Height()) )
	{
		JobSetup		aJobSetup = maJobSetup;
		ImplJobSetup*	pSetupData = aJobSetup.ImplGetData();
		pSetupData->mePaperFormat	= PAPER_USER;
		pSetupData->mnPaperWidth	= aPageSize.Width();
		pSetupData->mnPaperHeight	= aPageSize.Height();

		if ( IsDisplayPrinter() )
		{
			mbNewJobSetup = sal_True;
			maJobSetup = aJobSetup;
			return sal_True;
		}

		ImplReleaseGraphics();
		ImplFindPaperFormatForUserSize( aJobSetup, bMatchNearest );

		// Changing the paper size can also change the orientation!
		if ( mpInfoPrinter->SetData( SAL_JOBSET_PAPERSIZE|SAL_JOBSET_ORIENTATION, pSetupData ) )
		{
			ImplUpdateJobSetupPaper( aJobSetup );
			mbNewJobSetup = sal_True;
			maJobSetup = aJobSetup;
			ImplUpdatePageData();
			ImplUpdateFontList();
			return sal_True;
		}
		else
			return sal_False;
	}

	return sal_True;
}

// -----------------------------------------------------------------------

int Printer::GetPaperInfoCount() const
{
    if( ! mpInfoPrinter )
        return 0;
    if( ! mpInfoPrinter->m_bPapersInit )
        mpInfoPrinter->InitPaperFormats( maJobSetup.ImplGetConstData() );
    return mpInfoPrinter->m_aPaperFormats.size();
}

// -----------------------------------------------------------------------

rtl::OUString Printer::GetPaperName( Paper ePaper )
{
    ImplSVData* pSVData = ImplGetSVData();
    if( ! pSVData->mpPaperNames )
    {
        pSVData->mpPaperNames = new std::hash_map< int, rtl::OUString >();
        if( ImplGetResMgr() )
        {
            ResStringArray aPaperStrings( VclResId( RID_STR_PAPERNAMES ) );
            static const int PaperIndex[] =
            {
                PAPER_A0, PAPER_A1, PAPER_A2, PAPER_A3, PAPER_A4, PAPER_A5,
                PAPER_B4_ISO, PAPER_B5_ISO, PAPER_LETTER, PAPER_LEGAL, PAPER_TABLOID,
                PAPER_USER, PAPER_B6_ISO, PAPER_ENV_C4, PAPER_ENV_C5, PAPER_ENV_C6, PAPER_ENV_C65,
                PAPER_ENV_DL, PAPER_SLIDE_DIA, PAPER_SCREEN, PAPER_C, PAPER_D, PAPER_E,
                PAPER_EXECUTIVE, PAPER_FANFOLD_LEGAL_DE, PAPER_ENV_MONARCH, PAPER_ENV_PERSONAL,
                PAPER_ENV_9, PAPER_ENV_10, PAPER_ENV_11, PAPER_ENV_12, PAPER_KAI16,
                PAPER_KAI32, PAPER_KAI32BIG, PAPER_B4_JIS, PAPER_B5_JIS, PAPER_B6_JIS
            };
            OSL_ENSURE( sal_uInt32(sizeof(PaperIndex)/sizeof(PaperIndex[0])) == aPaperStrings.Count(), "localized paper name count wrong" );
            for( int i = 0; i < int(sizeof(PaperIndex)/sizeof(PaperIndex[0])); i++ )
                (*pSVData->mpPaperNames)[PaperIndex[i]] = aPaperStrings.GetString(i);
        }
    }

    std::hash_map<int,rtl::OUString>::const_iterator it = pSVData->mpPaperNames->find( (int)ePaper );
    return (it != pSVData->mpPaperNames->end()) ? it->second : rtl::OUString();
}

// -----------------------------------------------------------------------

rtl::OUString Printer::GetPaperName( bool i_bPaperUser ) const
{
	Size  aPageSize = PixelToLogic( GetPaperSizePixel(), MAP_100TH_MM );
	Paper ePaper    = ImplGetPaperFormat( aPageSize.Width(), aPageSize.Height() );
	if( ePaper == PAPER_USER )
	    ePaper = ImplGetPaperFormat( aPageSize.Height(), aPageSize.Width() );
	return (ePaper != PAPER_USER || i_bPaperUser ) ? GetPaperName( ePaper ) : rtl::OUString();
}

// -----------------------------------------------------------------------

const PaperInfo& Printer::GetPaperInfo( int nPaper ) const
{
    if( ! mpInfoPrinter )
        return ImplGetEmptyPaper();
    if( ! mpInfoPrinter->m_bPapersInit )
        mpInfoPrinter->InitPaperFormats( maJobSetup.ImplGetConstData() );
    if( mpInfoPrinter->m_aPaperFormats.empty() || nPaper < 0 || nPaper >= int(mpInfoPrinter->m_aPaperFormats.size()) )
        return ImplGetEmptyPaper();
    return mpInfoPrinter->m_aPaperFormats[nPaper];
}

// -----------------------------------------------------------------------

DuplexMode Printer::GetDuplexMode() const
{
	return maJobSetup.ImplGetConstData()->meDuplexMode;
}

// -----------------------------------------------------------------------

sal_Bool Printer::SetDuplexMode( DuplexMode eDuplex )
{
	if ( mbInPrintPage )
		return sal_False;

	if ( maJobSetup.ImplGetConstData()->meDuplexMode != eDuplex )
	{
		JobSetup		aJobSetup = maJobSetup;
		ImplJobSetup*	pSetupData = aJobSetup.ImplGetData();
		pSetupData->meDuplexMode = eDuplex;

		if ( IsDisplayPrinter() )
		{
			mbNewJobSetup = sal_True;
			maJobSetup = aJobSetup;
			return sal_True;
		}

		ImplReleaseGraphics();
		if ( mpInfoPrinter->SetData( SAL_JOBSET_DUPLEXMODE, pSetupData ) )
		{
			ImplUpdateJobSetupPaper( aJobSetup );
			mbNewJobSetup = sal_True;
			maJobSetup = aJobSetup;
			ImplUpdatePageData();
			ImplUpdateFontList();
			return sal_True;
		}
		else
			return sal_False;
	}

	return sal_True;
}

// -----------------------------------------------------------------------

int Printer::GetLandscapeAngle() const
{
    return mpInfoPrinter ? mpInfoPrinter->GetLandscapeAngle( maJobSetup.ImplGetConstData() ) : 900;
}

// -----------------------------------------------------------------------

Paper Printer::GetPaper() const
{
	return maJobSetup.ImplGetConstData()->mePaperFormat;
}

// -----------------------------------------------------------------------

sal_uInt16 Printer::GetPaperBinCount() const
{
	if ( IsDisplayPrinter() )
		return 0;

	return (sal_uInt16)mpInfoPrinter->GetPaperBinCount( maJobSetup.ImplGetConstData() );
}

// -----------------------------------------------------------------------

XubString Printer::GetPaperBinName( sal_uInt16 nPaperBin ) const
{
	if ( IsDisplayPrinter() )
		return ImplGetSVEmptyStr();

	if ( nPaperBin < GetPaperBinCount() )
		return mpInfoPrinter->GetPaperBinName( maJobSetup.ImplGetConstData(), nPaperBin );
	else
		return ImplGetSVEmptyStr();
}

// -----------------------------------------------------------------------

sal_Bool Printer::SetCopyCount( sal_uInt16 nCopy, sal_Bool bCollate )
{
	mnCopyCount = nCopy;
    mbCollateCopy = bCollate;
	return sal_True;
}

// -----------------------------------------------------------------------

void Printer::Error()
{
	maErrorHdl.Call( this );
}

// -----------------------------------------------------------------------


sal_uLong Printer::ImplSalPrinterErrorCodeToVCL( sal_uLong nError )
{
	sal_uLong nVCLError;
	switch ( nError )
	{
		case 0:
			nVCLError = PRINTER_OK;
			break;
		case SAL_PRINTER_ERROR_ABORT:
			nVCLError = PRINTER_ABORT;
			break;
		default:
			nVCLError = PRINTER_GENERALERROR;
			break;
	}

	return nVCLError;
}

// -----------------------------------------------------------------------

void Printer::ImplEndPrint()
{
	mbPrinting		= sal_False;
	mnCurPrintPage	= 0;
	maJobName.Erase();
}

// -----------------------------------------------------------------------

IMPL_LINK( Printer, ImplDestroyPrinterAsync, void*, pSalPrinter )
{
	SalPrinter* pPrinter = (SalPrinter*)pSalPrinter;
	ImplSVData* pSVData = ImplGetSVData();
	pSVData->mpDefInst->DestroyPrinter( pPrinter );
	return 0;
}

// -----------------------------------------------------------------------

sal_Bool Printer::EndJob()
{
	sal_Bool bRet = sal_False;
	if ( !IsJobActive() )
		return bRet;

	DBG_ASSERT( !mbInPrintPage, "Printer::EndJob() - StartPage() without EndPage() called" );

	mbJobActive = sal_False;

	if ( mpPrinter )
	{
		ImplReleaseGraphics();

		mnCurPage = 0;

		bRet = sal_True;

        mbPrinting		= sal_False;
        mnCurPrintPage	= 0;
        maJobName.Erase();

        mbDevOutput = sal_False;
        bRet = mpPrinter->EndJob();
        // Hier den Drucker nicht asyncron zerstoeren, da es
        // W95 nicht verkraftet, wenn gleichzeitig gedruckt wird
        // und ein Druckerobjekt zerstoert wird
        ImplGetSVData()->mpDefInst->DestroyPrinter( mpPrinter );
        mpPrinter = NULL;
	}

	return bRet;
}

// -----------------------------------------------------------------------

sal_Bool Printer::AbortJob()
{
	// Wenn wir einen Queue-Printer haben, kann man diesen noch mit
	// AbortJob() abbrechen, solange dieser noch am Drucken ist
	if ( !IsJobActive() && !IsPrinting() )
		return sal_False;

	mbJobActive 	= sal_False;
	mbInPrintPage	= sal_False;
	mpJobGraphics	= NULL;

	if ( mpPrinter )
	{
		mbPrinting		= sal_False;
		mnCurPage		= 0;
		mnCurPrintPage	= 0;
		maJobName.Erase();

        ImplReleaseGraphics();
        mbDevOutput = sal_False;
        mpPrinter->AbortJob();
        Application::PostUserEvent( LINK( this, Printer, ImplDestroyPrinterAsync ), mpPrinter );
        mpPrinter = NULL;

		return sal_True;
	}

	return sal_False;
}

// -----------------------------------------------------------------------

void Printer::ImplStartPage()
{
	if ( !IsJobActive() )
		return;

	if ( mpPrinter )
	{
        SalGraphics* pGraphics = mpPrinter->StartPage( maJobSetup.ImplGetConstData(), mbNewJobSetup );
        if ( pGraphics )
        {
            ImplReleaseGraphics();
            mpJobGraphics = pGraphics;
        }
        mbDevOutput = sal_True;

		// PrintJob not aborted ???
		if ( IsJobActive() )
		{
			mbInPrintPage = sal_True;
			mnCurPage++;
            mnCurPrintPage++;
		}
	}
}

// -----------------------------------------------------------------------

void Printer::ImplEndPage()
{
	if ( !IsJobActive() )
		return;

	mbInPrintPage = sal_False;

	if ( mpPrinter )
	{
        mpPrinter->EndPage();
        ImplReleaseGraphics();
        mbDevOutput = sal_False;

		mpJobGraphics = NULL;
		mbNewJobSetup = sal_False;
	}
}

// -----------------------------------------------------------------------

void Printer::updatePrinters()
{
	ImplSVData* 		pSVData = ImplGetSVData();
	ImplPrnQueueList*	pPrnList = pSVData->maGDIData.mpPrinterQueueList;

	if ( pPrnList )
	{
        ImplPrnQueueList* pNewList = new ImplPrnQueueList;
        pSVData->mpDefInst->GetPrinterQueueInfo( pNewList );

        bool bChanged = pPrnList->m_aQueueInfos.size() != pNewList->m_aQueueInfos.size();
        for( unsigned int i = 0; ! bChanged && i < pPrnList->m_aQueueInfos.size(); i++ )
        {
            ImplPrnQueueData& rInfo     = pPrnList->m_aQueueInfos[i];
            ImplPrnQueueData& rNewInfo  = pNewList->m_aQueueInfos[i];
            if( ! rInfo.mpSalQueueInfo || ! rNewInfo.mpSalQueueInfo || // sanity check
                rInfo.mpSalQueueInfo->maPrinterName != rNewInfo.mpSalQueueInfo->maPrinterName )
            {
                bChanged = true;
            }
		}
        if( bChanged )
        {
            ImplDeletePrnQueueList();
            pSVData->maGDIData.mpPrinterQueueList = pNewList;

            Application* pApp = GetpApp();
            if( pApp )
            {
                DataChangedEvent aDCEvt( DATACHANGED_PRINTER );
                pApp->DataChanged( aDCEvt );
                pApp->NotifyAllWindows( aDCEvt );
            }
        }
        else
            delete pNewList;
	}
}