xref: /aoo41x/main/sw/source/ui/frmdlg/wrap.cxx (revision efeef26f)

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


#include "hintids.hxx"
#include <vcl/graph.hxx>
#include <svx/htmlmode.hxx>
#include <sfx2/objsh.hxx>
#include <svl/intitem.hxx>
#include <editeng/opaqitem.hxx>
#include <editeng/ulspitem.hxx>
#include <editeng/lrspitem.hxx>
// OD 18.09.2003 #i18732#
#include <fmtfollowtextflow.hxx>
#include <svx/swframevalidation.hxx>


#include "cmdid.h"
#include "uitool.hxx"
#include "wrtsh.hxx"
#include "swmodule.hxx"
#include "viewopt.hxx"
#include "frmatr.hxx"
#include "frmmgr.hxx"
#include "globals.hrc"
#include "frmui.hrc"
#include "wrap.hrc"
#include "wrap.hxx"

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


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

static sal_uInt16 __FAR_DATA aWrapPageRg[] = {
	RES_LR_SPACE, RES_UL_SPACE,
	RES_PROTECT, RES_SURROUND,
	RES_PRINT, RES_PRINT,
	0
};


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



SwWrapDlg::SwWrapDlg(Window* pParent, SfxItemSet& rSet, SwWrtShell* pSh, sal_Bool bDrawMode) :
	SfxSingleTabDialog(pParent, rSet, 0),
	pWrtShell(pSh)

{
	// TabPage erzeugen
    SwWrapTabPage* pNewPage = (SwWrapTabPage*) SwWrapTabPage::Create(this, rSet);
    pNewPage->SetFormatUsed(sal_False, bDrawMode);
    pNewPage->SetShell(pWrtShell);
    SetTabPage(pNewPage);

	String sTitle(SW_RES(STR_FRMUI_WRAP));
	SetText(sTitle);
}



SwWrapDlg::~SwWrapDlg()
{
}

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



SwWrapTabPage::SwWrapTabPage(Window *pParent, const SfxItemSet &rSet) :
	SfxTabPage(pParent, SW_RES(TP_FRM_WRAP), rSet),

    aWrapFLC           (this, SW_RES(C_WRAP_FL)),
	aNoWrapRB			(this, SW_RES(RB_NO_WRAP)),
	aWrapLeftRB			(this, SW_RES(RB_WRAP_LEFT)),
	aWrapRightRB		(this, SW_RES(RB_WRAP_RIGHT)),
	aWrapParallelRB		(this, SW_RES(RB_WRAP_PARALLEL)),
	aWrapThroughRB		(this, SW_RES(RB_WRAP_THROUGH)),
	aIdealWrapRB		(this, SW_RES(RB_WRAP_IDEAL)),

    aMarginFL           (this, SW_RES(FL_MARGIN)),
    aLeftMarginFT       (this, SW_RES(FT_LEFT_MARGIN)),
    aLeftMarginED       (this, SW_RES(ED_LEFT_MARGIN)),
    aRightMarginFT      (this, SW_RES(FT_RIGHT_MARGIN)),
    aRightMarginED      (this, SW_RES(ED_RIGHT_MARGIN)),
    aTopMarginFT        (this, SW_RES(FT_TOP_MARGIN)),
    aTopMarginED        (this, SW_RES(ED_TOP_MARGIN)),
    aBottomMarginFT     (this, SW_RES(FT_BOTTOM_MARGIN)),
    aBottomMarginED     (this, SW_RES(ED_BOTTOM_MARGIN)),

    aOptionsSepFL       (this, SW_RES(FL_OPTION_SEP)),
    aOptionsFL          (this, SW_RES(FL_OPTION)),
    aWrapAnchorOnlyCB   (this, SW_RES(CB_ANCHOR_ONLY)),
	aWrapTransparentCB	(this, SW_RES(CB_TRANSPARENT)),
	aWrapOutlineCB		(this, SW_RES(CB_OUTLINE)),
	aWrapOutsideCB		(this, SW_RES(CB_ONLYOUTSIDE)),

    aWrapIL             (SW_RES(IL_WRAP)),
    aWrapILH            (SW_RES(ILH_WRAP)),

    nAnchorId(FLY_AT_PARA),
    nHtmlMode(0),

    pWrtSh(0),

    bFormat(sal_False),
	bNew(sal_True),
	bHtmlMode(sal_False),
    bContourImage(sal_False)

