xref: /aoo41x/main/sw/source/ui/config/optpage.cxx (revision 4d7c9de0)

/**************************************************************
 *
 * 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_sw.hxx"

#ifdef SW_DLLIMPLEMENTATION
#undef SW_DLLIMPLEMENTATION
#endif

#ifndef _SVSTDARR_HXX
#define _SVSTDARR_STRINGSDTOR
#include <svl/svstdarr.hxx>
#endif

#include <optpage.hxx>
#include <doc.hxx>
#include <hintids.hxx>
#include <cmdid.h>
#include <fmtcol.hxx>
#include <charatr.hxx>
#include <swtypes.hxx>
#include <view.hxx>
#include <docsh.hxx>
#include <IDocumentDeviceAccess.hxx>
#include <swmodule.hxx>
#include <wrtsh.hxx>
#include <uitool.hxx>
#include <cfgitems.hxx>
#include <poolfmt.hxx>
#include <uiitems.hxx>
#include <initui.hxx>
#include <printdata.hxx>
#include <modcfg.hxx>
#include <srcview.hxx>
#include <crstate.hxx>
#include <viewopt.hxx>
#include <globals.hrc>
#include <config.hrc>
#include <redlopt.hrc>
#include <optdlg.hrc>
#include <swwrtshitem.hxx>
#include <unomid.h>

#include <editeng/fhgtitem.hxx>
#include <editeng/fontitem.hxx>
#include <editeng/langitem.hxx>
#include <sfx2/request.hxx>
#include <sfx2/printer.hxx>
#include <sfx2/bindings.hxx>
#include <svl/slstitm.hxx>
#include <svl/ctloptions.hxx>
#include <svl/eitem.hxx>
#include <svl/cjkoptions.hxx>
#include <svtools/ctrltool.hxx>
#include <svx/htmlmode.hxx>
#include <svx/xtable.hxx>
#include <svx/dlgutil.hxx>
#include <svx/strarray.hxx>
#include <vcl/svapp.hxx>



using namespace ::com::sun::star;


/*******************************************************
 ******************************************************/

/*-----------------31.08.96 10.16-------------------
	TabPage Anzeige/Inhalt
--------------------------------------------------*/

SwContentOptPage::SwContentOptPage( Window* pParent,
									  const SfxItemSet& rCoreSet ) :
	SfxTabPage( pParent, SW_RES( TP_CONTENT_OPT ), rCoreSet ),
    aLineFL       ( this,   SW_RES( FL_LINE     ) ),
	aCrossCB   	  ( this,	SW_RES( CB_CROSS     ) ),
	aSolidHandleCB( this, 	SW_RES( CB_HANDLE	) ),
	aBigHandleCB  ( this, 	SW_RES( CB_BIGHANDLE) ),

    aWindowFL     ( this,   SW_RES( FL_WINDOW   ) ),
	aHScrollBox   ( this,	SW_RES( CB_HSCROLL   ) ),
	aVScrollBox   ( this,	SW_RES( CB_VSCROLL   ) ),
    aAnyRulerCB   ( this,   SW_RES( CB_ANY_RULER ) ),
    aHRulerCBox   ( this,   SW_RES( CB_HRULER   ) ),
    aHMetric      ( this,   SW_RES( LB_HMETRIC    ) ),
	aVRulerCBox   ( this,	SW_RES( CB_VRULER    ) ),
    aVRulerRightCBox( this, SW_RES( CB_VRULER_RIGHT    ) ),
    aVMetric      ( this,   SW_RES( LB_VMETRIC    ) ),
    aSmoothCBox   ( this,   SW_RES( CB_SMOOTH_SCROLL    ) ),

    aDispFL      ( this,   SW_RES( FL_DISP     ) ),
	aGrfCB        ( this,	SW_RES( CB_GRF  		) ),
	aTblCB        ( this,	SW_RES( CB_TBL		) ),
	aDrwCB        ( this,	SW_RES( CB_DRWFAST   ) ),
	aFldNameCB    ( this,	SW_RES( CB_FIELD 	) ),
	aPostItCB     ( this,	SW_RES( CB_POSTIT 	) ),

    aSettingsFL   ( this,   SW_RES( FL_SETTINGS   ) ),
    aMetricFT     ( this,   SW_RES( FT_METRIC   ) ),
    aMetricLB     ( this,   SW_RES( LB_METRIC   ) )
{
	FreeResource();
	const SfxPoolItem* pItem;
	if(SFX_ITEM_SET == rCoreSet.GetItemState(SID_HTML_MODE, sal_False, &pItem )
		&& ((SfxUInt16Item*)pItem)->GetValue() & HTMLMODE_ON)
	{
        aMetricLB.Show();
        aSettingsFL.Show();
        aMetricFT.Show();
    }
    SvtCJKOptions aCJKOptions;
    if(aCJKOptions.IsVerticalTextEnabled() )
    {
        Point aSmoothPos(aSmoothCBox.GetPosPixel());
        aSmoothPos.Y() += aSmoothPos.Y() - aVRulerCBox.GetPosPixel().Y();
        aSmoothCBox.SetPosPixel(aSmoothPos);
    }
    else
        aVRulerRightCBox.Hide();
    aVRulerCBox.SetClickHdl(LINK(this, SwContentOptPage, VertRulerHdl ));
    aAnyRulerCB.SetClickHdl(LINK(this, SwContentOptPage, AnyRulerHdl));

    SvxStringArray aMetricArr( SW_RES( STR_ARR_METRIC ) );
    for ( sal_uInt16 i = 0; i < aMetricArr.Count(); ++i )
	{
		String sMetric = aMetricArr.GetStringByPos( i );
		FieldUnit eFUnit = (FieldUnit)aMetricArr.GetValue( i );

		switch ( eFUnit )
		{
			case FUNIT_MM:
			case FUNIT_CM:
			case FUNIT_POINT:
			case FUNIT_PICA:
			case FUNIT_INCH:
			{
				// nur diese Metriken benutzen
				sal_uInt16 nPos = aMetricLB.InsertEntry( sMetric );
				aMetricLB.SetEntryData( nPos, (void*)(long)eFUnit );
                aVMetric.InsertEntry( sMetric );
                aVMetric.SetEntryData( nPos, (void*)(long)eFUnit );
                aHMetric.InsertEntry( sMetric );
                aHMetric.SetEntryData( nPos, (void*)(long)eFUnit );
			}
            default:;//prevent warning
		}
	}
}

/*-----------------31.08.96 13.58-------------------

--------------------------------------------------*/
SwContentOptPage::~SwContentOptPage()
{
}

/*-----------------31.08.96 13.58-------------------

--------------------------------------------------*/
SfxTabPage*	SwContentOptPage::Create( Window* pParent,
								const SfxItemSet& rAttrSet)
{
	return new SwContentOptPage(pParent, rAttrSet);
}
/* -----------------------------07.04.01 16:57--------------------------------

 ---------------------------------------------------------------------------*/
static void lcl_SelectMetricLB(ListBox& rMetric, sal_uInt16 nSID, const SfxItemSet& rSet)
{
    const SfxPoolItem* pItem;
    if( rSet.GetItemState( nSID, sal_False, &pItem ) >= SFX_ITEM_AVAILABLE )
	{
        FieldUnit eFieldUnit = (FieldUnit)((SfxUInt16Item*)pItem)->GetValue();
        for ( sal_uInt16 i = 0; i < rMetric.GetEntryCount(); ++i )
		{
            if ( (int)(sal_IntPtr)rMetric.GetEntryData( i ) == (int)eFieldUnit )
			{
                rMetric.SelectEntryPos( i );
				break;
			}
		}
    }
    rMetric.SaveValue();
}
/*-----------------31.08.96 13.58-------------------

--------------------------------------------------*/
void SwContentOptPage::Reset(const SfxItemSet& rSet)
{
    const SwElemItem* pElemAttr = 0;

	rSet.GetItemState( FN_PARAM_ELEM , sal_False,
									(const SfxPoolItem**)&pElemAttr );
	if(pElemAttr)
    {
        aTblCB      .Check  (pElemAttr->bTable                );
        aGrfCB      .Check  (pElemAttr->bGraphic              );
        aDrwCB      .Check  (pElemAttr->bDrawing              );
        aFldNameCB  .Check  (pElemAttr->bFieldName            );
        aPostItCB   .Check  (pElemAttr->bNotes                );
        aCrossCB   .Check( pElemAttr->bCrosshair        );
        aSolidHandleCB.Check( !pElemAttr->bHandles          );
        aBigHandleCB.Check(pElemAttr->bBigHandles       );
        aHScrollBox.Check( pElemAttr->bHorzScrollbar     );
        aVScrollBox.Check( pElemAttr->bVertScrollbar     );
        aAnyRulerCB.Check( pElemAttr->bAnyRuler );
        aHRulerCBox.Check( pElemAttr->bHorzRuler         );
        aVRulerCBox.Check( pElemAttr->bVertRuler         );
        aVRulerRightCBox.Check(pElemAttr->bVertRulerRight);
        aSmoothCBox.Check( pElemAttr->bSmoothScroll      );
	}
    aMetricLB.SetNoSelection();
    lcl_SelectMetricLB(aMetricLB, SID_ATTR_METRIC, rSet);
    lcl_SelectMetricLB(aHMetric, FN_HSCROLL_METRIC, rSet);
    lcl_SelectMetricLB(aVMetric, FN_VSCROLL_METRIC, rSet);
    AnyRulerHdl(&aAnyRulerCB);
}

/*-----------------31.08.96 13.58-------------------

--------------------------------------------------*/
sal_Bool SwContentOptPage::FillItemSet(SfxItemSet& rSet)
{
    const SwElemItem*   pOldAttr = (const SwElemItem*)
						GetOldItem(GetItemSet(), FN_PARAM_ELEM);

	SwElemItem aElem;
	if(pOldAttr)
		aElem = *pOldAttr;
    aElem.bTable                = aTblCB        .IsChecked();
    aElem.bGraphic              = aGrfCB        .IsChecked();
    aElem.bDrawing              = aDrwCB        .IsChecked();
    aElem.bFieldName            = aFldNameCB    .IsChecked();
    aElem.bNotes                = aPostItCB     .IsChecked();
    aElem.bCrosshair     = aCrossCB   .IsChecked();
    aElem.bHandles       = !aSolidHandleCB.IsChecked();
    aElem.bBigHandles    = aBigHandleCB.IsChecked();
    aElem.bHorzScrollbar = aHScrollBox.IsChecked();
    aElem.bVertScrollbar = aVScrollBox.IsChecked();
    aElem.bAnyRuler = aAnyRulerCB.IsChecked();
    aElem.bHorzRuler     = aHRulerCBox.IsChecked();
    aElem.bVertRuler     = aVRulerCBox.IsChecked();
    aElem.bVertRulerRight= aVRulerRightCBox.IsChecked();
    aElem.bSmoothScroll  = aSmoothCBox.IsChecked();


    sal_Bool bRet = !pOldAttr || aElem != *pOldAttr;
	if(bRet)
        bRet = 0 != rSet.Put(aElem);
    sal_uInt16 nMPos = aMetricLB.GetSelectEntryPos();
    sal_uInt16 nGlobalMetricPos = nMPos;
	if ( nMPos != aMetricLB.GetSavedValue() )
	{
		// Doppel-Cast fuer VA3.0
		sal_uInt16 nFieldUnit = (sal_uInt16)(long)aMetricLB.GetEntryData( nMPos );
        rSet.Put( SfxUInt16Item( SID_ATTR_METRIC, (sal_uInt16)nFieldUnit ) );
        bRet = sal_True;
	}

    nMPos = aHMetric.GetSelectEntryPos();
    if ( nMPos != aHMetric.GetSavedValue() || nMPos != nGlobalMetricPos )
	{
		// Doppel-Cast fuer VA3.0
        sal_uInt16 nFieldUnit = (sal_uInt16)(long)aHMetric.GetEntryData( nMPos );
        rSet.Put( SfxUInt16Item( FN_HSCROLL_METRIC, (sal_uInt16)nFieldUnit ) );
        bRet = sal_True;
	}
    nMPos = aVMetric.GetSelectEntryPos();
    if ( nMPos != aVMetric.GetSavedValue() || nMPos != nGlobalMetricPos )
	{
		// Doppel-Cast fuer VA3.0
        sal_uInt16 nFieldUnit = (sal_uInt16)(long)aVMetric.GetEntryData( nMPos );
        rSet.Put( SfxUInt16Item( FN_VSCROLL_METRIC, (sal_uInt16)nFieldUnit ) );
        bRet = sal_True;
	}
    return bRet;
}
/* -----------------------------05.03.2002 15:07------------------------------

 ---------------------------------------------------------------------------*/
IMPL_LINK(SwContentOptPage, VertRulerHdl, CheckBox*, pBox)
{
    aVRulerRightCBox.Enable(pBox->IsEnabled() && pBox->IsChecked());
    return 0;
}
/* -----------------20.09.2002 11:30-----------------
 *
 * --------------------------------------------------*/
IMPL_LINK( SwContentOptPage, AnyRulerHdl, CheckBox*, pBox)
{
    sal_Bool bChecked = pBox->IsChecked();
    aHRulerCBox      .Enable(bChecked);
    aHMetric         .Enable(bChecked);
    aVRulerCBox      .Enable(bChecked);
    aVMetric         .Enable(bChecked);
    VertRulerHdl(&aVRulerCBox);
    return 0;
}
/*----------------- OS 27.01.95  -----------------------
 TabPage Drucker Zusatzeinstellungen
-------------------------------------------------------*/
SwAddPrinterTabPage::SwAddPrinterTabPage( Window* pParent,
									  const SfxItemSet& rCoreSet) :
	SfxTabPage( pParent, SW_RES( TP_OPTPRINT_PAGE ), rCoreSet),
    aFL1          (this, SW_RES(FL_1)),
	aGrfCB           (this, SW_RES(CB_PGRF)),
//	aTabCB           (this, SW_RES(CB_PTAB)),
//	aDrawCB          (this, SW_RES(CB_PDRAW)),
	aCtrlFldCB       (this, SW_RES(CB_CTRLFLD)),
	aBackgroundCB    (this, SW_RES(CB_BACKGROUND)),
	aBlackFontCB 	 (this, SW_RES(CB_BLACK_FONT)),
    aPrintHiddenTextCB(this, SW_RES(CB_HIDDEN_TEXT)),
    aPrintTextPlaceholderCB(this, SW_RES(CB_TEXT_PLACEHOLDER)),
    aSeparatorLFL    (this, SW_RES(FL_SEP_PRT_LEFT )),
    aFL2          (this, SW_RES(FL_2)),
    aLeftPageCB      (this, SW_RES(CB_LEFTP)),
    aRightPageCB     (this, SW_RES(CB_RIGHTP)),
//    aReverseCB       (this, SW_RES(CB_REVERSE)),
    aProspectCB      (this, SW_RES(CB_PROSPECT)),
    aProspectCB_RTL      (this, SW_RES(CB_PROSPECT_RTL)),
    aSeparatorRFL    (this, SW_RES(FL_SEP_PRT_RIGHT)),
	aFL3          (this, SW_RES(FL_3)),
    aNoRB            (this, SW_RES(RB_NO)),
	aOnlyRB          (this, SW_RES(RB_ONLY)),
	aEndRB           (this, SW_RES(RB_END)),
	aEndPageRB       (this, SW_RES(RB_PAGEEND)),
    aFL4          (this, SW_RES(FL_4)),
    aPrintEmptyPagesCB(this, SW_RES(CB_PRINTEMPTYPAGES)),
//    aSingleJobsCB    (this, SW_RES(CB_SINGLEJOBS)),
    aPaperFromSetupCB(this, SW_RES(CB_PAPERFROMSETUP)),
    aFaxFT           (this, SW_RES(FT_FAX)),
    aFaxLB           (this, SW_RES(LB_FAX)),
    sNone(SW_RES(ST_NONE)),
    bAttrModified( sal_False ),
    bPreview  ( sal_False )
{
	Init();
	FreeResource();
    Link aLk = LINK( this, SwAddPrinterTabPage, AutoClickHdl);
	aGrfCB.SetClickHdl( aLk );
	aRightPageCB.SetClickHdl( aLk );
	aLeftPageCB.SetClickHdl( aLk );
//	aTabCB.SetClickHdl( aLk );
//	aDrawCB.SetClickHdl( aLk );
	aCtrlFldCB.SetClickHdl( aLk );
	aBackgroundCB.SetClickHdl( aLk );
	aBlackFontCB.SetClickHdl( aLk );
    aPrintHiddenTextCB.SetClickHdl( aLk );
    aPrintTextPlaceholderCB.SetClickHdl( aLk );
//	aReverseCB.SetClickHdl( aLk );
	aProspectCB.SetClickHdl( aLk );
	aProspectCB_RTL.SetClickHdl( aLk );
	aPaperFromSetupCB.SetClickHdl( aLk );
    aPrintEmptyPagesCB.SetClickHdl( aLk );
	aEndPageRB.SetClickHdl( aLk );
	aEndRB.SetClickHdl( aLk );
	aOnlyRB.SetClickHdl( aLk );
	aNoRB.SetClickHdl( aLk );
//	aSingleJobsCB.SetClickHdl( aLk );
	aFaxLB.SetSelectHdl( LINK( this, SwAddPrinterTabPage, SelectHdl ) );

	const SfxPoolItem* pItem;
	if(SFX_ITEM_SET == rCoreSet.GetItemState(SID_HTML_MODE, sal_False, &pItem )
		&& ((SfxUInt16Item*)pItem)->GetValue() & HTMLMODE_ON)
	{
//		aDrawCB      .Hide();
		aLeftPageCB  .Hide();
		aRightPageCB .Hide();
        aPrintHiddenTextCB.Hide();
        aPrintTextPlaceholderCB.Hide();
//		aReverseCB.SetPosPixel(aLeftPageCB.GetPosPixel());
		aProspectCB.SetPosPixel(aLeftPageCB.GetPosPixel());
        Point aPt( aRightPageCB.GetPosPixel() );
        aPt.setX(aPt.getX() + 15); // indent
        aProspectCB_RTL.SetPosPixel(aPt);
//		aBlackFontCB.SetPosPixel(aBackgroundCB.GetPosPixel());
//        aPrintHiddenTextCB.SetPosPixel(aBlackFontCB.GetPosPixel());
//		aBackgroundCB.SetPosPixel(aCtrlFldCB.GetPosPixel());
//		aCtrlFldCB.SetPosPixel(aDrawCB.GetPosPixel());

        // hide aPrintEmptyPagesCB and move everything below up accordingly
        long nDeltaY = aPaperFromSetupCB.GetPosPixel().getY() - aPrintEmptyPagesCB.GetPosPixel().getY();
        aPrintEmptyPagesCB.Hide();
        aPt = aPaperFromSetupCB.GetPosPixel();
        aPt.setY( aPt.getY() - nDeltaY );
        aPaperFromSetupCB.SetPosPixel( aPt );
        aPt = aFaxFT.GetPosPixel();
        aPt.setY( aPt.getY() - nDeltaY );
        aFaxFT.SetPosPixel( aPt );
        aPt = aFaxLB.GetPosPixel();
        aPt.setY( aPt.getY() - nDeltaY );
        aFaxLB.SetPosPixel( aPt );
	}
	aProspectCB_RTL.Disable();
    SvtCTLOptions aCTLOptions;
    aProspectCB_RTL.Show(aCTLOptions.IsCTLFontEnabled());
}

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

void SwAddPrinterTabPage::SetPreview(sal_Bool bPrev)
{
	bPreview = bPrev;

	if (bPreview)
	{
		aLeftPageCB.Disable();
		aRightPageCB.Disable();
		aProspectCB.Disable();
		aProspectCB_RTL.Disable();
        aFL3.Disable();
		aNoRB.Disable();
		aOnlyRB.Disable();
		aEndRB.Disable();
		aEndPageRB.Disable();
	}
}

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

SfxTabPage*	SwAddPrinterTabPage::Create( Window* pParent,
									   const SfxItemSet& rAttrSet )
{
	return ( new SwAddPrinterTabPage( pParent, rAttrSet ) );
}
//------------------------------------------------------------------------


sal_Bool 	SwAddPrinterTabPage::FillItemSet( SfxItemSet& rCoreSet )
{
	if ( bAttrModified )
	{
		SwAddPrinterItem aAddPrinterAttr (FN_PARAM_ADDPRINTER);
		aAddPrinterAttr.bPrintGraphic 	= aGrfCB.IsChecked();
		aAddPrinterAttr.bPrintTable 	= sal_True; // always enabled since CWS printerpullgpages /*aTabCB.IsChecked();*/
        aAddPrinterAttr.bPrintDraw      = aGrfCB.IsChecked(); // UI merged with aGrfCB in CWS printerpullgpages /*aDrawCB.IsChecked()*/;
		aAddPrinterAttr.bPrintControl 	= aCtrlFldCB.IsChecked();
		aAddPrinterAttr.bPrintPageBackground = aBackgroundCB.IsChecked();
		aAddPrinterAttr.bPrintBlackFont = aBlackFontCB.IsChecked();
        aAddPrinterAttr.bPrintHiddenText = aPrintHiddenTextCB.IsChecked();
        aAddPrinterAttr.bPrintTextPlaceholder = aPrintTextPlaceholderCB.IsChecked();

        aAddPrinterAttr.bPrintLeftPages     = aLeftPageCB.IsChecked();
        aAddPrinterAttr.bPrintRightPages    = aRightPageCB.IsChecked();
        aAddPrinterAttr.bPrintReverse       = sal_False; // handled by vcl itself since CWS printerpullpages /*aReverseCB.IsChecked()*/;
        aAddPrinterAttr.bPrintProspect      = aProspectCB.IsChecked();
        aAddPrinterAttr.bPrintProspectRTL   = aProspectCB_RTL.IsChecked();
        aAddPrinterAttr.bPaperFromSetup     = aPaperFromSetupCB.IsChecked();
        aAddPrinterAttr.bPrintEmptyPages    = aPrintEmptyPagesCB.IsChecked();
        aAddPrinterAttr.bPrintSingleJobs    = sal_True; // handled by vcl in new print dialog since CWS printerpullpages /*aSingleJobsCB.IsChecked()*/;

		if (aNoRB.IsChecked()) 	aAddPrinterAttr.nPrintPostIts =
														POSTITS_NONE;
		if (aOnlyRB.IsChecked()) aAddPrinterAttr.nPrintPostIts =
														POSTITS_ONLY;
		if (aEndRB.IsChecked()) aAddPrinterAttr.nPrintPostIts =
														POSTITS_ENDDOC;
		if (aEndPageRB.IsChecked()) aAddPrinterAttr.nPrintPostIts =
														POSTITS_ENDPAGE;

        String sFax = aFaxLB.GetSelectEntry();
        aAddPrinterAttr.sFaxName = sNone == sFax ? aEmptyStr : sFax;
		rCoreSet.Put(aAddPrinterAttr);
	}
	return bAttrModified;
}
//------------------------------------------------------------------------


void 	SwAddPrinterTabPage::Reset( const SfxItemSet&  )
{
	const 	SfxItemSet&			rSet = GetItemSet();
	const 	SwAddPrinterItem*	pAddPrinterAttr = 0;

	if( SFX_ITEM_SET == rSet.GetItemState( FN_PARAM_ADDPRINTER , sal_False,
									(const SfxPoolItem**)&pAddPrinterAttr ))
	{
		aGrfCB.Check(			pAddPrinterAttr->bPrintGraphic || pAddPrinterAttr->bPrintDraw );
//		aTabCB.Check(			pAddPrinterAttr->bPrintTable);
//        aDrawCB.Check(          pAddPrinterAttr->bPrintDraw);
		aCtrlFldCB.Check(		pAddPrinterAttr->bPrintControl);
		aBackgroundCB.Check(    pAddPrinterAttr->bPrintPageBackground);
		aBlackFontCB.Check(		pAddPrinterAttr->bPrintBlackFont);
        aPrintHiddenTextCB.Check( pAddPrinterAttr->bPrintHiddenText);
        aPrintTextPlaceholderCB.Check(pAddPrinterAttr->bPrintTextPlaceholder);
        aLeftPageCB.Check(      pAddPrinterAttr->bPrintLeftPages);
        aRightPageCB.Check(     pAddPrinterAttr->bPrintRightPages);
//		aReverseCB.Check(		pAddPrinterAttr->bPrintReverse);
		aPaperFromSetupCB.Check(pAddPrinterAttr->bPaperFromSetup);
        aPrintEmptyPagesCB.Check(pAddPrinterAttr->bPrintEmptyPages);
		aProspectCB.Check(      pAddPrinterAttr->bPrintProspect);
        aProspectCB_RTL.Check(      pAddPrinterAttr->bPrintProspectRTL);
//		aSingleJobsCB.Check(    pAddPrinterAttr->bPrintSingleJobs);

		aNoRB.Check (pAddPrinterAttr->nPrintPostIts== POSTITS_NONE ) ;
		aOnlyRB.Check (pAddPrinterAttr->nPrintPostIts== POSTITS_ONLY ) ;
		aEndRB.Check (pAddPrinterAttr->nPrintPostIts== POSTITS_ENDDOC ) ;
		aEndPageRB.Check (pAddPrinterAttr->nPrintPostIts== POSTITS_ENDPAGE ) ;
        aFaxLB.SelectEntry( pAddPrinterAttr->sFaxName );
	}
	if (aProspectCB.IsChecked())
    {
		aProspectCB_RTL.Enable(sal_True);
        aNoRB.Enable( sal_False );
        aOnlyRB.Enable( sal_False );
        aEndRB.Enable( sal_False );
        aEndPageRB.Enable( sal_False );
    }
	else
		aProspectCB_RTL.Enable( sal_False );
}
//-----------------------------------------------------------------------


void 	SwAddPrinterTabPage::Init()
{

}
//------------------------------------------------------------------------


IMPL_LINK_INLINE_START( SwAddPrinterTabPage, AutoClickHdl, CheckBox *, EMPTYARG )
{
	bAttrModified = sal_True;
    bool bIsProspect = aProspectCB.IsChecked();
    if (!bIsProspect)
	    aProspectCB_RTL.Check( sal_False );
	aProspectCB_RTL.Enable( bIsProspect );
    aNoRB.Enable( !bIsProspect );
    aOnlyRB.Enable( !bIsProspect );
    aEndRB.Enable( !bIsProspect );
    aEndPageRB.Enable( !bIsProspect );
	return 0;
}
IMPL_LINK_INLINE_END( SwAddPrinterTabPage, AutoClickHdl, CheckBox *, EMPTYARG )

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


void  SwAddPrinterTabPage::SetFax( const SvStringsDtor& rFaxLst )
{
    aFaxLB.InsertEntry(sNone);
    for ( sal_uInt16 i = 0; i < rFaxLst.Count(); ++i )
		aFaxLB.InsertEntry( *rFaxLst.GetObject(i) );
    aFaxLB.SelectEntryPos(0);
}

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


IMPL_LINK_INLINE_START( SwAddPrinterTabPage, SelectHdl, ListBox *, EMPTYARG )
{
	bAttrModified=sal_True;
	return 0;
}
IMPL_LINK_INLINE_END( SwAddPrinterTabPage, SelectHdl, ListBox *, EMPTYARG )

void SwAddPrinterTabPage::PageCreated (SfxAllItemSet aSet)
{
	//SFX_ITEMSET_ARG (&aSet,pListItem,SfxStringListItem,SID_FAX_LIST,sal_False);
	SFX_ITEMSET_ARG (&aSet,pListItem,SfxBoolItem,SID_FAX_LIST,sal_False);
	SFX_ITEMSET_ARG (&aSet,pPreviewItem,SfxBoolItem,SID_PREVIEWFLAG_TYPE,sal_False);
	if (pPreviewItem)
	{
		SetPreview(pPreviewItem->GetValue());
		Reset(aSet);
	}
	if (pListItem && pListItem->GetValue())
	{
		SvStringsDtor aFaxList;
        const std::vector<rtl::OUString>& rPrinters = Printer::GetPrinterQueues();
		for (unsigned int i = 0; i < rPrinters.size(); ++i)
		{
			String* pString = new String( rPrinters[i] );
			String* &rpString = pString;
			aFaxList.Insert(rpString, 0);
		}
		SetFax( aFaxList );
/*		SvStringsDtor aFaxList;
		const List *pList = (pListItem)->GetList();
		sal_uInt32 nCount = pList->Count();
        for(sal_uInt32 i = 0; i < nCount ; i++)
		{
			String* pString = (String*)(pList->GetObject(i));
			String* &rpString = pString;
			aFaxList.Insert(rpString, 0 );
		}
		SetFax(aFaxList);
*/
	}
}
/*-----------------03.09.96 11.53-------------------
	Tabpage Standardfonts
--------------------------------------------------*/