{
	FreeResource();
	SetExchangeSupport();

	Link aLk = LINK(this, SwWrapTabPage, RangeModifyHdl);
	aLeftMarginED.SetUpHdl(aLk);
	aLeftMarginED.SetDownHdl(aLk);
	aLeftMarginED.SetFirstHdl(aLk);
	aLeftMarginED.SetLastHdl(aLk);
	aLeftMarginED.SetLoseFocusHdl(aLk);

	aRightMarginED.SetUpHdl(aLk);
	aRightMarginED.SetDownHdl(aLk);
	aRightMarginED.SetFirstHdl(aLk);
	aRightMarginED.SetLastHdl(aLk);
	aRightMarginED.SetLoseFocusHdl(aLk);

	aTopMarginED.SetUpHdl(aLk);
	aTopMarginED.SetDownHdl(aLk);
	aTopMarginED.SetFirstHdl(aLk);
	aTopMarginED.SetLastHdl(aLk);
	aTopMarginED.SetLoseFocusHdl(aLk);

	aBottomMarginED.SetUpHdl(aLk);
	aBottomMarginED.SetDownHdl(aLk);
	aBottomMarginED.SetFirstHdl(aLk);
	aBottomMarginED.SetLastHdl(aLk);
	aBottomMarginED.SetLoseFocusHdl(aLk);

	aLk = LINK(this, SwWrapTabPage, WrapTypeHdl);
	aNoWrapRB.SetClickHdl(aLk);
	aWrapLeftRB.SetClickHdl(aLk);
	aWrapRightRB.SetClickHdl(aLk);
	aWrapParallelRB.SetClickHdl(aLk);
	aWrapThroughRB.SetClickHdl(aLk);
	aIdealWrapRB.SetClickHdl(aLk);
    ApplyImageList();
	aWrapOutlineCB.SetClickHdl(LINK(this, SwWrapTabPage, ContourHdl));
}



SwWrapTabPage::~SwWrapTabPage()
{
}



SfxTabPage* SwWrapTabPage::Create(Window *pParent, const SfxItemSet &rSet)
{
	return new SwWrapTabPage(pParent, rSet);
}
/*--------------------------------------------------------------------
	Beschreibung:
 --------------------------------------------------------------------*/