SwStdFontTabPage::SwStdFontTabPage( Window* pParent,
									   const SfxItemSet& rSet ) :
	SfxTabPage( pParent, SW_RES( TP_STD_FONT ), rSet),
    aStdChrFL  (this, SW_RES(FL_STDCHR  )),
    aTypeFT(        this, SW_RES( FT_TYPE          )),

    aStandardLbl(this, SW_RES(FT_STANDARD)),
    aStandardBox(this, SW_RES(LB_STANDARD)),

    aHeightFT(        this, SW_RES( FT_SIZE          )),
    aStandardHeightLB(this, SW_RES( LB_STANDARD_SIZE )),

    aTitleLbl   (this, SW_RES(FT_TITLE   )),
    aTitleBox   (this, SW_RES(LB_TITLE   )),
    aTitleHeightLB(   this, SW_RES( LB_TITLE_SIZE    )),

    aListLbl    (this, SW_RES(FT_LIST    )),
    aListBox    (this, SW_RES(LB_LIST    )),
    aListHeightLB(    this, SW_RES( LB_LIST_SIZE     )),

    aLabelLbl   (this, SW_RES(FT_LABEL   )),
    aLabelBox   (this, SW_RES(LB_LABEL   )),
    aLabelHeightLB(   this, SW_RES( LB_LABEL_SIZE    )),

    aIdxLbl     (this, SW_RES(FT_IDX     )),
    aIdxBox     (this, SW_RES(LB_IDX     )),
    aIndexHeightLB(   this, SW_RES( LB_INDEX_SIZE    )),

    aDocOnlyCB  (this, SW_RES(CB_DOCONLY )),
	aStandardPB (this, SW_RES(PB_STANDARD)),
    pPrt(0),
    pFontList(0),
    pFontConfig(0),
    pWrtShell(0),
    eLanguage( GetAppLanguage() ),

    bListDefault(sal_False),
    bSetListDefault(sal_True),
    bLabelDefault(sal_False),
    bSetLabelDefault(sal_True),
    bIdxDefault(sal_False),
    bSetIdxDefault(sal_True),
    bDeletePrinter(sal_False),

    bListHeightDefault    (sal_False),
    bSetListHeightDefault (sal_False),
    bLabelHeightDefault   (sal_False),
    bSetLabelHeightDefault(sal_False),
    bIndexHeightDefault     (sal_False),
    bSetIndexHeightDefault  (sal_False),

    nFontGroup(FONT_GROUP_DEFAULT),

    sScriptWestern(SW_RES(ST_SCRIPT_WESTERN)),
    sScriptAsian(SW_RES(ST_SCRIPT_ASIAN)),
    sScriptComplex(SW_RES(ST_SCRIPT_CTL))
{
	FreeResource();
	aStandardPB.SetClickHdl(LINK(this, SwStdFontTabPage, StandardHdl));
	aStandardBox.SetModifyHdl( LINK(this, SwStdFontTabPage, ModifyHdl));
	aListBox    .SetModifyHdl( LINK(this, SwStdFontTabPage, ModifyHdl));
	aLabelBox	.SetModifyHdl( LINK(this, SwStdFontTabPage, ModifyHdl));
	aIdxBox		.SetModifyHdl( LINK(this, SwStdFontTabPage, ModifyHdl));
    Link aFocusLink = LINK( this, SwStdFontTabPage, LoseFocusHdl);
    aStandardBox.SetLoseFocusHdl( aFocusLink );
    aTitleBox   .SetLoseFocusHdl( aFocusLink );
    aListBox    .SetLoseFocusHdl( aFocusLink );
    aLabelBox   .SetLoseFocusHdl( aFocusLink );
    aIdxBox     .SetLoseFocusHdl( aFocusLink );

    Link aModifyHeightLink( LINK( this, SwStdFontTabPage, ModifyHeightHdl));
    aStandardHeightLB.SetModifyHdl( aModifyHeightLink );
    aTitleHeightLB.   SetModifyHdl( aModifyHeightLink );
    aListHeightLB.    SetModifyHdl( aModifyHeightLink );
    aLabelHeightLB.   SetModifyHdl( aModifyHeightLink );
    aIndexHeightLB.   SetModifyHdl( aModifyHeightLink );

	aDocOnlyCB.Check(SW_MOD()->GetModuleConfig()->IsDefaultFontInCurrDocOnly());
}

/*-----------------03.09.96 11.53-------------------

--------------------------------------------------*/

SwStdFontTabPage::~SwStdFontTabPage()
{
	if(bDeletePrinter)
		delete pPrt;
}

/*-----------------03.09.96 11.53-------------------

--------------------------------------------------*/
SfxTabPage*	SwStdFontTabPage::Create( Window* pParent,
								const SfxItemSet& rAttrSet )
{
	return new SwStdFontTabPage(pParent, rAttrSet);
}

/*-----------------03.09.96 11.53-------------------

--------------------------------------------------*/
void lcl_SetColl(SwWrtShell* pWrtShell, sal_uInt16 nType,
                    SfxPrinter* pPrt, const String& rStyle,
                    sal_uInt16 nFontWhich)
{
	Font aFont( rStyle, Size( 0, 10 ) );
	if( pPrt )
	    aFont = pPrt->GetFontMetric( aFont );
	SwTxtFmtColl *pColl = pWrtShell->GetTxtCollFromPool(nType);
    pColl->SetFmtAttr(SvxFontItem(aFont.GetFamily(), aFont.GetName(),
                aEmptyStr, aFont.GetPitch(), aFont.GetCharSet(), nFontWhich));
}
/*-- 11.10.2005 15:47:52---------------------------------------------------

  -----------------------------------------------------------------------*/
void lcl_SetColl(SwWrtShell* pWrtShell, sal_uInt16 nType,
                    sal_Int32 nHeight, sal_uInt16 nFontHeightWhich)
{
    float fSize = (float)nHeight / 10;
    nHeight = CalcToUnit( fSize, SFX_MAPUNIT_TWIP );
    SwTxtFmtColl *pColl = pWrtShell->GetTxtCollFromPool(nType);
    pColl->SetFmtAttr(SvxFontHeightItem(nHeight, 100, nFontHeightWhich));
}
/*-----------------03.09.96 11.53-------------------

--------------------------------------------------*/
sal_Bool SwStdFontTabPage::FillItemSet( SfxItemSet& )
{
	sal_Bool bNotDocOnly = !aDocOnlyCB.IsChecked();
	SW_MOD()->GetModuleConfig()->SetDefaultFontInCurrDocOnly(!bNotDocOnly);

	String sStandard 	= aStandardBox.GetText();
	String sTitle 		=  aTitleBox   .GetText();
	String sList 		=  aListBox    .GetText();
	String sLabel 		=  aLabelBox   .GetText();
	String sIdx 		=  aIdxBox     .GetText();
	String sStandardBak	= aStandardBox.GetSavedValue();
	String sTitleBak 	= aTitleBox   .GetSavedValue();
	String sListBak 	= aListBox    .GetSavedValue();
	String sLabelBak 	= aLabelBox   .GetSavedValue();
	String sIdxBak  	= aIdxBox     .GetSavedValue();

    bool bStandardHeightChanged = aStandardHeightLB.GetSavedValue() != aStandardHeightLB.GetText();
    bool bTitleHeightChanged = aTitleHeightLB.GetSavedValue() != aTitleHeightLB.GetText();
    bool bListHeightChanged = aListHeightLB.GetSavedValue() != aListHeightLB.GetText() && (!bListHeightDefault || !bSetListHeightDefault );
    bool bLabelHeightChanged = aLabelHeightLB.GetSavedValue() != aLabelHeightLB.GetText() && (!bLabelHeightDefault || !bSetLabelHeightDefault );
    bool bIndexHeightChanged = aIndexHeightLB.GetSavedValue() != aIndexHeightLB.GetText() && (!bIndexHeightDefault || !bSetIndexHeightDefault );
    if(bNotDocOnly)
	{
        pFontConfig->SetFontStandard(sStandard, nFontGroup);
        pFontConfig->SetFontOutline(sTitle, nFontGroup);
        pFontConfig->SetFontList(sList, nFontGroup);
        pFontConfig->SetFontCaption(sLabel, nFontGroup);
        pFontConfig->SetFontIndex(sIdx, nFontGroup);
        if(bStandardHeightChanged)
        {
            float fSize = (float)aStandardHeightLB.GetValue() / 10;
            pFontConfig->SetFontHeight( CalcToUnit( fSize, SFX_MAPUNIT_TWIP ), FONT_STANDARD, nFontGroup );
        }
        if(bTitleHeightChanged)
        {
            float fSize = (float)aTitleHeightLB.GetValue() / 10;
            pFontConfig->SetFontHeight( CalcToUnit( fSize, SFX_MAPUNIT_TWIP ), FONT_OUTLINE, nFontGroup );
        }
        if(bListHeightChanged)
        {
            float fSize = (float)aListHeightLB.GetValue() / 10;
            pFontConfig->SetFontHeight( CalcToUnit( fSize, SFX_MAPUNIT_TWIP ), FONT_LIST, nFontGroup );
        }
        if(bLabelHeightChanged)
        {
            float fSize = (float)aLabelHeightLB.GetValue() / 10;
            pFontConfig->SetFontHeight( CalcToUnit( fSize, SFX_MAPUNIT_TWIP ), FONT_CAPTION, nFontGroup );
        }
        if(bIndexHeightChanged)
        {
            float fSize = (float)aIndexHeightLB.GetValue() / 10;
            pFontConfig->SetFontHeight( CalcToUnit( fSize, SFX_MAPUNIT_TWIP ), FONT_INDEX, nFontGroup );
        }
    }
	if(pWrtShell)
	{
		pWrtShell->StartAllAction();
        SfxPrinter* pPrinter = pWrtShell->getIDocumentDeviceAccess()->getPrinter( false );
		sal_Bool bMod = sal_False;
        sal_uInt16 nFontWhich = sal::static_int_cast< sal_uInt16, RES_CHRATR >(
            nFontGroup == FONT_GROUP_DEFAULT  ? RES_CHRATR_FONT :
            FONT_GROUP_CJK == nFontGroup ? RES_CHRATR_CJK_FONT : RES_CHRATR_CTL_FONT);
        sal_uInt16 nFontHeightWhich = sal::static_int_cast< sal_uInt16, RES_CHRATR >(
            nFontGroup == FONT_GROUP_DEFAULT  ? RES_CHRATR_FONTSIZE :
            FONT_GROUP_CJK == nFontGroup ? RES_CHRATR_CJK_FONTSIZE : RES_CHRATR_CTL_FONTSIZE);
        if(sStandard != sShellStd)
		{
			Font aFont( sStandard, Size( 0, 10 ) );
			if( pPrinter )
			    aFont = pPrinter->GetFontMetric( aFont );
			pWrtShell->SetDefault(SvxFontItem(aFont.GetFamily(), aFont.GetName(),
                                  aEmptyStr, aFont.GetPitch(), aFont.GetCharSet(), nFontWhich));
			SwTxtFmtColl *pColl = pWrtShell->GetTxtCollFromPool(RES_POOLCOLL_STANDARD);
            pColl->ResetFmtAttr(nFontWhich);
//          lcl_SetColl(pWrtShell, RES_POOLCOLL_STANDARD, pPrinter, sStandard);
			bMod = sal_True;
		}
        if(bStandardHeightChanged)
        {
            float fSize = (float)aStandardHeightLB.GetValue() / 10;
            pWrtShell->SetDefault(SvxFontHeightItem( CalcToUnit( fSize, SFX_MAPUNIT_TWIP ), 100, nFontHeightWhich ) );
            SwTxtFmtColl *pColl = pWrtShell->GetTxtCollFromPool(RES_POOLCOLL_STANDARD);
            pColl->ResetFmtAttr(nFontHeightWhich);
            bMod = sal_True;
        }

		if(sTitle != sShellTitle )
		{
            lcl_SetColl(pWrtShell, RES_POOLCOLL_HEADLINE_BASE, pPrinter, sTitle, nFontWhich);
			bMod = sal_True;
		}
        if(bTitleHeightChanged)
        {
            lcl_SetColl(pWrtShell, RES_POOLCOLL_HEADLINE_BASE,
                sal::static_int_cast< sal_uInt16, sal_Int64 >(aTitleHeightLB.GetValue()), nFontHeightWhich);
            bMod = sal_True;
        }
        if(sList != sShellList && (!bListDefault || !bSetListDefault ))
		{
            lcl_SetColl(pWrtShell, RES_POOLCOLL_NUMBUL_BASE, pPrinter, sList, nFontWhich);
			bMod = sal_True;
		}
        if(bListHeightChanged)
        {
            lcl_SetColl(pWrtShell, RES_POOLCOLL_NUMBUL_BASE,
                sal::static_int_cast< sal_uInt16, sal_Int64 >(aListHeightLB.GetValue()), nFontHeightWhich);
            bMod = sal_True;
        }
        if(sLabel != sShellLabel && (!bLabelDefault || !bSetLabelDefault))
		{
            lcl_SetColl(pWrtShell, RES_POOLCOLL_LABEL, pPrinter, sLabel, nFontWhich);
			bMod = sal_True;
		}
        if(bLabelHeightChanged)
        {
            lcl_SetColl(pWrtShell, RES_POOLCOLL_LABEL,
                sal::static_int_cast< sal_uInt16, sal_Int64 >(aLabelHeightLB.GetValue()), nFontHeightWhich);
            bMod = sal_True;
        }
        if(sIdx != sShellIndex && (!bIdxDefault || !bSetIdxDefault))
		{
            lcl_SetColl(pWrtShell, RES_POOLCOLL_REGISTER_BASE, pPrinter, sIdx, nFontWhich);
			bMod = sal_True;
		}
        if(bIndexHeightChanged)
        {
            lcl_SetColl(pWrtShell, RES_POOLCOLL_REGISTER_BASE,
                sal::static_int_cast< sal_uInt16, sal_Int64 >(aIndexHeightLB.GetValue()), nFontHeightWhich);
            bMod = sal_True;
        }
        if ( bMod )
			pWrtShell->SetModified();
		pWrtShell->EndAllAction();
	}

	return sal_False;
}