void SwWrapTabPage::Reset(const SfxItemSet &rSet)
{
	//Contour fuer Draw, Grafik und OLE (Einfuegen/Grafik/Eigenschaften fehlt noch!)
	if( bDrawMode )
	{
		aWrapOutlineCB.Show();
		aWrapOutsideCB.Show();

		aWrapTransparentCB.Check( 0 == ((const SfxInt16Item&)rSet.Get(
										FN_DRAW_WRAP_DLG)).GetValue() );
		aWrapTransparentCB.SaveValue();
	}
	else
	{
		sal_Bool bShowCB = bFormat;
		if( !bFormat )
		{
			int nSelType = pWrtSh->GetSelectionType();
			if( ( nSelType & nsSelectionType::SEL_GRF ) ||
			    ( nSelType & nsSelectionType::SEL_OLE && GRAPHIC_NONE !=
				            pWrtSh->GetIMapGraphic().GetType() ))
				bShowCB = sal_True;
		}
		if( bShowCB )
		{
			aWrapOutlineCB.Show();
			aWrapOutsideCB.Show();
		}
	}

	nHtmlMode = ::GetHtmlMode((const SwDocShell*)SfxObjectShell::Current());
	bHtmlMode = nHtmlMode & HTMLMODE_ON ? sal_True : sal_False;

	FieldUnit aMetric = ::GetDfltMetric(bHtmlMode);
	SetMetric( aLeftMarginED  , aMetric );
	SetMetric( aRightMarginED , aMetric );
	SetMetric( aTopMarginED   , aMetric );
	SetMetric( aBottomMarginED, aMetric );

	const SwFmtSurround& rSurround = (const SwFmtSurround&)rSet.Get(RES_SURROUND);

    SwSurround nSur = rSurround.GetSurround();
	const SwFmtAnchor &rAnch = (const SwFmtAnchor&)rSet.Get(RES_ANCHOR);
	nAnchorId = rAnch.GetAnchorId();

    if (((nAnchorId == FLY_AT_PARA) || (nAnchorId == FLY_AT_CHAR))
        && (nSur != SURROUND_NONE))
    {
		aWrapAnchorOnlyCB.Check( rSurround.IsAnchorOnly() );
    }
	else
    {
		aWrapAnchorOnlyCB.Enable( sal_False );
    }

	sal_Bool bContour = rSurround.IsContour();
	aWrapOutlineCB.Check( bContour );
	aWrapOutsideCB.Check( rSurround.IsOutside() );
	aWrapThroughRB.Enable(!aWrapOutlineCB.IsChecked());
	bContourImage = !bContour;

	ImageRadioButton* pBtn = NULL;

	switch (nSur)
	{
		case SURROUND_NONE:
		{
			pBtn = &aNoWrapRB;
			break;
		}

		case SURROUND_THROUGHT:
		{
			// transparent ?
			pBtn = &aWrapThroughRB;

			if (!bDrawMode)
			{
				const SvxOpaqueItem& rOpaque = (const SvxOpaqueItem&)rSet.Get(RES_OPAQUE);
				aWrapTransparentCB.Check(!rOpaque.GetValue());
			}
			break;
		}

		case SURROUND_PARALLEL:
		{
			pBtn = &aWrapParallelRB;
			break;
		}

		case SURROUND_IDEAL:
		{
			pBtn = &aIdealWrapRB;
			break;
		}

		default:
		{
			if (nSur == SURROUND_LEFT)
				pBtn = &aWrapLeftRB;
			else if (nSur == SURROUND_RIGHT)
				pBtn = &aWrapRightRB;
		}
	}
	if (pBtn)
	{
		pBtn->Check();
		WrapTypeHdl(pBtn);
		// Hier wird fuer Zeichenobjekte, die im Moment auf Durchlauf stehen,
		// schon mal der Default "Kontur an" vorbereitet, falls man spaeter auf
		// irgendeinen Umlauf umschaltet.
		if (bDrawMode && !aWrapOutlineCB.IsEnabled())
			aWrapOutlineCB.Check();
	}
	aWrapTransparentCB.Enable( pBtn == &aWrapThroughRB && !bHtmlMode );

	const SvxULSpaceItem& rUL = (const SvxULSpaceItem&)rSet.Get(RES_UL_SPACE);
	const SvxLRSpaceItem& rLR = (const SvxLRSpaceItem&)rSet.Get(RES_LR_SPACE);

	// Abstand zum Text
	aLeftMarginED.SetValue(aLeftMarginED.Normalize(rLR.GetLeft()), FUNIT_TWIP);
	aRightMarginED.SetValue(aRightMarginED.Normalize(rLR.GetRight()), FUNIT_TWIP);
	aTopMarginED.SetValue(aTopMarginED.Normalize(rUL.GetUpper()), FUNIT_TWIP);
	aBottomMarginED.SetValue(aBottomMarginED.Normalize(rUL.GetLower()), FUNIT_TWIP);

	ContourHdl(0);
	ActivatePage( rSet );
}

/*--------------------------------------------------------------------
	Beschreibung:	Attribute in den Set stopfen bei OK
 --------------------------------------------------------------------*/



sal_Bool SwWrapTabPage::FillItemSet(SfxItemSet &rSet)
{
	sal_Bool bModified = sal_False;
	const SfxPoolItem* pOldItem;

	const SwFmtSurround& rOldSur = (const SwFmtSurround&)GetItemSet().Get(RES_SURROUND);
	SwFmtSurround aSur( rOldSur );

    SvxOpaqueItem aOp( RES_OPAQUE);

	if (!bDrawMode)
	{
		const SvxOpaqueItem& rOpaque = (const SvxOpaqueItem&)GetItemSet().Get(RES_OPAQUE);
        aOp = rOpaque;
		aOp.SetValue(sal_True);
	}

	if (aNoWrapRB.IsChecked())
		aSur.SetSurround(SURROUND_NONE);
	else if (aWrapLeftRB.IsChecked())
		aSur.SetSurround(SURROUND_LEFT);
	else if (aWrapRightRB.IsChecked())
		aSur.SetSurround(SURROUND_RIGHT);
	else if (aWrapParallelRB.IsChecked())
		aSur.SetSurround(SURROUND_PARALLEL);
	else if (aWrapThroughRB.IsChecked())
	{
		aSur.SetSurround(SURROUND_THROUGHT);
		if (aWrapTransparentCB.IsChecked() && !bDrawMode)
			aOp.SetValue(sal_False);
	}
	else if (aIdealWrapRB.IsChecked())
		aSur.SetSurround(SURROUND_IDEAL);

	aSur.SetAnchorOnly( aWrapAnchorOnlyCB.IsChecked() );
	sal_Bool bContour = aWrapOutlineCB.IsChecked() && aWrapOutlineCB.IsEnabled();
	aSur.SetContour( bContour );

	if ( bContour )
		aSur.SetOutside(aWrapOutsideCB.IsChecked());

	if(0 == (pOldItem = GetOldItem( rSet, RES_SURROUND )) ||
				aSur != *pOldItem )
	{
		rSet.Put(aSur);
		bModified = sal_True;
	}

	if (!bDrawMode)
	{
		if(0 == (pOldItem = GetOldItem( rSet, FN_OPAQUE )) ||
					aOp != *pOldItem )
		{
			rSet.Put(aOp);
			bModified = sal_True;
		}
	}

	sal_Bool bTopMod = aTopMarginED.IsValueModified();
	sal_Bool bBottomMod = aBottomMarginED.IsValueModified();

    SvxULSpaceItem aUL( RES_UL_SPACE );
	aUL.SetUpper((sal_uInt16)aTopMarginED.Denormalize(aTopMarginED.GetValue(FUNIT_TWIP)));
	aUL.SetLower((sal_uInt16)aBottomMarginED.Denormalize(aBottomMarginED.GetValue(FUNIT_TWIP)));

	if ( bTopMod || bBottomMod )
	{
		if(0 == (pOldItem = GetOldItem(rSet, RES_UL_SPACE)) ||
				aUL != *pOldItem )
		{
			rSet.Put( aUL, RES_UL_SPACE );
			bModified = sal_True;
		}
	}

	sal_Bool bLeftMod = aLeftMarginED.IsValueModified();
	sal_Bool bRightMod = aRightMarginED.IsValueModified();

    SvxLRSpaceItem aLR( RES_LR_SPACE );
	aLR.SetLeft((sal_uInt16)aLeftMarginED.Denormalize(aLeftMarginED.GetValue(FUNIT_TWIP)));
	aLR.SetRight((sal_uInt16)aRightMarginED.Denormalize(aRightMarginED.GetValue(FUNIT_TWIP)));

	if ( bLeftMod || bRightMod )
	{
		if( 0 == (pOldItem = GetOldItem(rSet, RES_LR_SPACE)) ||
				aLR != *pOldItem )
		{
			rSet.Put(aLR, RES_LR_SPACE);
			bModified = sal_True;
		}
	}

	if ( bDrawMode )
	{
		sal_Bool bChecked = aWrapTransparentCB.IsChecked() & aWrapTransparentCB.IsEnabled();
		if (aWrapTransparentCB.GetSavedValue() != bChecked)
			bModified |= 0 != rSet.Put(SfxInt16Item(FN_DRAW_WRAP_DLG, bChecked ? 0 : 1));
	}

	return bModified;
}