/*-----------------03.09.96 11.53-------------------

--------------------------------------------------*/
void SwStdFontTabPage::Reset( const SfxItemSet& rSet)
{
    const SfxPoolItem* pLang;
    sal_uInt16 nLangSlot = nFontGroup == FONT_GROUP_DEFAULT  ? SID_ATTR_LANGUAGE :
        FONT_GROUP_CJK == nFontGroup ? SID_ATTR_CHAR_CJK_LANGUAGE : SID_ATTR_CHAR_CTL_LANGUAGE;


    if( SFX_ITEM_SET == rSet.GetItemState(nLangSlot, sal_False, &pLang))
        eLanguage = ((const SvxLanguageItem*)pLang)->GetValue();

    String sTmp(aStdChrFL.GetText());
    String sToReplace = sScriptWestern;
    if(FONT_GROUP_CJK == nFontGroup )
        sToReplace = sScriptAsian;
    else if(FONT_GROUP_CTL == nFontGroup )
        sToReplace = sScriptComplex;

    sTmp.SearchAndReplaceAscii("%1", sToReplace);
    aStdChrFL.SetText(sTmp);
    const SfxPoolItem* pItem;

	if(SFX_ITEM_SET == rSet.GetItemState(FN_PARAM_PRINTER, sal_False, &pItem))
	{
		pPrt = (SfxPrinter*)((const SwPtrItem*)pItem)->GetValue();
	}
	else
	{
        SfxItemSet* pPrinterSet = new SfxItemSet( *rSet.GetPool(),
					SID_PRINTER_NOTFOUND_WARN, SID_PRINTER_NOTFOUND_WARN,
					SID_PRINTER_CHANGESTODOC, SID_PRINTER_CHANGESTODOC,
					0 );
        pPrt = new SfxPrinter(pPrinterSet);
		bDeletePrinter = sal_True;
	}
    pFontList = new FontList( pPrt );
    // #i94536# prevent duplication of font entries when 'reset' button is pressed
    if( !aStandardBox.GetEntryCount() )
    {
        // get the set of disctinct available family names
        std::set< String > aFontNames;
        int nFontNames = pPrt->GetDevFontCount();
        for( int i = 0; i < nFontNames; i++ )
        {
            FontInfo aInf( pPrt->GetDevFont( i ) );
            aFontNames.insert( aInf.GetName() );
        }

        // insert to listboxes
        for( std::set< String >::const_iterator it = aFontNames.begin();
             it != aFontNames.end(); ++it )
        {
            aStandardBox.InsertEntry( *it );
            aTitleBox   .InsertEntry( *it );
            aListBox    .InsertEntry( *it );
            aLabelBox   .InsertEntry( *it );
            aIdxBox     .InsertEntry( *it );
        }
    }
	if(SFX_ITEM_SET == rSet.GetItemState(FN_PARAM_STDFONTS, sal_False, &pItem))
	{
		 pFontConfig = (SwStdFontConfig*)((const SwPtrItem*)pItem)->GetValue();
	}

	if(SFX_ITEM_SET == rSet.GetItemState(FN_PARAM_WRTSHELL, sal_False, &pItem))
	{
		pWrtShell = (SwWrtShell*)((const SwPtrItem*)pItem)->GetValue();
	}
	String sStdBackup;
	String sOutBackup;
	String sListBackup;
	String sCapBackup;
	String sIdxBackup;
    sal_Int32 nStandardHeight = -1;
    sal_Int32 nTitleHeight = -1;
    sal_Int32 nListHeight = -1;
    sal_Int32 nLabelHeight = -1;
    sal_Int32 nIndexHeight = -1;

	if(!pWrtShell)
	{
        sStdBackup = pFontConfig->GetFontStandard(nFontGroup);
        sOutBackup = pFontConfig->GetFontOutline(nFontGroup);
        sListBackup= pFontConfig->GetFontList(nFontGroup);
        sCapBackup = pFontConfig->GetFontCaption(nFontGroup);
        sIdxBackup = pFontConfig->GetFontIndex(nFontGroup);
        nStandardHeight = pFontConfig->GetFontHeight( FONT_STANDARD, nFontGroup, eLanguage );
        nTitleHeight =    pFontConfig->GetFontHeight( FONT_OUTLINE , nFontGroup, eLanguage );
        nListHeight =     pFontConfig->GetFontHeight( FONT_LIST    , nFontGroup, eLanguage );
        nLabelHeight =    pFontConfig->GetFontHeight( FONT_CAPTION , nFontGroup, eLanguage );
        nIndexHeight =    pFontConfig->GetFontHeight( FONT_INDEX   , nFontGroup, eLanguage );
        if( nStandardHeight <= 0)
            nStandardHeight = pFontConfig->GetDefaultHeightFor( FONT_STANDARD + nFontGroup * FONT_PER_GROUP, eLanguage);
        if( nTitleHeight <= 0)
            nTitleHeight = pFontConfig->GetDefaultHeightFor( FONT_OUTLINE + nFontGroup * FONT_PER_GROUP, eLanguage);
        if( nListHeight <= 0)
            nListHeight = pFontConfig->GetDefaultHeightFor( FONT_LIST + nFontGroup * FONT_PER_GROUP, eLanguage);
        if( nLabelHeight <= 0)
            nLabelHeight = pFontConfig->GetDefaultHeightFor( FONT_CAPTION + nFontGroup * FONT_PER_GROUP, eLanguage);
        if( nIndexHeight <= 0)
            nIndexHeight = pFontConfig->GetDefaultHeightFor( FONT_INDEX + nFontGroup * FONT_PER_GROUP, eLanguage);

	   aDocOnlyCB.Enable(sal_False);
	}
	else
	{
		SwTxtFmtColl *pColl = pWrtShell->GetTxtCollFromPool(RES_POOLCOLL_STANDARD);
        const SvxFontItem& rFont = !nFontGroup ? pColl->GetFont() :
                FONT_GROUP_CJK == nFontGroup ? pColl->GetCJKFont() : pColl->GetCTLFont();
        sShellStd = sStdBackup =  rFont.GetFamilyName();

        sal_uInt16 nFontHeightWhich = sal::static_int_cast< sal_uInt16, RES_CHRATR >(
            nFontGroup == FONT_GROUP_DEFAULT  ? RES_CHRATR_FONTSIZE :
            FONT_GROUP_CJK == nFontGroup ? RES_CHRATR_CJK_FONTSIZE : RES_CHRATR_CTL_FONTSIZE );
        const SvxFontHeightItem& rFontHeightStandard = (const SvxFontHeightItem& )pColl->GetFmtAttr(nFontHeightWhich);
        nStandardHeight = (sal_Int32)rFontHeightStandard.GetHeight();

		pColl = pWrtShell->GetTxtCollFromPool(RES_POOLCOLL_HEADLINE_BASE);
        const SvxFontItem& rFontHL = !nFontGroup ? pColl->GetFont() :
                FONT_GROUP_CJK == nFontGroup ? pColl->GetCJKFont() : pColl->GetCTLFont();
        sShellTitle = sOutBackup = rFontHL.GetFamilyName();

        const SvxFontHeightItem& rFontHeightTitle = (const SvxFontHeightItem&)pColl->GetFmtAttr( nFontHeightWhich, sal_True );
        nTitleHeight = (sal_Int32)rFontHeightTitle.GetHeight();

        sal_uInt16 nFontWhich = sal::static_int_cast< sal_uInt16, RES_CHRATR >(
            nFontGroup == FONT_GROUP_DEFAULT  ? RES_CHRATR_FONT :
            FONT_GROUP_CJK == nFontGroup ? RES_CHRATR_CJK_FONT : RES_CHRATR_CTL_FONT);
        pColl = pWrtShell->GetTxtCollFromPool(RES_POOLCOLL_NUMBUL_BASE);
        const SvxFontItem& rFontLS = !nFontGroup ? pColl->GetFont() :
                FONT_GROUP_CJK == nFontGroup ? pColl->GetCJKFont() : pColl->GetCTLFont();
        bListDefault = SFX_ITEM_DEFAULT == pColl->GetAttrSet().GetItemState(nFontWhich, sal_False);
        sShellList = sListBackup = rFontLS.GetFamilyName();

        const SvxFontHeightItem& rFontHeightList = (const SvxFontHeightItem&)pColl->GetFmtAttr(nFontHeightWhich, sal_True);
        nListHeight = (sal_Int32)rFontHeightList.GetHeight();
        bListHeightDefault = SFX_ITEM_DEFAULT == pColl->GetAttrSet().GetItemState(nFontWhich, sal_False);


        pColl = pWrtShell->GetTxtCollFromPool(RES_POOLCOLL_LABEL);
        bLabelDefault = SFX_ITEM_DEFAULT == pColl->GetAttrSet().GetItemState(nFontWhich, sal_False);
        const SvxFontItem& rFontCP = !nFontGroup ? pColl->GetFont() :
                FONT_GROUP_CJK == nFontGroup ? pColl->GetCJKFont() : pColl->GetCTLFont();
        sShellLabel = sCapBackup = rFontCP.GetFamilyName();
        const SvxFontHeightItem& rFontHeightLabel = (const SvxFontHeightItem&)pColl->GetFmtAttr(nFontHeightWhich, sal_True);
        nLabelHeight = (sal_Int32)rFontHeightLabel.GetHeight();
        bLabelHeightDefault = SFX_ITEM_DEFAULT == pColl->GetAttrSet().GetItemState(nFontWhich, sal_False);

		pColl = pWrtShell->GetTxtCollFromPool(RES_POOLCOLL_REGISTER_BASE);
        bIdxDefault = SFX_ITEM_DEFAULT == pColl->GetAttrSet().GetItemState(nFontWhich, sal_False);
        const SvxFontItem& rFontIDX = !nFontGroup ? pColl->GetFont() :
                FONT_GROUP_CJK == nFontGroup ? pColl->GetCJKFont() : pColl->GetCTLFont();
        sShellIndex = sIdxBackup = rFontIDX.GetFamilyName();
        const SvxFontHeightItem& rFontHeightIndex = (const SvxFontHeightItem&)pColl->GetFmtAttr(nFontHeightWhich, sal_True);
        nIndexHeight = (sal_Int32)rFontHeightIndex.GetHeight();
        bIndexHeightDefault = SFX_ITEM_DEFAULT == pColl->GetAttrSet().GetItemState(nFontWhich, sal_False);
    }
	aStandardBox.SetText(sStdBackup );
	aTitleBox   .SetText(sOutBackup );
	aListBox    .SetText(sListBackup);
	aLabelBox   .SetText(sCapBackup );
	aIdxBox     .SetText(sIdxBackup );

	FontInfo aFontInfo( pFontList->Get(sStdBackup, sStdBackup) );
    aStandardHeightLB.Fill( &aFontInfo, pFontList );
	aFontInfo = pFontList->Get(sOutBackup, sOutBackup );
    aTitleHeightLB.Fill( &aFontInfo, pFontList );
	aFontInfo = pFontList->Get(sListBackup,sListBackup);
	aListHeightLB.Fill( &aFontInfo, pFontList );
	aFontInfo = pFontList->Get(sCapBackup, sCapBackup );
    aLabelHeightLB.Fill( &aFontInfo, pFontList );
	aFontInfo = pFontList->Get(sIdxBackup, sIdxBackup );
    aIndexHeightLB.Fill( &aFontInfo, pFontList );

    aStandardHeightLB.SetValue( CalcToPoint( nStandardHeight, SFX_MAPUNIT_TWIP, 10 ) );
    aTitleHeightLB.   SetValue( CalcToPoint( nTitleHeight   , SFX_MAPUNIT_TWIP, 10 ) );
    aListHeightLB.    SetValue( CalcToPoint( nListHeight    , SFX_MAPUNIT_TWIP, 10 ) );
    aLabelHeightLB.   SetValue( CalcToPoint( nLabelHeight   , SFX_MAPUNIT_TWIP, 10 ));
    aIndexHeightLB.   SetValue( CalcToPoint( nIndexHeight   , SFX_MAPUNIT_TWIP, 10 ));

    aStandardBox.SaveValue();
	aTitleBox   .SaveValue();
	aListBox    .SaveValue();
	aLabelBox   .SaveValue();
	aIdxBox     .SaveValue();

    aStandardHeightLB.SaveValue();
    aTitleHeightLB.   SaveValue();
    aListHeightLB.    SaveValue();
    aLabelHeightLB.   SaveValue();
    aIndexHeightLB.   SaveValue();
}

/*-----------------07.09.96 12.28-------------------

--------------------------------------------------*/


IMPL_LINK( SwStdFontTabPage, StandardHdl, PushButton *, EMPTYARG )
{
    sal_uInt8 nFontOffset = nFontGroup * FONT_PER_GROUP;
    aStandardBox.SetText(SwStdFontConfig::GetDefaultFor(FONT_STANDARD + nFontOffset, eLanguage));
    aTitleBox   .SetText(SwStdFontConfig::GetDefaultFor(FONT_OUTLINE  + nFontOffset, eLanguage));
    aListBox    .SetText(SwStdFontConfig::GetDefaultFor(FONT_LIST     + nFontOffset, eLanguage));
    aLabelBox   .SetText(SwStdFontConfig::GetDefaultFor(FONT_CAPTION  + nFontOffset, eLanguage));
    aIdxBox     .SetText(SwStdFontConfig::GetDefaultFor(FONT_INDEX    + nFontOffset, eLanguage));

	aStandardBox.SaveValue();
	aTitleBox   .SaveValue();
	aListBox    .SaveValue();
	aLabelBox   .SaveValue();
	aIdxBox     .SaveValue();

    aStandardHeightLB.SetValue( CalcToPoint(
        SwStdFontConfig::GetDefaultHeightFor(FONT_STANDARD + nFontOffset, eLanguage),
            SFX_MAPUNIT_TWIP, 10 ) );
    aTitleHeightLB   .SetValue(CalcToPoint(
        SwStdFontConfig::GetDefaultHeightFor(FONT_OUTLINE  +
            nFontOffset, eLanguage), SFX_MAPUNIT_TWIP, 10 ));
    aListHeightLB    .SetValue(CalcToPoint(
        SwStdFontConfig::GetDefaultHeightFor(FONT_LIST + nFontOffset, eLanguage),
            SFX_MAPUNIT_TWIP, 10 ));
    aLabelHeightLB   .SetValue(CalcToPoint(
        SwStdFontConfig::GetDefaultHeightFor(FONT_CAPTION  + nFontOffset, eLanguage),
            SFX_MAPUNIT_TWIP, 10 ));
    aIndexHeightLB   .SetValue(CalcToPoint(
        SwStdFontConfig::GetDefaultHeightFor(FONT_INDEX    + nFontOffset, eLanguage),
            SFX_MAPUNIT_TWIP, 10 ));

    return 0;
}
/*-----------------17.01.97 15.43-------------------

--------------------------------------------------*/

IMPL_LINK( SwStdFontTabPage, ModifyHdl, ComboBox*, pBox )
{
    if(pBox == &aStandardBox)
	{
        String sEntry = pBox->GetText();
        if(bSetListDefault && bListDefault)
			aListBox.SetText(sEntry);
		if(bSetLabelDefault && bLabelDefault)
			aLabelBox.SetText(sEntry);
		if(bSetIdxDefault && bIdxDefault)
			aIdxBox.SetText(sEntry);
	}
	else if(pBox == &aListBox)
	{
		bSetListDefault = sal_False;
	}
	else if(pBox == &aLabelBox)
	{
		bSetLabelDefault = sal_False;
	}
	else if(pBox == &aIdxBox)
	{
		bSetIdxDefault = sal_False;
	}
	return 0;
}

/*-- 11.10.2005 15:11:23---------------------------------------------------

  -----------------------------------------------------------------------*/
IMPL_LINK( SwStdFontTabPage, ModifyHeightHdl, FontSizeBox*, pBox )
{
    if(pBox == &aStandardHeightLB)
    {
        sal_Int64 nValue = pBox->GetValue(FUNIT_TWIP);
        if(bSetListHeightDefault && bListHeightDefault)
            aListHeightLB.SetValue(nValue, FUNIT_TWIP);
        if(bSetLabelHeightDefault && bLabelHeightDefault)
            aLabelHeightLB.SetValue(nValue, FUNIT_TWIP);
        if(bSetIndexHeightDefault && bIndexHeightDefault)
            aIndexHeightLB.SetValue(nValue, FUNIT_TWIP);
    }
    else if(pBox == &aListHeightLB)
    {
        bSetListHeightDefault = sal_False;
    }
    else if(pBox == &aLabelHeightLB)
    {
        bSetLabelHeightDefault = sal_False;
    }
    else if(pBox == &aIndexHeightLB)
    {
        bSetIndexHeightDefault = sal_False;
    }
    return 0;
}

/*-- 28.09.2005 13:22:36---------------------------------------------------

  -----------------------------------------------------------------------*/
IMPL_LINK( SwStdFontTabPage, LoseFocusHdl, ComboBox*, pBox )
{
    FontSizeBox* pHeightLB = 0;
    String sEntry = pBox->GetText();
    if(pBox == &aStandardBox)
    {
        pHeightLB = &aStandardHeightLB;
    }
    else if(pBox == &aTitleBox)
    {
        pHeightLB = &aTitleHeightLB;
    }
    else if(pBox == &aListBox)
    {
        pHeightLB = &aListHeightLB;
    }
    else if(pBox == &aLabelBox)
    {
        pHeightLB = &aLabelHeightLB;
    }
    else /*if(pBox == &aIdxBox)*/
    {
        pHeightLB = &aIndexHeightLB;
    }
	FontInfo aFontInfo( pFontList->Get(sEntry, sEntry) );
    pHeightLB->Fill( &aFontInfo, pFontList );

    return 0;
}


void SwStdFontTabPage::PageCreated (SfxAllItemSet aSet)
{
    SFX_ITEMSET_ARG (&aSet,pFlagItem,SfxUInt16Item, SID_FONTMODE_TYPE, sal_False);
	if (pFlagItem)
        SetFontMode(sal::static_int_cast< sal_uInt8, sal_uInt16>( pFlagItem->GetValue()));
}
/*-----------------18.01.97 12.14-------------------
	Optionen Tabelle
--------------------------------------------------*/