/*--------------------------------------------------------------------
	Beschreibung:	Bsp - Update
 --------------------------------------------------------------------*/



void SwWrapTabPage::ActivatePage(const SfxItemSet& rSet)
{
	// Anchor
	const SwFmtAnchor &rAnch = (const SwFmtAnchor&)rSet.Get(RES_ANCHOR);
	nAnchorId = rAnch.GetAnchorId();
    sal_Bool bEnable = (nAnchorId != FLY_AS_CHAR);

	if (!bDrawMode)
	{
		SwWrtShell* pSh = bFormat ? ::GetActiveWrtShell() : pWrtSh;
		SwFlyFrmAttrMgr aMgr( bNew, pSh, (const SwAttrSet&)GetItemSet() );
        SvxSwFrameValidation aVal;

		// Size
		const SwFmtFrmSize& rFrmSize = (const SwFmtFrmSize&)rSet.Get(RES_FRM_SIZE);
		Size aSize = rFrmSize.GetSize();

		// Rand
		const SvxULSpaceItem& rUL = (const SvxULSpaceItem&)rSet.Get(RES_UL_SPACE);
		const SvxLRSpaceItem& rLR = (const SvxLRSpaceItem&)rSet.Get(RES_LR_SPACE);
        nOldLeftMargin  = static_cast< sal_uInt16 >(rLR.GetLeft());
        nOldRightMargin = static_cast< sal_uInt16 >(rLR.GetRight());
        nOldUpperMargin = static_cast< sal_uInt16 >(rUL.GetUpper());
        nOldLowerMargin = static_cast< sal_uInt16 >(rUL.GetLower());

		// Position
		const SwFmtHoriOrient& rHori = (const SwFmtHoriOrient&)rSet.Get(RES_HORI_ORIENT);
		const SwFmtVertOrient& rVert = (const SwFmtVertOrient&)rSet.Get(RES_VERT_ORIENT);

        aVal.nAnchorType = static_cast< sal_Int16 >(nAnchorId);
		aVal.bAutoHeight = rFrmSize.GetHeightSizeType() == ATT_MIN_SIZE;
		aVal.bAutoWidth = rFrmSize.GetWidthSizeType() == ATT_MIN_SIZE;
		aVal.bMirror = rHori.IsPosToggle();
        // OD 18.09.2003 #i18732#
        aVal.bFollowTextFlow =
            static_cast<const SwFmtFollowTextFlow&>(rSet.Get(RES_FOLLOW_TEXT_FLOW)).GetValue();

        aVal.nHoriOrient = (short)rHori.GetHoriOrient();
        aVal.nVertOrient = (short)rVert.GetVertOrient();

		aVal.nHPos = rHori.GetPos();
        aVal.nHRelOrient = rHori.GetRelationOrient();
		aVal.nVPos = rVert.GetPos();
        aVal.nVRelOrient = rVert.GetRelationOrient();

		if (rFrmSize.GetWidthPercent() && rFrmSize.GetWidthPercent() != 0xff)
			aSize.Width() = aSize.Width() * rFrmSize.GetWidthPercent() / 100;

		if (rFrmSize.GetHeightPercent() && rFrmSize.GetHeightPercent() != 0xff)
			aSize.Height() = aSize.Height() * rFrmSize.GetHeightPercent() / 100;

		aVal.nWidth  = aSize.Width();
		aVal.nHeight = aSize.Height();
		aFrmSize = aSize;

        aMgr.ValidateMetrics(aVal, 0);

		SwTwips nLeft;
		SwTwips nRight;
		SwTwips nTop;
		SwTwips nBottom;

		nLeft	= aVal.nHPos - aVal.nMinHPos;
		nRight	= aVal.nMaxWidth - aVal.nWidth;
		nTop	= aVal.nVPos - aVal.nMinVPos;
		nBottom	= aVal.nMaxHeight - aVal.nHeight;

		if (bHtmlMode && 0 == (nHtmlMode & HTMLMODE_FULL_ABS_POS))
		{
			nLeft = nRight = ( nLeft + nRight ) / 2;
			nTop = nBottom = ( nTop + nBottom ) / 2;
		}
		else
		{
            if (aVal.nAnchorType == FLY_AS_CHAR)
			{
				nLeft = nRight;

				if (aVal.nVPos < 0)
				{
					if (aVal.nVPos <= aVal.nMaxHeight)
						nTop = aVal.nMaxVPos - aVal.nHeight;
					else
						nTop = nBottom = 0;	// Kein Umlauf
				}
				else
					nTop = aVal.nMaxVPos - aVal.nHeight - aVal.nVPos;
			}
			else
			{
				nLeft += nRight;
				nTop += nBottom;
			}

			nBottom	= nTop;
			nRight = nLeft;
		}

		aLeftMarginED.SetMax(aLeftMarginED.Normalize(nLeft), FUNIT_TWIP);
		aRightMarginED.SetMax(aRightMarginED.Normalize(nRight), FUNIT_TWIP);

		aTopMarginED.SetMax(aTopMarginED.Normalize(nTop), FUNIT_TWIP);
		aBottomMarginED.SetMax(aBottomMarginED.Normalize(nBottom), FUNIT_TWIP);

		RangeModifyHdl(&aLeftMarginED);
		RangeModifyHdl(&aTopMarginED);
	}

	const SwFmtSurround& rSurround = (const SwFmtSurround&)rSet.Get(RES_SURROUND);
    SwSurround nSur = rSurround.GetSurround();

	aWrapTransparentCB.Enable( bEnable && !bHtmlMode && nSur == SURROUND_THROUGHT );
	if(bHtmlMode)
	{
		sal_Bool bSomeAbsPos = 0 != (nHtmlMode & HTMLMODE_SOME_ABS_POS);
		const SwFmtHoriOrient& rHori = (const SwFmtHoriOrient&)rSet.Get(RES_HORI_ORIENT);
        sal_Int16 eHOrient = rHori.GetHoriOrient();
        sal_Int16 eHRelOrient = rHori.GetRelationOrient();
		aWrapOutlineCB.Hide();
        const bool bAllHtmlModes =
            ((nAnchorId == FLY_AT_PARA) || (nAnchorId == FLY_AT_CHAR)) &&
                            (eHOrient == text::HoriOrientation::RIGHT || eHOrient == text::HoriOrientation::LEFT);
		aWrapAnchorOnlyCB.Enable( bAllHtmlModes && nSur != SURROUND_NONE );
		aWrapOutsideCB.Hide();
		aIdealWrapRB.Enable( sal_False );


		aWrapTransparentCB.Enable( sal_False );
        aNoWrapRB.Enable( FLY_AT_PARA == nAnchorId );
		aWrapParallelRB.Enable( sal_False  );
        aWrapLeftRB       .Enable
                    (  (FLY_AT_PARA == nAnchorId)
                    || (   (FLY_AT_CHAR == nAnchorId)
                        && (eHOrient == text::HoriOrientation::RIGHT)
                        && (eHRelOrient == text::RelOrientation::PRINT_AREA)));
        aWrapRightRB      .Enable
                    (  (FLY_AT_PARA == nAnchorId)
                    || (   (FLY_AT_CHAR == nAnchorId)
                        && (eHOrient == text::HoriOrientation::LEFT)
                        && (eHRelOrient == text::RelOrientation::PRINT_AREA)));

        aWrapThroughRB.Enable
                (   (  (FLY_AT_PAGE == nAnchorId)
                    || (   (FLY_AT_CHAR == nAnchorId)
                        && (eHRelOrient != text::RelOrientation::PRINT_AREA))
                    || (FLY_AT_PARA == nAnchorId))
                && bSomeAbsPos
                && (eHOrient != text::HoriOrientation::RIGHT));
		if(aNoWrapRB.IsChecked() && !aNoWrapRB.IsEnabled())
		{
			if(aWrapThroughRB.IsEnabled())
				aWrapThroughRB.Check(sal_True);
			else if(aWrapLeftRB.IsEnabled())
				aWrapLeftRB.Check();
			else if(aWrapRightRB.IsEnabled())
				aWrapRightRB.Check();

		}
		if(aWrapLeftRB.IsChecked() && !aWrapLeftRB.IsEnabled())
		{
			if(aWrapRightRB.IsEnabled())
				aWrapRightRB.Check();
			else if(aWrapThroughRB.IsEnabled())
				aWrapThroughRB.Check();
		}
		if(aWrapRightRB.IsChecked() && !aWrapRightRB.IsEnabled())
		{
			if(aWrapLeftRB.IsEnabled())
				aWrapLeftRB.Check();
			else if(aWrapThroughRB.IsEnabled())
				aWrapThroughRB.Check();
		}
		if(aWrapThroughRB.IsChecked() && !aWrapThroughRB.IsEnabled())
			if(aNoWrapRB.IsEnabled())
				aNoWrapRB.Check();

		if(aWrapParallelRB.IsChecked() && !aWrapParallelRB.IsEnabled())
			aWrapThroughRB.Check();
	}
	else
	{
		aNoWrapRB.Enable( bEnable );
		aWrapLeftRB.Enable( bEnable );
		aWrapRightRB.Enable( bEnable );
		aIdealWrapRB.Enable( bEnable );
		aWrapThroughRB.Enable( bEnable );
		aWrapParallelRB.Enable( bEnable );
        aWrapAnchorOnlyCB.Enable(
                ((nAnchorId == FLY_AT_PARA) || (nAnchorId == FLY_AT_CHAR))
				&& nSur != SURROUND_NONE );
	}
	ContourHdl(0);
}



int SwWrapTabPage::DeactivatePage(SfxItemSet* _pSet)
{
    if(_pSet)
        FillItemSet(*_pSet);

	return sal_True;
}

/*--------------------------------------------------------------------
	Beschreibung:	Bereichspruefung
 --------------------------------------------------------------------*/



IMPL_LINK( SwWrapTabPage, RangeModifyHdl, MetricField *, pEdit )
{
	if(bHtmlMode && 0 == (nHtmlMode & HTMLMODE_FULL_ABS_POS))
	{
        sal_Int64 nValue = pEdit->GetValue();
		if (pEdit == &aLeftMarginED)
			aRightMarginED.SetUserValue(nValue, FUNIT_NONE);
		else if (pEdit == &aRightMarginED)
			aLeftMarginED.SetUserValue(nValue, FUNIT_NONE);
		else if (pEdit == &aTopMarginED)
			aBottomMarginED.SetUserValue(nValue, FUNIT_NONE);
		else if (pEdit == &aBottomMarginED)
			aTopMarginED.SetUserValue(nValue, FUNIT_NONE);
	}
	else
	{
        sal_Int64 nValue = pEdit->GetValue();
        MetricField *pOpposite = 0;

		if (pEdit == &aLeftMarginED)
			pOpposite = &aRightMarginED;
		else if (pEdit == &aRightMarginED)
			pOpposite = &aLeftMarginED;
		else if (pEdit == &aTopMarginED)
			pOpposite = &aBottomMarginED;
		else if (pEdit == &aBottomMarginED)
			pOpposite = &aTopMarginED;

        sal_Int64 nOpposite = pOpposite->GetValue();

		if (nValue + nOpposite > Max(pEdit->GetMax(), pOpposite->GetMax()))
			pOpposite->SetValue(pOpposite->GetMax() - nValue);
	}

	return 0;
}

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