SwTableOptionsTabPage::SwTableOptionsTabPage( Window* pParent, const SfxItemSet& rSet ) :
	SfxTabPage(pParent, SW_RES(TP_OPTTABLE_PAGE), rSet),
    aTableFL        (this, SW_RES(FL_TABLE           )),
    aHeaderCB       (this, SW_RES(CB_HEADER          )),
    aRepeatHeaderCB (this, SW_RES(CB_REPEAT_HEADER    )),
    aDontSplitCB    (this, SW_RES(CB_DONT_SPLIT       )),
    aBorderCB       (this, SW_RES(CB_BORDER           )),

    aSeparatorFL     (this, SW_RES(FL_TABLE_SEPARATOR)),

    aTableInsertFL  (this, SW_RES(FL_TABLE_INSERT    )),
    aNumFormattingCB(this, SW_RES(CB_NUMFORMATTING   )),
    aNumFmtFormattingCB(this, SW_RES(CB_NUMFMT_FORMATTING )),
    aNumAlignmentCB (this, SW_RES(CB_NUMALIGNMENT )),

    aMoveFL(        this, SW_RES(FL_MOVE     )),
    aMoveFT(        this, SW_RES(FT_MOVE     )),
    aRowMoveFT(     this, SW_RES(FT_ROWMOVE  )),
    aRowMoveMF(     this, SW_RES(MF_ROWMOVE   )),
    aColMoveFT(     this, SW_RES(FT_COLMOVE   )),
    aColMoveMF(     this, SW_RES(MF_COLMOVE   )),

    aInsertFT(      this, SW_RES(FT_INSERT   )),
    aRowInsertFT(   this, SW_RES(FT_ROWINSERT)),
    aRowInsertMF(   this, SW_RES(MF_ROWINSERT)),
    aColInsertFT(   this, SW_RES(FT_COLINSERT)),
    aColInsertMF(   this, SW_RES(MF_COLINSERT)),

    aHandlingFT(    this, SW_RES(FT_HANDLING )),
    aFixRB(         this, SW_RES(RB_FIX       )),
    aFixPropRB(     this, SW_RES(RB_FIXPROP  )),
    aVarRB(         this, SW_RES(RB_VAR      )),
    aFixFT(         this, SW_RES(FT_FIX      )),
    aFixPropFT(     this, SW_RES(FT_FIXPROP   )),
    aVarFT(         this, SW_RES(FT_VAR       )),
    pWrtShell(0),
    bHTMLMode(sal_False)
{
	FreeResource();

    Link aLnk(LINK(this, SwTableOptionsTabPage, CheckBoxHdl));
	aNumFormattingCB.SetClickHdl(aLnk);
	aNumFmtFormattingCB.SetClickHdl(aLnk);
	aHeaderCB.SetClickHdl(aLnk);
}

/*-----------------18.01.97 12.43-------------------

--------------------------------------------------*/

SwTableOptionsTabPage::~SwTableOptionsTabPage()
{
}

/*-----------------18.01.97 12.43-------------------

--------------------------------------------------*/

SfxTabPage*	SwTableOptionsTabPage::Create( Window* pParent,
								const SfxItemSet& rAttrSet )
{
	return new SwTableOptionsTabPage(pParent, rAttrSet );
}

/*-----------------18.01.97 12.42-------------------

--------------------------------------------------*/

sal_Bool SwTableOptionsTabPage::FillItemSet( SfxItemSet& )
{
	sal_Bool bRet = sal_False;
	SwModuleOptions* pModOpt = SW_MOD()->GetModuleConfig();

	if(aRowMoveMF.IsModified())
		pModOpt->SetTblHMove( (sal_uInt16)aRowMoveMF.Denormalize( aRowMoveMF.GetValue(FUNIT_TWIP)));

	if(aColMoveMF.IsModified())
		pModOpt->SetTblVMove( (sal_uInt16)aColMoveMF.Denormalize( aColMoveMF.GetValue(FUNIT_TWIP)));

	if(aRowInsertMF.IsModified())
		pModOpt->SetTblHInsert((sal_uInt16)aRowInsertMF.Denormalize( aRowInsertMF.GetValue(FUNIT_TWIP)));

	if(aColInsertMF.IsModified())
		pModOpt->SetTblVInsert((sal_uInt16)aColInsertMF.Denormalize( aColInsertMF.GetValue(FUNIT_TWIP)));

	TblChgMode eMode;
	if(aFixRB.IsChecked())
		eMode = TBLFIX_CHGABS;
	else if(aFixPropRB.IsChecked())
		eMode = TBLFIX_CHGPROP;
	else
		eMode = TBLVAR_CHGABS;
	if(eMode != pModOpt->GetTblMode())
	{
		pModOpt->SetTblMode(eMode);
		// der Tabellen-Tastatur-Modus hat sich geaendert, das soll
		// jetzt auch die aktuelle Tabelle erfahren
		if(pWrtShell && nsSelectionType::SEL_TBL & pWrtShell->GetSelectionType())
		{
			pWrtShell->SetTblChgMode(eMode);
			static sal_uInt16 __READONLY_DATA aInva[] =
								{   FN_TABLE_MODE_FIX,
									FN_TABLE_MODE_FIX_PROP,
									FN_TABLE_MODE_VARIABLE,
									0
								};
			pWrtShell->GetView().GetViewFrame()->GetBindings().Invalidate( aInva );
		}

		bRet = sal_True;
	}

    SwInsertTableOptions aInsOpts( 0, 0 );

	if (aHeaderCB.IsChecked())
        aInsOpts.mnInsMode |= tabopts::HEADLINE;

	if (aRepeatHeaderCB.IsEnabled() )
		aInsOpts.mnRowsToRepeat = aRepeatHeaderCB.IsChecked()? 1 : 0;

	if (!aDontSplitCB.IsChecked())
        aInsOpts.mnInsMode |= tabopts::SPLIT_LAYOUT;

	if (aBorderCB.IsChecked())
        aInsOpts.mnInsMode |= tabopts::DEFAULT_BORDER;

	if (aHeaderCB.GetSavedValue() != aHeaderCB.GetState() ||
		aRepeatHeaderCB.GetSavedValue() != aRepeatHeaderCB.GetState() ||
		aDontSplitCB.GetSavedValue() != aDontSplitCB.GetState() ||
		aBorderCB.GetSavedValue() != aBorderCB.GetState())
	{
		pModOpt->SetInsTblFlags(bHTMLMode, aInsOpts);
	}

	if (aNumFormattingCB.GetSavedValue() != aNumFormattingCB.GetState())
	{
		pModOpt->SetInsTblFormatNum(bHTMLMode, aNumFormattingCB.IsChecked());
		bRet = sal_True;
	}

	if (aNumFmtFormattingCB.GetSavedValue() != aNumFmtFormattingCB.GetState())
	{
		pModOpt->SetInsTblChangeNumFormat(bHTMLMode, aNumFmtFormattingCB.IsChecked());
		bRet = sal_True;
	}

    if (aNumAlignmentCB.GetSavedValue() != aNumAlignmentCB.GetState())
	{
		pModOpt->SetInsTblAlignNum(bHTMLMode, aNumAlignmentCB.IsChecked());
		bRet = sal_True;
	}

    return bRet;
}
/*-----------------18.01.97 12.42-------------------

--------------------------------------------------*/
void SwTableOptionsTabPage::Reset( const SfxItemSet& rSet)
{
	const SwModuleOptions* pModOpt = SW_MOD()->GetModuleConfig();
	if ( rSet.GetItemState( SID_ATTR_METRIC ) >= SFX_ITEM_AVAILABLE )
	{
		const SfxUInt16Item& rItem = (SfxUInt16Item&)rSet.Get( SID_ATTR_METRIC );
		FieldUnit eFieldUnit = (FieldUnit)rItem.GetValue();
		::SetFieldUnit( aRowMoveMF, eFieldUnit );
		::SetFieldUnit( aColMoveMF, eFieldUnit );
		::SetFieldUnit( aRowInsertMF, eFieldUnit );
		::SetFieldUnit( aColInsertMF, eFieldUnit );
	}

	aRowMoveMF  .SetValue(aRowMoveMF.Normalize(pModOpt->GetTblHMove()), FUNIT_TWIP);
	aColMoveMF  .SetValue(aColMoveMF.Normalize(pModOpt->GetTblVMove()), FUNIT_TWIP);
	aRowInsertMF.SetValue(aRowInsertMF.Normalize(pModOpt->GetTblHInsert()), FUNIT_TWIP);
	aColInsertMF.SetValue(aColInsertMF.Normalize(pModOpt->GetTblVInsert()), FUNIT_TWIP);

	switch(pModOpt->GetTblMode())
	{
		case TBLFIX_CHGABS: 	aFixRB.Check();		break;
		case TBLFIX_CHGPROP: 	aFixPropRB.Check();	break;
		case TBLVAR_CHGABS: 	aVarRB.Check();	break;
	}
    const SfxPoolItem* pItem;
	if(SFX_ITEM_SET == rSet.GetItemState(SID_HTML_MODE, sal_False, &pItem))
	{
		bHTMLMode = 0 != (((const SfxUInt16Item*)pItem)->GetValue() & HTMLMODE_ON);
	}

	//bestimmte Controls fuer HTML verstecken
	if(bHTMLMode)
	{
/*        Point aPos(aCaptionFL.GetPosPixel());
        long nYDiff = aTableFL.GetPosPixel().Y() - aPos.Y();
        aTableFL.SetPosPixel(aPos);

		aPos = aHeaderCB.GetPosPixel();
		aPos.Y() -= nYDiff;
		aHeaderCB.SetPosPixel(aPos);

		aPos = aRepeatHeaderCB.GetPosPixel();
		aPos.Y() -= nYDiff;
		aRepeatHeaderCB.SetPosPixel(aPos);

		aPos = aDontSplitCB.GetPosPixel(); // hier muss eine Luecke geschlossen werden
		aPos.Y() -= nYDiff;
		aBorderCB.SetPosPixel(aPos);

        aPos = aTableInsertFL.GetPosPixel();
		aPos.Y() -= nYDiff;
        aTableInsertFL.SetPosPixel(aPos);

		aPos = aNumFormattingCB.GetPosPixel();
		aPos.Y() -= nYDiff;
		aNumFormattingCB.SetPosPixel(aPos);

		aPos = aNumFmtFormattingCB.GetPosPixel();
		aPos.Y() -= nYDiff;
		aNumFmtFormattingCB.SetPosPixel(aPos);

		aPos = aNumAlignmentCB.GetPosPixel();
		aPos.Y() -= nYDiff;
		aNumAlignmentCB.SetPosPixel(aPos);

        aCaptionFL.Hide();
		aCaptionCB.Hide();
		aCaptionFT.Hide();
		aCaptionPB.Hide();
*/
		aDontSplitCB.Hide();
	}

	SwInsertTableOptions aInsOpts = pModOpt->GetInsTblFlags(bHTMLMode);
	sal_uInt16 nInsTblFlags = aInsOpts.mnInsMode;

    aHeaderCB.Check(0 != (nInsTblFlags & tabopts::HEADLINE));
    aRepeatHeaderCB.Check(aInsOpts.mnRowsToRepeat > 0);
    aDontSplitCB.Check(!(nInsTblFlags & tabopts::SPLIT_LAYOUT));
    aBorderCB.Check(0 != (nInsTblFlags & tabopts::DEFAULT_BORDER));

	aNumFormattingCB.Check(pModOpt->IsInsTblFormatNum(bHTMLMode));
	aNumFmtFormattingCB.Check(pModOpt->IsInsTblChangeNumFormat(bHTMLMode));
	aNumAlignmentCB.Check(pModOpt->IsInsTblAlignNum(bHTMLMode));

    aHeaderCB.SaveValue();
	aRepeatHeaderCB.SaveValue();
	aDontSplitCB.SaveValue();
	aBorderCB.SaveValue();
	aNumFormattingCB.SaveValue();
	aNumFmtFormattingCB.SaveValue();
	aNumAlignmentCB.SaveValue();

    CheckBoxHdl(0);
}
/*-----------------18.01.97 12.42-------------------

--------------------------------------------------*/
IMPL_LINK(SwTableOptionsTabPage, CheckBoxHdl, CheckBox*, EMPTYARG)
{
	aNumFmtFormattingCB.Enable(aNumFormattingCB.IsChecked());
	aNumAlignmentCB.Enable(aNumFormattingCB.IsChecked());
	aRepeatHeaderCB.Enable(aHeaderCB.IsChecked());
	return 0;
}

void SwTableOptionsTabPage::PageCreated (SfxAllItemSet aSet)
{
	SFX_ITEMSET_ARG (&aSet,pWrtSh,SwWrtShellItem,SID_WRT_SHELL,sal_False);
	if (pWrtSh)
		SetWrtShell(pWrtSh->GetValue());
}
/*  */

/*-----------------31.10.97 17:55-------------------
 TabPage fuer ShadowCrsr
--------------------------------------------------*/

SwShdwCrsrOptionsTabPage::SwShdwCrsrOptionsTabPage( Window* pParent,
													const SfxItemSet& rSet )
	: SfxTabPage(pParent, SW_RES(TP_OPTSHDWCRSR), rSet),
    aUnprintFL   ( this,   SW_RES( FL_NOPRINT  ) ),
    aParaCB       ( this,   SW_RES( CB_PARA      ) ),
    aSHyphCB      ( this,   SW_RES( CB_SHYPH        ) ),
    aSpacesCB     ( this,   SW_RES( CB_SPACE    ) ),
    aHSpacesCB    ( this,   SW_RES( CB_HSPACE   ) ),
    aTabCB        ( this,   SW_RES( CB_TAB      ) ),
    aBreakCB      ( this,   SW_RES( CB_BREAK        ) ),
    aCharHiddenCB     ( this,   SW_RES( CB_CHAR_HIDDEN   ) ),
    aFldHiddenCB     ( this,   SW_RES( CB_FLD_HIDDEN   ) ),
    aFldHiddenParaCB ( this,   SW_RES( CB_FLD_HIDDEN_PARA ) ),

    aSeparatorFL(   this, SW_RES( FL_SEPARATOR_SHDW)),

    aFlagFL( this, SW_RES( FL_SHDWCRSFLAG )),
    aOnOffCB( this, SW_RES( CB_SHDWCRSONOFF )),

    aFillModeFT( this, SW_RES( FT_SHDWCRSFILLMODE )),
    aFillMarginRB( this, SW_RES( RB_SHDWCRSFILLMARGIN )),
    aFillIndentRB( this, SW_RES( RB_SHDWCRSFILLINDENT )),
    aFillTabRB( this, SW_RES( RB_SHDWCRSFILLTAB )),
    aFillSpaceRB( this, SW_RES( RB_SHDWCRSFILLSPACE )),
    aCrsrOptFL   ( this, SW_RES( FL_CRSR_OPT)),
    aCrsrInProtCB( this, SW_RES( CB_ALLOW_IN_PROT )),
    m_aLayoutOptionsFL( this, SW_RES( FL_LAYOUT_OPTIONS ) ),
    m_aMathBaselineAlignmentCB( this, SW_RES( CB_MATH_BASELINE_ALIGNMENT ) ),
    m_pWrtShell( NULL )
{
	FreeResource();
    const SfxPoolItem* pItem = 0;

    SwShadowCursorItem aOpt;
	if( SFX_ITEM_SET == rSet.GetItemState( FN_PARAM_SHADOWCURSOR, sal_False, &pItem ))
		aOpt = *(SwShadowCursorItem*)pItem;
	aOnOffCB.Check( aOpt.IsOn() );

	sal_uInt8 eMode = aOpt.GetMode();
	aFillIndentRB.Check( FILL_INDENT == eMode );
	aFillMarginRB.Check( FILL_MARGIN == eMode );
	aFillTabRB.Check( FILL_TAB == eMode );
	aFillSpaceRB.Check( FILL_SPACE == eMode );

    if(SFX_ITEM_SET == rSet.GetItemState(SID_HTML_MODE, sal_False, &pItem )
		&& ((SfxUInt16Item*)pItem)->GetValue() & HTMLMODE_ON)
	{
		aTabCB		.Hide();
        aCharHiddenCB.Hide();
        aFldHiddenCB    .Hide();
        aFldHiddenParaCB.Hide();
        aBreakCB.SetPosPixel(aTabCB.GetPosPixel());
        aFlagFL         .Hide();
        aOnOffCB        .Hide();
        aFillModeFT     .Hide();
        aFillMarginRB   .Hide();
        aFillIndentRB   .Hide();
        aFillTabRB      .Hide();
        aFillSpaceRB    .Hide();
        aCrsrOptFL      .Hide();
        aCrsrInProtCB   .Hide();
        aSeparatorFL.Hide();
        long nWidth = aFlagFL.GetSizePixel().Width() + aFlagFL.GetPosPixel().X()
                                                        - aUnprintFL.GetPosPixel().X();
        Size aSize(aUnprintFL.GetSizePixel());
        aSize.Width() = nWidth;
        aUnprintFL.SetSizePixel(aSize);
    }
}

SwShdwCrsrOptionsTabPage::~SwShdwCrsrOptionsTabPage()
{
}


SfxTabPage*	SwShdwCrsrOptionsTabPage::Create( Window* pParent, const SfxItemSet& rSet )
{
	return new SwShdwCrsrOptionsTabPage( pParent, rSet );
}


void SwShdwCrsrOptionsTabPage::PageCreated( SfxAllItemSet aSet )
{
    SFX_ITEMSET_ARG (&aSet,pWrtSh,SwWrtShellItem,SID_WRT_SHELL,sal_False);
    if (pWrtSh)
        SetWrtShell(pWrtSh->GetValue());
}


sal_Bool SwShdwCrsrOptionsTabPage::FillItemSet( SfxItemSet& rSet )
{
    SwShadowCursorItem aOpt;
    aOpt.SetOn( aOnOffCB.IsChecked() );

    sal_uInt8 eMode;
    if( aFillIndentRB.IsChecked() )
        eMode= FILL_INDENT;
    else if( aFillMarginRB.IsChecked() )
        eMode = FILL_MARGIN;
    else if( aFillTabRB.IsChecked() )
        eMode = FILL_TAB;
    else
        eMode = FILL_SPACE;
    aOpt.SetMode( eMode );

    sal_Bool bRet = sal_False;
    const SfxPoolItem* pItem = 0;
    if( SFX_ITEM_SET != rSet.GetItemState( FN_PARAM_SHADOWCURSOR, sal_False, &pItem )
        ||  ((SwShadowCursorItem&)*pItem) != aOpt )
    {
        rSet.Put( aOpt );
        bRet = sal_True;
    }

    if ( m_pWrtShell )
    {
        m_pWrtShell->GetDoc()->set(
            IDocumentSettingAccess::MATH_BASELINE_ALIGNMENT,
            m_aMathBaselineAlignmentCB.IsChecked() );
        bRet |= m_aMathBaselineAlignmentCB.IsChecked() != m_aMathBaselineAlignmentCB.GetSavedValue();
    }

    if( aCrsrInProtCB.IsChecked() != aCrsrInProtCB.GetSavedValue())
    {
        rSet.Put(SfxBoolItem(FN_PARAM_CRSR_IN_PROTECTED, aCrsrInProtCB.IsChecked()));
        bRet |= sal_True;
    }

    const SwDocDisplayItem* pOldAttr =
        (const SwDocDisplayItem*)GetOldItem(GetItemSet(), FN_PARAM_DOCDISP);

    SwDocDisplayItem aDisp;
    if(pOldAttr)
        aDisp = *pOldAttr;
    //
    aDisp.bParagraphEnd         = aParaCB       .IsChecked();
    aDisp.bTab                  = aTabCB        .IsChecked();
    aDisp.bSpace                = aSpacesCB     .IsChecked();
    aDisp.bNonbreakingSpace     = aHSpacesCB    .IsChecked();
    aDisp.bSoftHyphen           = aSHyphCB      .IsChecked();
    aDisp.bFldHiddenText        = aFldHiddenCB     .IsChecked();
    aDisp.bCharHiddenText       = aCharHiddenCB.IsChecked();
    aDisp.bShowHiddenPara       = aFldHiddenParaCB .IsChecked();
    aDisp.bManualBreak          = aBreakCB      .IsChecked();

    bRet |= (!pOldAttr || aDisp != *pOldAttr);
    if(bRet)
        bRet = 0 != rSet.Put(aDisp);

    return bRet;
}

void SwShdwCrsrOptionsTabPage::Reset( const SfxItemSet& rSet )
{
    const SfxPoolItem* pItem = 0;

    SwShadowCursorItem aOpt;
    if( SFX_ITEM_SET == rSet.GetItemState( FN_PARAM_SHADOWCURSOR, sal_False, &pItem ))
    {
        aOpt = *(SwShadowCursorItem*)pItem;
    }
    aOnOffCB.Check( aOpt.IsOn() );

    sal_uInt8 eMode = aOpt.GetMode();
    aFillIndentRB.Check( FILL_INDENT == eMode );
    aFillMarginRB.Check( FILL_MARGIN == eMode );
    aFillTabRB.Check( FILL_TAB == eMode );
    aFillSpaceRB.Check( FILL_SPACE == eMode );

    if ( m_pWrtShell )
    {
        m_aMathBaselineAlignmentCB.Check( m_pWrtShell->GetDoc()->get( IDocumentSettingAccess::MATH_BASELINE_ALIGNMENT ) );
        m_aMathBaselineAlignmentCB.SaveValue();
    }
    else
    {
        m_aMathBaselineAlignmentCB.Disable();
    }

    if( SFX_ITEM_SET == rSet.GetItemState( FN_PARAM_CRSR_IN_PROTECTED, sal_False, &pItem ))
    {
        aCrsrInProtCB.Check(((const SfxBoolItem*)pItem)->GetValue());
    }
    aCrsrInProtCB.SaveValue();

    const SwDocDisplayItem* pDocDisplayAttr = 0;

    rSet.GetItemState( FN_PARAM_DOCDISP, sal_False, (const SfxPoolItem**)&pDocDisplayAttr );
    if(pDocDisplayAttr)
    {
        aParaCB     .Check  (pDocDisplayAttr->bParagraphEnd         );
        aTabCB      .Check  (pDocDisplayAttr->bTab                  );
        aSpacesCB   .Check  (pDocDisplayAttr->bSpace                );
        aHSpacesCB  .Check  (pDocDisplayAttr->bNonbreakingSpace     );
        aSHyphCB    .Check  (pDocDisplayAttr->bSoftHyphen           );
        aCharHiddenCB.Check (pDocDisplayAttr->bCharHiddenText );
        aFldHiddenCB   .Check  (pDocDisplayAttr->bFldHiddenText );
        aFldHiddenParaCB.Check (pDocDisplayAttr->bShowHiddenPara       );
        aBreakCB    .Check  (pDocDisplayAttr->bManualBreak          );
    }
}

/*-----------------31.10.97 17:55-------------------
 TabPage fuer Redlining
--------------------------------------------------*/

struct CharAttr
{
	sal_uInt16 nItemId;
	sal_uInt16 nAttr;
};

// Editieren entspricht Einfuegen-Attributen
static CharAttr __FAR_DATA aRedlineAttr[] =
{
	{ SID_ATTR_CHAR_CASEMAP,		SVX_CASEMAP_NOT_MAPPED },
	{ SID_ATTR_CHAR_WEIGHT,			WEIGHT_BOLD },
	{ SID_ATTR_CHAR_POSTURE,  		ITALIC_NORMAL },
	{ SID_ATTR_CHAR_UNDERLINE,    	UNDERLINE_SINGLE },
	{ SID_ATTR_CHAR_UNDERLINE,    	UNDERLINE_DOUBLE },
    { SID_ATTR_CHAR_STRIKEOUT,    	STRIKEOUT_SINGLE },
    { SID_ATTR_CHAR_CASEMAP,      	SVX_CASEMAP_VERSALIEN },
	{ SID_ATTR_CHAR_CASEMAP,      	SVX_CASEMAP_GEMEINE },
	{ SID_ATTR_CHAR_CASEMAP,      	SVX_CASEMAP_KAPITAELCHEN },
	{ SID_ATTR_CHAR_CASEMAP,      	SVX_CASEMAP_TITEL },
	{ SID_ATTR_BRUSH,				0 }
};
// Items from aRedlineAttr relevant for InsertAttr: strikethrough is
// not used
static sal_uInt16 aInsertAttrMap[] = { 0, 1, 2, 3, 4, 6, 7, 8, 9, 10 };

// Items from aRedlineAttr relevant for DeleteAttr: underline and
// double underline is not used
static sal_uInt16 aDeletedAttrMap[] = { 0, 1, 2, 5, 6, 7, 8, 9, 10 };

// Items from aRedlineAttr relevant for ChangeAttr: strikethrough is
// not used
static sal_uInt16 aChangedAttrMap[] = { 0, 1, 2, 3, 4, 6, 7, 8, 9, 10 };

/*-----------------------------------------------------------------------
	Beschreibung: Markierungsvorschau
 -----------------------------------------------------------------------*/

SwMarkPreview::SwMarkPreview( Window *pParent, const ResId& rResID ) :

	Window(pParent, rResID),
	m_aTransCol( COL_TRANSPARENT ),
	m_aMarkCol( COL_LIGHTRED ),
	nMarkPos(0)

{
	InitColors();
	SetMapMode(MAP_PIXEL);

	const Size aSz(GetOutputSizePixel());

	// Seite
	aPage.SetSize(Size(aSz.Width() - 3, aSz.Height() - 3));

	sal_uLong nOutWPix = aPage.GetWidth();
	sal_uLong nOutHPix = aPage.GetHeight();

	// PrintArea
	sal_uLong nLBorder = 8;
	sal_uLong nRBorder = 8;
	sal_uLong nTBorder = 4;
	sal_uLong nBBorder = 4;

	aLeftPagePrtArea = Rectangle(Point(nLBorder, nTBorder), Point((nOutWPix - 1) - nRBorder, (nOutHPix - 1) - nBBorder));
	sal_uInt16 nWidth = (sal_uInt16)aLeftPagePrtArea.GetWidth();
	sal_uInt16 nKorr = (nWidth & 1) != 0 ? 0 : 1;
	aLeftPagePrtArea.SetSize(Size(nWidth / 2 - (nLBorder + nRBorder) / 2 + nKorr, aLeftPagePrtArea.GetHeight()));

	aRightPagePrtArea = aLeftPagePrtArea;
	aRightPagePrtArea.Move(aLeftPagePrtArea.GetWidth() + nLBorder + nRBorder + 1, 0);
}

SwMarkPreview::~SwMarkPreview()
{
}

void SwMarkPreview::InitColors( void )
{
	// m_aTransCol and m_aMarkCol are _not_ changed because they are set from outside!

	const StyleSettings& rSettings = GetSettings().GetStyleSettings();
	m_aBgCol = Color( rSettings.GetWindowColor() );

	sal_Bool bHC = rSettings.GetHighContrastMode();
    m_aLineCol = bHC? SwViewOption::GetFontColor() : Color( COL_BLACK );
	m_aShadowCol = bHC? m_aBgCol : rSettings.GetShadowColor();
    m_aTxtCol = bHC? SwViewOption::GetFontColor() : Color( COL_GRAY );
	m_aPrintAreaCol = m_aTxtCol;
}

void SwMarkPreview::DataChanged( const DataChangedEvent& rDCEvt )
{
	Window::DataChanged( rDCEvt );

	if( rDCEvt.GetType() == DATACHANGED_SETTINGS && ( rDCEvt.GetFlags() & SETTINGS_STYLE ) )
		InitColors();
}

void SwMarkPreview::Paint(const Rectangle &/*rRect*/)
{
	// Schatten zeichnen
	Rectangle aShadow(aPage);
	aShadow += Point(3, 3);
	DrawRect( aShadow, m_aShadowCol, m_aTransCol );

	// Seite zeichnen
	DrawRect( aPage, m_aBgCol, m_aLineCol );

	// Separator zeichnen
	Rectangle aPageSeparator(aPage);
	aPageSeparator.SetSize(Size(2, aPageSeparator.GetHeight()));
	aPageSeparator.Move(aPage.GetWidth() / 2 - 1, 0);
	DrawRect( aPageSeparator, m_aLineCol, m_aTransCol );

	PaintPage(aLeftPagePrtArea);
	PaintPage(aRightPagePrtArea);

	Rectangle aLeftMark(Point(aPage.Left() + 2, aLeftPagePrtArea.Top() + 4), Size(aLeftPagePrtArea.Left() - 4, 2));
	Rectangle aRightMark(Point(aRightPagePrtArea.Right() + 2, aRightPagePrtArea.Bottom() - 6), Size(aLeftPagePrtArea.Left() - 4, 2));

	switch (nMarkPos)
	{
		case 1:		// Links
			aRightMark.SetPos(Point(aRightPagePrtArea.Left() - 2 - aRightMark.GetWidth(), aRightMark.Top()));
			break;

		case 2:		// Rechts
			aLeftMark.SetPos(Point(aLeftPagePrtArea.Right() + 2, aLeftMark.Top()));
			break;

		case 3:		// Aussen
			break;

		case 4:		// Innen
			aLeftMark.SetPos(Point(aLeftPagePrtArea.Right() + 2, aLeftMark.Top()));
			aRightMark.SetPos(Point(aRightPagePrtArea.Left() - 2 - aRightMark.GetWidth(), aRightMark.Top()));
			break;

		case 0:		// Keine
		default:
			return;
	}
	DrawRect( aLeftMark, m_aMarkCol, m_aTransCol );
	DrawRect( aRightMark, m_aMarkCol, m_aTransCol );
}

void SwMarkPreview::PaintPage(const Rectangle &rRect)
{
	// PrintArea zeichnen
	DrawRect(rRect, m_aTransCol, m_aPrintAreaCol );

	// Testabsatz zeichnen
	sal_uLong nLTxtBorder = 4;
	sal_uLong nRTxtBorder = 4;
	sal_uLong nTTxtBorder = 4;

	Rectangle aTextLine = rRect;
	aTextLine.SetSize(Size(aTextLine.GetWidth(), 2));
	aTextLine.Left()	+= nLTxtBorder;
	aTextLine.Right()	-= nRTxtBorder;
	aTextLine.Move(0, nTTxtBorder);

    sal_Int32 nStep;
    sal_uInt16 nLines;

	nStep = aTextLine.GetHeight() + 2;
	nLines = (sal_uInt16)(rRect.GetHeight() / (aTextLine.GetHeight() + 2)) - 1;

	// Text simulieren
	//
	for (sal_uInt16 i = 0; i < nLines; ++i)
	{
		if (i == (nLines - 1))
			aTextLine.SetSize(Size(aTextLine.GetWidth() / 2, aTextLine.GetHeight()));

		if (aPage.IsInside(aTextLine))
			DrawRect(aTextLine, m_aTxtCol, m_aTransCol );

		aTextLine.Move(0, nStep);
	}
	aTextLine.Move(0, -nStep);
}