IMPL_LINK( SwWrapTabPage, WrapTypeHdl, ImageRadioButton *, pBtn )
{
	sal_Bool bWrapThrough = (pBtn == &aWrapThroughRB);
	aWrapTransparentCB.Enable( bWrapThrough && !bHtmlMode );
    bWrapThrough |= ( nAnchorId == FLY_AS_CHAR );
	aWrapOutlineCB.Enable( !bWrapThrough && pBtn != &aNoWrapRB);
	aWrapOutsideCB.Enable( !bWrapThrough && aWrapOutlineCB.IsChecked() );
    aWrapAnchorOnlyCB.Enable(
        ((nAnchorId == FLY_AT_PARA) || (nAnchorId == FLY_AT_CHAR)) &&
		(pBtn != &aNoWrapRB) );

	ContourHdl(0);
	return 0;
}

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



IMPL_LINK( SwWrapTabPage, ContourHdl, CheckBox *, EMPTYARG )
{
	sal_Bool bEnable = !(aWrapOutlineCB.IsChecked() && aWrapOutlineCB.IsEnabled());

	aWrapOutsideCB.Enable(!bEnable);

	bEnable =  !aWrapOutlineCB.IsChecked();
	if (bEnable == bContourImage) // damit es nicht immer flackert
	{
        bContourImage = !bEnable;
        ApplyImageList();
    }

	return 0;
}