void SwMarkPreview::DrawRect(const Rectangle &rRect, const Color &rFillColor, const Color &rLineColor)
{
	SetFillColor(rFillColor);
	SetLineColor(rLineColor);
	Window::DrawRect(rRect);
}

namespace
{
    void lcl_FillRedlineAttrListBox(
            ListBox& rLB, const AuthorCharAttr& rAttrToSelect,
            const sal_uInt16* pAttrMap, const sal_uInt16 nAttrMapSize)
    {
        for (sal_uInt16 i = 0; i != nAttrMapSize; ++i)
        {
            CharAttr& rAttr(aRedlineAttr[pAttrMap[i]]);
            rLB.SetEntryData(i, &rAttr);
            if (rAttr.nItemId == rAttrToSelect.nItemId &&
                rAttr.nAttr == rAttrToSelect.nAttr)
                rLB.SelectEntryPos(i);
        }
    }
}

SwRedlineOptionsTabPage::SwRedlineOptionsTabPage( Window* pParent,
													const SfxItemSet& rSet )
	: SfxTabPage(pParent, SW_RES(TP_REDLINE_OPT), rSet),

    aInsertFL(          this, SW_RES( FL_TE )),

    aInsertFT(          this, SW_RES( FT_CHG_INSERT     )),
    aInsertAttrFT(          this, SW_RES( FT_INS_ATTR     )),
    aInsertLB(          this, SW_RES( LB_INS_ATTR     )),
    aInsertColorFT(     this, SW_RES( FT_INS_COL      )),
    aInsertColorLB(     this, SW_RES( LB_INS_COL      )),
    aInsertedPreviewWN( this, SW_RES( WIN_INS         )),

    aDeletedFT(         this, SW_RES( FT_CHG_DELETE     )),
    aDeletedAttrFT(         this, SW_RES( FT_DEL_ATTR     )),
    aDeletedLB(         this, SW_RES( LB_DEL_ATTR     )),
    aDeletedColorFT(    this, SW_RES( FT_DEL_COL      )),
    aDeletedColorLB(    this, SW_RES( LB_DEL_COL      )),
    aDeletedPreviewWN(  this, SW_RES( WIN_DEL         )),

    aChangedFT(         this, SW_RES( FT_CHG_CHANGE     )),
    aChangedAttrFT(         this, SW_RES( FT_CHG_ATTR     )),
    aChangedLB(         this, SW_RES( LB_CHG_ATTR     )),
    aChangedColorFT(    this, SW_RES( FT_CHG_COL      )),
    aChangedColorLB(    this, SW_RES( LB_CHG_COL      )),
    aChangedPreviewWN(  this, SW_RES( WIN_CHG         )),

    aChangedFL          ( this, SW_RES( FL_LC )),

	aMarkPosFT			( this, SW_RES( FT_MARKPOS )),
	aMarkPosLB			( this, SW_RES( LB_MARKPOS )),
	aMarkColorFT		( this, SW_RES( FT_LC_COL )),
	aMarkColorLB		( this, SW_RES( LB_LC_COL )),
	aMarkPreviewWN		( this, SW_RES( WIN_MARK )),

    sAuthor             ( SW_RES( STR_AUTHOR )),
	sNone				( SW_RES( STR_NOTHING ))

{
	FreeResource();

    for(sal_uInt16 i = 0; i < aInsertLB.GetEntryCount(); i++)
    {
        String sEntry(aInsertLB.GetEntry(i));
        aDeletedLB.InsertEntry(sEntry);
        aChangedLB.InsertEntry(sEntry);
    };

    // remove strikethrough from insert and change and underline + double
    // underline from delete
    aInsertLB.RemoveEntry(5);
    aChangedLB.RemoveEntry(5);
    aDeletedLB.RemoveEntry(4);
    aDeletedLB.RemoveEntry(3);

    Link aLk = LINK(this, SwRedlineOptionsTabPage, AttribHdl);
	aInsertLB.SetSelectHdl( aLk );
	aDeletedLB.SetSelectHdl( aLk );
	aChangedLB.SetSelectHdl( aLk );

	aLk = LINK(this, SwRedlineOptionsTabPage, ColorHdl);
	aInsertColorLB.SetSelectHdl( aLk );
	aDeletedColorLB.SetSelectHdl( aLk );
	aChangedColorLB.SetSelectHdl( aLk );

	aLk = LINK(this, SwRedlineOptionsTabPage, ChangedMaskPrevHdl);
	aMarkPosLB.SetSelectHdl( aLk );
	aMarkColorLB.SetSelectHdl( aLk );
	//solution: set different accessible name of four color box
	aInsertColorLB.SetAccessibleName(::rtl::OUString( aInsertFT.GetDisplayText()) + ::rtl::OUString(aInsertColorFT.GetDisplayText()));
	aDeletedColorLB.SetAccessibleName(::rtl::OUString( aDeletedFT.GetDisplayText()) + ::rtl::OUString( aDeletedColorFT.GetDisplayText()));
	aChangedColorLB.SetAccessibleName(::rtl::OUString( aChangedFT.GetDisplayText()) + ::rtl::OUString( aChangedColorFT.GetDisplayText()));
	aMarkColorLB.SetAccessibleName(::rtl::OUString( aMarkPosFT.GetDisplayText()) + ::rtl::OUString( aMarkColorFT.GetDisplayText()));
}

SwRedlineOptionsTabPage::~SwRedlineOptionsTabPage()
{
}

SfxTabPage* SwRedlineOptionsTabPage::Create( Window* pParent, const SfxItemSet& rSet)
{
	return new SwRedlineOptionsTabPage( pParent, rSet );
}

sal_Bool SwRedlineOptionsTabPage::FillItemSet( SfxItemSet& )
{
	CharAttr *pAttr;
	SwModuleOptions *pOpt = SW_MOD()->GetModuleConfig();

    AuthorCharAttr aInsertedAttr;
	AuthorCharAttr aDeletedAttr;
	AuthorCharAttr aChangedAttr;

	AuthorCharAttr aOldInsertAttr(pOpt->GetInsertAuthorAttr());
	AuthorCharAttr aOldDeletedAttr(pOpt->GetDeletedAuthorAttr());
	AuthorCharAttr aOldChangedAttr(pOpt->GetFormatAuthorAttr());

	ColorData nOldMarkColor = pOpt->GetMarkAlignColor().GetColor();
	sal_uInt16 nOldMarkMode = pOpt->GetMarkAlignMode();

	sal_uInt16 nPos = aInsertLB.GetSelectEntryPos();
	if (nPos != LISTBOX_ENTRY_NOTFOUND)
	{
		pAttr = (CharAttr *)aInsertLB.GetEntryData(nPos);
        aInsertedAttr.nItemId = pAttr->nItemId;
        aInsertedAttr.nAttr = pAttr->nAttr;

		nPos = aInsertColorLB.GetSelectEntryPos();

		switch (nPos)
		{
			case 0:
                aInsertedAttr.nColor = COL_NONE;
				break;
			case 1:
			case LISTBOX_ENTRY_NOTFOUND:
                aInsertedAttr.nColor = COL_TRANSPARENT;
				break;
			default:
                aInsertedAttr.nColor = aInsertColorLB.GetEntryColor(nPos).GetColor();
				break;
		}

        pOpt->SetInsertAuthorAttr(aInsertedAttr);
	}

	nPos = aDeletedLB.GetSelectEntryPos();
	if (nPos != LISTBOX_ENTRY_NOTFOUND)
	{
		pAttr = (CharAttr *)aDeletedLB.GetEntryData(nPos);
		aDeletedAttr.nItemId = pAttr->nItemId;
		aDeletedAttr.nAttr = pAttr->nAttr;

		nPos = aDeletedColorLB.GetSelectEntryPos();

		switch (nPos)
		{
			case 0:
				aDeletedAttr.nColor = COL_NONE;
				break;
			case 1:
			case LISTBOX_ENTRY_NOTFOUND:
				aDeletedAttr.nColor = COL_TRANSPARENT;
				break;
			default:
				aDeletedAttr.nColor = aDeletedColorLB.GetEntryColor(nPos).GetColor();
				break;
		}

		pOpt->SetDeletedAuthorAttr(aDeletedAttr);
	}

	nPos = aChangedLB.GetSelectEntryPos();
	if (nPos != LISTBOX_ENTRY_NOTFOUND)
	{
		pAttr = (CharAttr *)aChangedLB.GetEntryData(nPos);
		aChangedAttr.nItemId = pAttr->nItemId;
		aChangedAttr.nAttr = pAttr->nAttr;

		nPos = aChangedColorLB.GetSelectEntryPos();

		switch (nPos)
		{
			case 0:
				aChangedAttr.nColor = COL_NONE;
				break;
			case 1:
			case LISTBOX_ENTRY_NOTFOUND:
				aChangedAttr.nColor = COL_TRANSPARENT;
				break;
			default:
				aChangedAttr.nColor = aChangedColorLB.GetEntryColor(nPos).GetColor();
				break;
		}

		pOpt->SetFormatAuthorAttr(aChangedAttr);
	}

	nPos = 0;
	switch (aMarkPosLB.GetSelectEntryPos())
	{
        case 0: nPos = text::HoriOrientation::NONE;       break;
        case 1: nPos = text::HoriOrientation::LEFT;       break;
        case 2: nPos = text::HoriOrientation::RIGHT;      break;
        case 3: nPos = text::HoriOrientation::OUTSIDE;    break;
        case 4: nPos = text::HoriOrientation::INSIDE;     break;
	}
	pOpt->SetMarkAlignMode(nPos);

	pOpt->SetMarkAlignColor(aMarkColorLB.GetSelectEntryColor());

    if (!(aInsertedAttr == aOldInsertAttr) ||
		!(aDeletedAttr == aOldDeletedAttr) ||
		!(aChangedAttr == aOldChangedAttr) ||
	   nOldMarkColor != pOpt->GetMarkAlignColor().GetColor() ||
	   nOldMarkMode != pOpt->GetMarkAlignMode())
	{
		// Alle Dokumente aktualisieren
		TypeId aType(TYPE(SwDocShell));
		SwDocShell* pDocShell = (SwDocShell*)SfxObjectShell::GetFirst(&aType);

		while( pDocShell )
		{
			pDocShell->GetWrtShell()->UpdateRedlineAttr();
			pDocShell = (SwDocShell*)SfxObjectShell::GetNext(*pDocShell, &aType);
		}
	}

	return sal_False;
}

void SwRedlineOptionsTabPage::Reset( const SfxItemSet&  )
{
	const SwModuleOptions *pOpt = SW_MOD()->GetModuleConfig();

	const AuthorCharAttr &rInsertAttr = pOpt->GetInsertAuthorAttr();
	const AuthorCharAttr &rDeletedAttr = pOpt->GetDeletedAuthorAttr();
	const AuthorCharAttr &rChangedAttr = pOpt->GetFormatAuthorAttr();

	// Preview initialisieren
    InitFontStyle(aInsertedPreviewWN);
    InitFontStyle(aDeletedPreviewWN);
    InitFontStyle(aChangedPreviewWN);

	// Farblistboxen initialisieren
	String sColor;
	aInsertColorLB.SetUpdateMode(sal_False);
	aDeletedColorLB.SetUpdateMode(sal_False);
	aChangedColorLB.SetUpdateMode(sal_False);
	aMarkColorLB.SetUpdateMode(sal_False);

	aInsertColorLB.InsertEntry(sNone);
	aDeletedColorLB.InsertEntry(sNone);
	aChangedColorLB.InsertEntry(sNone);

	aInsertColorLB.InsertEntry(sAuthor);
	aDeletedColorLB.InsertEntry(sAuthor);
	aChangedColorLB.InsertEntry(sAuthor);

	XColorListSharedPtr aColorTbl = XColorList::GetStdColorList();
	sal_uInt16 i;
	for( i = 0; i < aColorTbl->Count(); ++i )
	{
		XColorEntry* pEntry = aColorTbl->GetColor( i );
		Color aColor = pEntry->GetColor();
		String sName = pEntry->GetName();

		aInsertColorLB.InsertEntry( aColor, sName );
		aDeletedColorLB.InsertEntry( aColor, sName );
		aChangedColorLB.InsertEntry( aColor, sName );
		aMarkColorLB.InsertEntry( aColor, sName );
	}
	aInsertColorLB.SetUpdateMode( sal_True );
	aDeletedColorLB.SetUpdateMode( sal_True );
	aChangedColorLB.SetUpdateMode( sal_True );
	aMarkColorLB.SetUpdateMode( sal_True );

	ColorData nColor = rInsertAttr.nColor;

	switch (nColor)
	{
		case COL_TRANSPARENT:
			aInsertColorLB.SelectEntryPos(1);
			break;
		case COL_NONE:
			aInsertColorLB.SelectEntryPos(0);
			break;
		default:
			aInsertColorLB.SelectEntry(Color(nColor));
	}

	nColor = rDeletedAttr.nColor;

	switch (nColor)
	{
		case COL_TRANSPARENT:
			aDeletedColorLB.SelectEntryPos(1);
			break;
		case COL_NONE:
			aDeletedColorLB.SelectEntryPos(0);
			break;
		default:
			aDeletedColorLB.SelectEntry(Color(nColor));
	}

	nColor = rChangedAttr.nColor;

	switch (nColor)
	{
		case COL_TRANSPARENT:
			aChangedColorLB.SelectEntryPos(1);
			break;
		case COL_NONE:
			aChangedColorLB.SelectEntryPos(0);
			break;
		default:
			aChangedColorLB.SelectEntry(Color(nColor));
	}

	aMarkColorLB.SelectEntry(pOpt->GetMarkAlignColor());

	aInsertLB.SelectEntryPos(0);
	aDeletedLB.SelectEntryPos(0);
	aChangedLB.SelectEntryPos(0);

    lcl_FillRedlineAttrListBox(aInsertLB, rInsertAttr, aInsertAttrMap,
            sizeof(aInsertAttrMap) / sizeof(sal_uInt16));
    lcl_FillRedlineAttrListBox(aDeletedLB, rDeletedAttr, aDeletedAttrMap,
            sizeof(aDeletedAttrMap) / sizeof(sal_uInt16));
    lcl_FillRedlineAttrListBox(aChangedLB, rChangedAttr, aChangedAttrMap,
            sizeof(aChangedAttrMap) / sizeof(sal_uInt16));

	sal_uInt16 nPos = 0;
	switch (pOpt->GetMarkAlignMode())
	{
        case text::HoriOrientation::NONE:     nPos = 0;   break;
        case text::HoriOrientation::LEFT:     nPos = 1;   break;
        case text::HoriOrientation::RIGHT:    nPos = 2;   break;
        case text::HoriOrientation::OUTSIDE:  nPos = 3;   break;
        case text::HoriOrientation::INSIDE:   nPos = 4;   break;
	}
	aMarkPosLB.SelectEntryPos(nPos);

	// Einstellungen in Preview anzeigen
	AttribHdl(&aInsertLB);
	ColorHdl(&aInsertColorLB);
    AttribHdl(&aDeletedLB);
	ColorHdl(&aInsertColorLB);
    AttribHdl(&aChangedLB);
    ColorHdl(&aChangedColorLB);

	ChangedMaskPrevHdl();
}

IMPL_LINK( SwRedlineOptionsTabPage, AttribHdl, ListBox *, pLB )
{
    SvxFontPrevWindow *pPrev = 0;
	ColorListBox *pColorLB;

	if (pLB == &aInsertLB)
    {
		pColorLB = &aInsertColorLB;
        pPrev = &aInsertedPreviewWN;
    }
	else if (pLB == &aDeletedLB)
    {
		pColorLB = &aDeletedColorLB;
        pPrev = &aDeletedPreviewWN;
    }
    else
    {
		pColorLB = &aChangedColorLB;
        pPrev = &aChangedPreviewWN;
    }

	SvxFont&	rFont = pPrev->GetFont();
	SvxFont&	rCJKFont = pPrev->GetCJKFont();

	rFont.SetWeight(WEIGHT_NORMAL);
	rCJKFont.SetWeight(WEIGHT_NORMAL);
	rFont.SetItalic(ITALIC_NONE);
	rCJKFont.SetItalic(ITALIC_NONE);
	rFont.SetUnderline(UNDERLINE_NONE);
	rCJKFont.SetUnderline(UNDERLINE_NONE);
	rFont.SetStrikeout(STRIKEOUT_NONE);
	rCJKFont.SetStrikeout(STRIKEOUT_NONE);
	rFont.SetCaseMap(SVX_CASEMAP_NOT_MAPPED);
	rCJKFont.SetCaseMap(SVX_CASEMAP_NOT_MAPPED);

	sal_uInt16		nPos = pColorLB->GetSelectEntryPos();

	switch( nPos )
	{
		case 0:
			rFont.SetColor( Color( COL_BLACK ) );
			rCJKFont.SetColor( Color( COL_BLACK ) );
			break;
		case 1:
		case LISTBOX_ENTRY_NOTFOUND:
			rFont.SetColor( Color( COL_RED ) );
			rCJKFont.SetColor( Color( COL_RED ) );
			break;
		default:
			rFont.SetColor( pColorLB->GetEntryColor( nPos ) );
			rCJKFont.SetColor( pColorLB->GetEntryColor( nPos ) );
			break;
	}

	nPos = pLB->GetSelectEntryPos();
	if( nPos == LISTBOX_ENTRY_NOTFOUND )
		nPos = 0;

	CharAttr*	pAttr = ( CharAttr* ) pLB->GetEntryData( nPos );
    //switch off preview background color
    pPrev->ResetColor();
	switch (pAttr->nItemId)
	{
		case SID_ATTR_CHAR_WEIGHT:
			rFont.SetWeight( ( FontWeight ) pAttr->nAttr );
			rCJKFont.SetWeight( ( FontWeight ) pAttr->nAttr );
			break;

		case SID_ATTR_CHAR_POSTURE:
			rFont.SetItalic( ( FontItalic ) pAttr->nAttr );
			rCJKFont.SetItalic( ( FontItalic ) pAttr->nAttr );
			break;

		case SID_ATTR_CHAR_UNDERLINE:
			rFont.SetUnderline( ( FontUnderline ) pAttr->nAttr );
			rCJKFont.SetUnderline( ( FontUnderline ) pAttr->nAttr );
			break;

		case SID_ATTR_CHAR_STRIKEOUT:
			rFont.SetStrikeout( ( FontStrikeout ) pAttr->nAttr );
			rCJKFont.SetStrikeout( ( FontStrikeout ) pAttr->nAttr );
			break;

		case SID_ATTR_CHAR_CASEMAP:
			rFont.SetCaseMap( ( SvxCaseMap ) pAttr->nAttr );
			rCJKFont.SetCaseMap( ( SvxCaseMap ) pAttr->nAttr );
			break;

		case SID_ATTR_BRUSH:
		{
			nPos = pColorLB->GetSelectEntryPos();
			if( nPos )
				pPrev->SetColor( pColorLB->GetSelectEntryColor() );
			else
				pPrev->SetColor( Color( COL_LIGHTGRAY ) );

			rFont.SetColor( Color( COL_BLACK ) );
			rCJKFont.SetColor( Color( COL_BLACK ) );
		}
		break;
	}

	pPrev->Invalidate();

	return 0;
}

IMPL_LINK( SwRedlineOptionsTabPage, ColorHdl, ColorListBox *, pColorLB )
{
    SvxFontPrevWindow *pPrev = 0;
    ListBox* pLB;

	if (pColorLB == &aInsertColorLB)
    {
		pLB = &aInsertLB;
        pPrev = &aInsertedPreviewWN;
    }
    else if (pColorLB == &aDeletedColorLB)
    {
		pLB = &aDeletedLB;
        pPrev = &aDeletedPreviewWN;
    }
    else
    {
		pLB = &aChangedLB;
        pPrev = &aChangedPreviewWN;
    }

	SvxFont&	rFont = pPrev->GetFont();
	SvxFont&	rCJKFont = pPrev->GetCJKFont();
	sal_uInt16		nPos = pLB->GetSelectEntryPos();
	if( nPos == LISTBOX_ENTRY_NOTFOUND )
		nPos = 0;

	CharAttr*	pAttr = ( CharAttr* ) pLB->GetEntryData( nPos );

	if( pAttr->nItemId == SID_ATTR_BRUSH )
	{
		rFont.SetColor( Color( COL_BLACK ) );
		rCJKFont.SetColor( Color( COL_BLACK ) );
		nPos = pColorLB->GetSelectEntryPos();
		if( nPos && nPos != LISTBOX_ENTRY_NOTFOUND )
			pPrev->SetColor( pColorLB->GetSelectEntryColor() );
		else
			pPrev->SetColor( Color( COL_LIGHTGRAY ) );
	}
	else
	{
		nPos = pColorLB->GetSelectEntryPos();

		switch( nPos )
		{
			case 0:
				rFont.SetColor( Color( COL_BLACK ) );
				rCJKFont.SetColor( Color( COL_BLACK ) );
				break;
			case 1:
			case LISTBOX_ENTRY_NOTFOUND:
				rFont.SetColor( Color( COL_RED ) );
				rCJKFont.SetColor( Color( COL_RED ) );
				break;
			default:
				rFont.SetColor( pColorLB->GetEntryColor( nPos ) );
				rCJKFont.SetColor( pColorLB->GetEntryColor( nPos ) );
				break;
		}
	}

	pPrev->Invalidate();

	return 0;
}

IMPL_LINK( SwRedlineOptionsTabPage, ChangedMaskPrevHdl, ListBox *, EMPTYARG )
{
	aMarkPreviewWN.SetMarkPos(aMarkPosLB.GetSelectEntryPos());
	aMarkPreviewWN.SetColor(aMarkColorLB.GetSelectEntryColor().GetColor());

	aMarkPreviewWN.Invalidate();

	return 0;
}

void SwRedlineOptionsTabPage::InitFontStyle(SvxFontPrevWindow& rExampleWin)
{
	const AllSettings&	rAllSettings = Application::GetSettings();
	LanguageType		eLangType = rAllSettings.GetUILanguage();
	Color				aBackCol( rAllSettings.GetStyleSettings().GetWindowColor() );
	SvxFont&			rFont = rExampleWin.GetFont();
	SvxFont&			rCJKFont = rExampleWin.GetCJKFont();
	SvxFont&			rCTLFont = rExampleWin.GetCTLFont();

	Font				aFont( OutputDevice::GetDefaultFont( DEFAULTFONT_SERIF, eLangType,
														DEFAULTFONT_FLAGS_ONLYONE, &rExampleWin ) );
	Font				aCJKFont( OutputDevice::GetDefaultFont( DEFAULTFONT_CJK_TEXT, eLangType,
														DEFAULTFONT_FLAGS_ONLYONE, &rExampleWin ) );
	Font				aCTLFont( OutputDevice::GetDefaultFont( DEFAULTFONT_CTL_TEXT, eLangType,
														DEFAULTFONT_FLAGS_ONLYONE, &rExampleWin ) );
	const Size			aDefSize( 0, 12 );
	aFont.SetSize( aDefSize );
	aCJKFont.SetSize( aDefSize );
	aCTLFont.SetSize( aDefSize );

	aFont.SetFillColor( aBackCol );
	aCJKFont.SetFillColor( aBackCol );
	aCTLFont.SetFillColor( aBackCol );

	aFont.SetWeight( WEIGHT_NORMAL );
	aCJKFont.SetWeight( WEIGHT_NORMAL );
	aCTLFont.SetWeight( WEIGHT_NORMAL );

	rFont = aFont;
	rCJKFont = aCJKFont;
	rCTLFont = aCTLFont;

	const Size			aNewSize( 0, rExampleWin.GetOutputSize().Height() * 2 / 3 );
	rFont.SetSize( aNewSize );
	rCJKFont.SetSize( aNewSize );

	rExampleWin.SetFont( rFont, rCJKFont,rCTLFont );

	rExampleWin.UseResourceText();

	Wallpaper			aWall( aBackCol );
	rExampleWin.SetBackground( aWall );
	rExampleWin.Invalidate();
}


#ifdef DBG_UTIL
/*******************************************************
 ******************************************************/
/*----------------- OS 11.01.95  -----------------------
 TabPage Testeinstellungen
-------------------------------------------------------*/

void lcl_SetPosSize(Window& rWin, Point aPos, Size aSize)
{
	aPos = rWin.LogicToPixel(aPos, MAP_APPFONT);
	aSize = rWin.OutputDevice::LogicToPixel(aSize, MAP_APPFONT);
	rWin.SetPosSizePixel(aPos, aSize);
}

SwTestTabPage::SwTestTabPage( Window* pParent,
									  const SfxItemSet& rCoreSet) :
	SfxTabPage( pParent, WB_HIDE, rCoreSet),
    aTestFL        ( this, WB_GROUP ),
	aTest1CBox   	( this,	0 ),
	aTest2CBox    	( this,	0 ),
	aTest3CBox    	( this,	0 ),
	aTest4CBox    	( this,	0 ),
	aTest5CBox   	( this, 0 ),
	aTest6CBox   	( this,	0 ),
	aTest7CBox   	( this,	0 ),
	aTest8CBox		( this,	0 ),
	aTest9CBox		( this,	0 ),
	aTest10CBox		( this,	0 ),
	bAttrModified( sal_False )
{
	lcl_SetPosSize(*this, 		Point(0,0), Size(260 , 135));
    lcl_SetPosSize(aTestFL,   Point(6,2), Size(209,8));
	lcl_SetPosSize(aTest1CBox  , 	Point(12 , 14),	Size(74 , 10));
	lcl_SetPosSize(aTest2CBox  , 	Point(12 , 27),	Size(74 , 10));
	lcl_SetPosSize(aTest3CBox  , 	Point(12 , 40),	Size(74 , 10));
	lcl_SetPosSize(aTest4CBox  , 	Point(12 , 53),	Size(74 , 10));
	lcl_SetPosSize(aTest5CBox  , 	Point(12 , 66),	Size(74 , 10));
	lcl_SetPosSize(aTest6CBox  , 	Point(116, 14),	Size(74 , 10));
	lcl_SetPosSize(aTest7CBox  , 	Point(116, 27),	Size(74 , 10));
	lcl_SetPosSize(aTest8CBox  , 	Point(116, 40),	Size(74 , 10));
	lcl_SetPosSize(aTest9CBox  , 	Point(116, 53),	Size(74 , 10));
	lcl_SetPosSize(aTest10CBox	, 	Point(116, 66),	Size(74 , 10));

    aTestFL.SetText( String(ByteString("Einstellungen nur f\xFCr Testzwecke" ), RTL_TEXTENCODING_MS_1252));
	aTest1CBox .SetText( C2S("unused"));
	aTest2CBox .SetText( C2S("dynamic"));
	aTest3CBox .SetText( C2S("No calm"               ));
	aTest4CBox .SetText( C2S("WYSIWYG debug"         ));
	aTest5CBox .SetText( C2S("No idle format"        ));
	aTest6CBox .SetText( C2S("No screen adj"         ));
	aTest7CBox .SetText( C2S("win format"            ));
	aTest8CBox .SetText( C2S("No Scroll"             ));
	aTest9CBox .SetText( C2S("DrawingLayerNotLoading"));
	aTest10CBox.SetText( C2S("AutoFormat by Input"   ));
    aTestFL.Show();
	aTest1CBox .Show();
	aTest2CBox .Show();
	aTest3CBox .Show();
	aTest4CBox .Show();
	aTest5CBox .Show();
	aTest6CBox .Show();
	aTest7CBox .Show();
	aTest8CBox .Show();
	aTest9CBox .Show();
	aTest10CBox.Show();
	Init();

}


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


SfxTabPage*	SwTestTabPage::Create( Window* pParent,
									   const SfxItemSet& rAttrSet )
{
	return ( new SwTestTabPage( pParent, rAttrSet ) );
}
//------------------------------------------------------------------------


sal_Bool 	SwTestTabPage::FillItemSet( SfxItemSet& rCoreSet )
{

	if ( bAttrModified )
	{
		SwTestItem aTestItem(FN_PARAM_SWTEST);
			aTestItem.bTest1=aTest1CBox.IsChecked();
			aTestItem.bTest2=aTest2CBox.IsChecked();
			aTestItem.bTest3=aTest3CBox.IsChecked();
			aTestItem.bTest4=aTest4CBox.IsChecked();
			aTestItem.bTest5=aTest5CBox.IsChecked();
			aTestItem.bTest6=aTest6CBox.IsChecked();
			aTestItem.bTest7=aTest7CBox.IsChecked();
			aTestItem.bTest8=aTest8CBox.IsChecked();
			aTestItem.bTest9=aTest9CBox.IsChecked();
			aTestItem.bTest10=aTest10CBox.IsChecked();
		rCoreSet.Put(aTestItem);
	}
	return bAttrModified;
}
//------------------------------------------------------------------------


void SwTestTabPage::Reset( const SfxItemSet& )
{
	const SfxItemSet& rSet = GetItemSet();
	const SwTestItem* pTestAttr = 0;

	if( SFX_ITEM_SET == rSet.GetItemState( FN_PARAM_SWTEST , sal_False,
									(const SfxPoolItem**)&pTestAttr ))
	{
		aTest1CBox.Check(pTestAttr->bTest1);
		aTest2CBox.Check(pTestAttr->bTest2);
		aTest3CBox.Check(pTestAttr->bTest3);
		aTest4CBox.Check(pTestAttr->bTest4);
		aTest5CBox.Check(pTestAttr->bTest5);
		aTest6CBox.Check(pTestAttr->bTest6);
		aTest7CBox.Check(pTestAttr->bTest7);
		aTest8CBox.Check(pTestAttr->bTest8);
		aTest9CBox.Check(pTestAttr->bTest9);
		aTest10CBox.Check(pTestAttr->bTest10);
	}
}
//------------------------------------------------------------------------


void SwTestTabPage::Init()
{
	// handler
	Link aLk = LINK( this, SwTestTabPage, AutoClickHdl );
	aTest1CBox.SetClickHdl( aLk );
	aTest2CBox.SetClickHdl( aLk );
	aTest3CBox.SetClickHdl( aLk );
	aTest4CBox.SetClickHdl( aLk );
	aTest5CBox.SetClickHdl( aLk );
	aTest6CBox.SetClickHdl( aLk );
	aTest7CBox.SetClickHdl( aLk );
	aTest8CBox.SetClickHdl( aLk );
	aTest9CBox.SetClickHdl( aLk );
	aTest10CBox.SetClickHdl( aLk );
}
//------------------------------------------------------------------------


IMPL_LINK_INLINE_START( SwTestTabPage, AutoClickHdl, CheckBox *, EMPTYARG )
{
	bAttrModified = sal_True;
	return 0;
}
IMPL_LINK_INLINE_END( SwTestTabPage, AutoClickHdl, CheckBox *, EMPTYARG )
#endif