/*--------------------------------------------------------------------
	Beschreibung:
 --------------------------------------------------------------------*/
sal_uInt16* SwWrapTabPage::GetRanges()
{
	return aWrapPageRg;
}
/* -----------------------------08.05.2002 14:28------------------------------

 ---------------------------------------------------------------------------*/
void SwWrapTabPage::DataChanged( const DataChangedEvent& rDCEvt )
{
	if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
         (rDCEvt.GetFlags() & SETTINGS_STYLE) )
            ApplyImageList();

    SfxTabPage::DataChanged( rDCEvt );
}
/* -----------------------------08.05.2002 14:28------------------------------

 ---------------------------------------------------------------------------*/
void SwWrapTabPage::ApplyImageList()
{
    ImageList& rImgLst = GetSettings().GetStyleSettings().GetHighContrastMode() ?
        aWrapILH : aWrapIL;

    aWrapThroughRB.SetModeRadioImage(rImgLst.GetImage(IMG_THROUGH));
    sal_Bool bWrapOutline =  !aWrapOutlineCB.IsChecked();
    if(bWrapOutline)
    {
        aNoWrapRB.SetModeRadioImage(rImgLst.GetImage(IMG_NONE));
        aWrapLeftRB.SetModeRadioImage(rImgLst.GetImage(IMG_LEFT));
        aWrapRightRB.SetModeRadioImage(rImgLst.GetImage(IMG_RIGHT));
        aWrapParallelRB.SetModeRadioImage(rImgLst.GetImage(IMG_PARALLEL));
        aIdealWrapRB.SetModeRadioImage(rImgLst.GetImage(IMG_IDEAL));
    }
    else
    {
        aNoWrapRB.SetModeRadioImage(rImgLst.GetImage( IMG_KON_NONE ));
        aWrapLeftRB.SetModeRadioImage(rImgLst.GetImage( IMG_KON_LEFT ));
        aWrapRightRB.SetModeRadioImage(rImgLst.GetImage( IMG_KON_RIGHT ));
        aWrapParallelRB.SetModeRadioImage(rImgLst.GetImage(IMG_KON_PARALLEL ));
        aIdealWrapRB.SetModeRadioImage(rImgLst.GetImage( IMG_KON_IDEAL ));
    }
}