xref: /AOO41X/main/sw/source/ui/docvw/PostItMgr.cxx (revision dec99bbd1eb6ae693d6ee672c1a69e3a32d917e7)

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

#include "PostItMgr.hxx"
#include <postithelper.hxx>

#include <SidebarWin.hxx>
#include <AnnotationWin.hxx>
#include <frmsidebarwincontainer.hxx>
#include <accmap.hxx>

#include <SidebarWindowsConsts.hxx>
#include <AnchorOverlayObject.hxx>
#include <ShadowOverlayObject.hxx>

#include <vcl/svapp.hxx>
#include <vcl/scrbar.hxx>
#include <vcl/outdev.hxx>

#include <viewopt.hxx>

#include <view.hxx>
#include <docsh.hxx>
#include <wrtsh.hxx>
#include <doc.hxx>
#include <fldbas.hxx>
#include <fmtfld.hxx>
#include <docufld.hxx>
#include <edtwin.hxx>
#include <txtfld.hxx>
#include <txtannotationfld.hxx>
#include <ndtxt.hxx>
#include <redline.hxx>
#include <docary.hxx>
#include <SwRewriter.hxx>
#include <tools/color.hxx>

#include <swmodule.hxx>
#include <annotation.hrc>
#include "cmdid.h"

#include <sfx2/request.hxx>
#include <sfx2/event.hxx>
#include <svl/srchitem.hxx>


#include <svl/languageoptions.hxx>
#include <svtools/langtab.hxx>
#include <svl/smplhint.hxx>

#include <svx/svdview.hxx>
#include <editeng/eeitem.hxx>
#include <editeng/langitem.hxx>
#include <editeng/outliner.hxx>

#include <i18npool/mslangid.hxx>
#include <i18npool/lang.h>

#include "swevent.hxx"
#include "switerator.hxx"

// distance between Anchor Y and initial note position
#define POSTIT_INITIAL_ANCHOR_DISTANCE      20
//distance between two postits
#define POSTIT_SPACE_BETWEEN				8
#define POSTIT_MINIMUMSIZE_WITH_META		60
#define POSTIT_SCROLL_SIDEBAR_HEIGHT		20

// if we layout more often we stop, this should never happen
#define MAX_LOOP_COUNT						50

using namespace sw::sidebarwindows;


bool comp_pos(const SwSidebarItem* a, const SwSidebarItem* b)
{
    // sort by anchor position
    return a->GetAnchorPosition() < b->GetAnchorPosition();
}

SwPostItMgr::SwPostItMgr(SwView* pView)
	: mpView(pView)
	, mpWrtShell(mpView->GetDocShell()->GetWrtShell())
	, mpEditWin(&mpView->GetEditWin())
	, mnEventId(0)
	, mbWaitingForCalcRects(false)
	, mpActivePostIt(0)
	, mbLayout(false)
	, mbLayoutHeight(0)
	, mbLayouting(false)
	, mbReadOnly(mpView->GetDocShell()->IsReadOnly())
	, mbDeleteNote(true)
	, mpAnswer(0)
    , mbIsShowAnchor( false )
    , mpFrmSidebarWinContainer( 0 )
{
	if(!mpView->GetDrawView() )
		mpView->GetWrtShell().MakeDrawView();

	SwNoteProps aProps;
    mbIsShowAnchor = aProps.IsShowAnchor();

	//make sure we get the colour yellow always, even if not the first one of comments or redlining
	SW_MOD()->GetRedlineAuthor();

	// collect all PostIts and redline comments that exist after loading the document
	// don't check for existance for any of them, don't focus them
	AddPostIts(false,false);
    /*  this code can be used once we want redline comments in the Sidebar
	AddRedlineComments(false,false);
	*/
	// we want to receive stuff like SFX_HINT_DOCCHANGED
	StartListening(*mpView->GetDocShell());
	if (!mvPostItFlds.empty())
	{
		mbWaitingForCalcRects = true;
		mnEventId = Application::PostUserEvent( LINK( this, SwPostItMgr, CalcHdl), 0 );
	}
}

SwPostItMgr::~SwPostItMgr()
{
	if ( mnEventId )
		Application::RemoveUserEvent( mnEventId );
    // forget about all our Sidebar windows
    RemoveSidebarWin();
	EndListening( *mpView->GetDocShell() );

	for(std::vector<SwPostItPageItem*>::iterator i = mPages.begin(); i!= mPages.end() ; i++)
		delete (*i);
	mPages.clear();

    delete mpFrmSidebarWinContainer;
    mpFrmSidebarWinContainer = 0;
}

void SwPostItMgr::CheckForRemovedPostIts()
{
	bool bRemoved = false;
    for(std::list<SwSidebarItem*>::iterator i = mvPostItFlds.begin(); i!= mvPostItFlds.end(); )
	{
        std::list<SwSidebarItem*>::iterator it = i++;
		if ( !(*it)->UseElement() )
		{
            SwSidebarItem* p = (*it);
			mvPostItFlds.remove(*it);
            if (GetActiveSidebarWin() == p->pPostIt)
                SetActiveSidebarWin(0);
			if (p->pPostIt)
				delete p->pPostIt;
			delete p;
			bRemoved = true;
		}
	}

	if ( bRemoved )
	{
		// make sure that no deleted items remain in page lists
		// todo: only remove deleted ones?!
		if ( mvPostItFlds.empty() )
		{
			PreparePageContainer();
			PrepareView();
		}
		else
			// if postits are their make sure that page lists are not empty
			// otherwise sudden paints can cause pain (in BorderOverPageBorder)
			CalcRects();
	}
}

void SwPostItMgr::InsertItem(SfxBroadcaster* pItem, bool bCheckExistance, bool bFocus)
{
	if (bCheckExistance)
	{
        for(std::list<SwSidebarItem*>::iterator i = mvPostItFlds.begin(); i!= mvPostItFlds.end() ; i++)
		{
			if ( (*i)->GetBroadCaster() == pItem )
				return;
		}
	}
	mbLayout = bFocus;
	if (pItem->ISA(SwFmtFld))
        mvPostItFlds.push_back(new SwAnnotationItem(static_cast<SwFmtFld&>(*pItem), true, bFocus) );
	/*
	else
	if (pItem->ISA(SwRedline))
		mvPostItFlds.push_back(new SwRedCommentItem( static_cast<SwRedline*>(pItem), true, bFocus)) ;
	*/
	DBG_ASSERT(pItem->ISA(SwFmtFld) /*|| pItem->ISA(SwRedline)*/,"Mgr::InsertItem: seems like new stuff was added");
	StartListening(*pItem);
}

void SwPostItMgr::RemoveItem( SfxBroadcaster* pBroadcast )
{
	EndListening(*pBroadcast);
    for(std::list<SwSidebarItem*>::iterator i = mvPostItFlds.begin(); i!= mvPostItFlds.end() ; i++)
	{
		if ( (*i)->GetBroadCaster() == pBroadcast )
		{
            SwSidebarItem* p = (*i);
            if (GetActiveSidebarWin() == p->pPostIt)
                SetActiveSidebarWin(0);
			mvPostItFlds.remove(*i);
			delete p->pPostIt;
			delete p;
			break;
		}
	}
	mbLayout = true;
	PrepareView();
}

void SwPostItMgr::Notify( SfxBroadcaster& rBC, const SfxHint& rHint )
{
	if ( rHint.IsA(TYPE(SfxEventHint) ) )
	{
		sal_uInt32 nId = ((SfxEventHint&)rHint).GetEventId();
		if ( nId == SW_EVENT_LAYOUT_FINISHED )
		{
			if ( !mbWaitingForCalcRects && !mvPostItFlds.empty())
			{
				mbWaitingForCalcRects = true;
				mnEventId = Application::PostUserEvent( LINK( this, SwPostItMgr, CalcHdl), 0 );
			}
		}
	}
	else if ( rHint.IsA(TYPE(SfxSimpleHint)	) )
	{
		sal_uInt32 nId = ((SfxSimpleHint&)rHint).GetId();
		switch ( nId )
		{
			case SFX_HINT_MODECHANGED:
			{
				if ( mbReadOnly != !!(mpView->GetDocShell()->IsReadOnly()) )
				{
					mbReadOnly = !mbReadOnly;
					SetReadOnlyState();
					mbLayout = true;
				}
				break;
			}
			case SFX_HINT_DOCCHANGED:
			{
				if ( mpView->GetDocShell() == &rBC )
				{
					if ( !mbWaitingForCalcRects && !mvPostItFlds.empty())
					{
						mbWaitingForCalcRects = true;
						mnEventId = Application::PostUserEvent( LINK( this, SwPostItMgr, CalcHdl), 0 );
					}
				}
				break;
			}
			case SFX_HINT_USER04:
			{
				// if we are in a SplitNode/Cut operation, do not delete note and then add again, as this will flicker
				mbDeleteNote = !mbDeleteNote;
				break;
			}
			case SFX_HINT_DYING:
			{
				if ( mpView->GetDocShell() != &rBC )
				{
					// field to be removed is the broadcaster
					DBG_ERROR("Notification for removed SwFmtFld was not sent!");
					RemoveItem(&rBC);
				}
				break;
			}
		}
	}
	/*
	else if ( rHint.IsA(TYPE(SwRedlineHint) ) )
	{
		const SwRedlineHint rRedlineHint = static_cast<const SwRedlineHint&>(rHint);
	   	SwRedline* pRedline = const_cast<SwRedline*>(rRedlineHint.GetRedline());
		switch ( rRedlineHint.Which() )
		{
			case SWREDLINE_INSERTED :
			{
				bool bEmpty = !HasNotes();
				InsertItem( pRedline, true, false );
				if (bEmpty && !mvPostItFlds.empty())
					PrepareView(true);
				break;
			}
			case SWREDLINE_REMOVED:
			{
				RemoveItem(pRedline);
				break;
			}
			case SWREDLINE_FOCUS:
			{
                                if (rRedlineHint.GetView()== mpView)
					Focus(rBC);
				break;
			}
		}
	}
	*/
	else if ( rHint.IsA(TYPE(SwFmtFldHint) ) )
	{
		const SwFmtFldHint& rFmtHint = static_cast<const SwFmtFldHint&>(rHint);
		SwFmtFld* pFld = const_cast <SwFmtFld*>( rFmtHint.GetField() );
		switch ( rFmtHint.Which() )
		{
			case SWFMTFLD_INSERTED :
			{
				if (!pFld)
				{
					AddPostIts(true);
					break;
				}
				// get field to be inserted from hint
				if ( pFld->IsFldInDoc() )
				{
					bool bEmpty = !HasNotes();
					InsertItem( pFld, true, false );
					if (bEmpty && !mvPostItFlds.empty())
						PrepareView(true);
				}
				else
				{
					DBG_ERROR( "Inserted field not in document!" );
                		}
				break;
			}
			case SWFMTFLD_REMOVED:
			{
				if (mbDeleteNote)
				{
					if (!pFld)
					{
						CheckForRemovedPostIts();
						break;
					}
					RemoveItem(pFld);
				}
				break;
			}
			case SWFMTFLD_FOCUS:
			{
       				if (rFmtHint.GetView()== mpView)
					Focus(rBC);
				break;
			}
			case SWFMTFLD_CHANGED:
			{
		                SwFmtFld* pFmtFld = dynamic_cast<SwFmtFld*>(&rBC);
                for(std::list<SwSidebarItem*>::iterator i = mvPostItFlds.begin(); i!= mvPostItFlds.end() ; i++)
				{
                			if ( pFmtFld == (*i)->GetBroadCaster() )
					{
						if ((*i)->pPostIt)
						{
							(*i)->pPostIt->SetPostItText();
							mbLayout = true;
						}
						break;
					}
				}
				break;
			}

            case SWFMTFLD_LANGUAGE:
                {
                    SwFmtFld* pFmtFld = dynamic_cast<SwFmtFld*>(&rBC);
                    for(std::list<SwSidebarItem*>::iterator i = mvPostItFlds.begin(); i!= mvPostItFlds.end() ; i++)
                    {
                        if ( pFmtFld == (*i)->GetBroadCaster() )
                        {
                            if ((*i)->pPostIt)
                            {
                                const sal_uInt16 nScriptType = SvtLanguageOptions::GetScriptTypeOfLanguage( (*i)->GetFmtFld().GetField()->GetLanguage() );
                                sal_uInt16 nLangWhichId = 0;
                                switch (nScriptType)
                                {
                                case SCRIPTTYPE_LATIN :    nLangWhichId = EE_CHAR_LANGUAGE ; break;
                                case SCRIPTTYPE_ASIAN :    nLangWhichId = EE_CHAR_LANGUAGE_CJK; break;
                                case SCRIPTTYPE_COMPLEX :  nLangWhichId = EE_CHAR_LANGUAGE_CTL; break;
                                }
                                (*i)->pPostIt->SetLanguage(
                                    SvxLanguageItem(
                                    (*i)->GetFmtFld().GetField()->GetLanguage(),
                                    nLangWhichId) );
                            }
                            break;
                        }
                    }
                    break;
                }
        }
    }
}

void SwPostItMgr::Focus(SfxBroadcaster& rBC)
{
	if (!mpWrtShell->GetViewOptions()->IsPostIts())
	{
		SfxRequest aRequest(mpView->GetViewFrame(),FN_VIEW_NOTES);
		mpView->ExecViewOptions(aRequest);
	}

    for(std::list<SwSidebarItem*>::iterator i = mvPostItFlds.begin(); i!= mvPostItFlds.end() ; i++)
	{
		// field to get the focus is the broadcaster
		if ( &rBC == (*i)->GetBroadCaster() )
		{
			if ((*i)->pPostIt)
			{
				(*i)->pPostIt->GrabFocus();
				MakeVisible((*i)->pPostIt);
			}
			else
			{
				// when the layout algorithm starts, this postit is created and receives focus
				(*i)->bFocus = true;
			}
		}
	}
}

bool SwPostItMgr::CalcRects()
{
    if ( mnEventId )
    {
        // if CalcRects() was forced and an event is still pending: remove it
        // it is superfluous and also may cause reentrance problems if triggered while layouting
        Application::RemoveUserEvent( mnEventId );
        mnEventId = 0;
    }

    bool bChange = false;
    bool bRepair = false;
    PreparePageContainer();
    if ( !mvPostItFlds.empty() )
    {
        for(std::list<SwSidebarItem*>::iterator i = mvPostItFlds.begin(); i!= mvPostItFlds.end() ; i++)
        {
            SwSidebarItem* pItem = (*i);
            if ( !pItem->UseElement() )
            {
                DBG_ERROR("PostIt is not in doc or other wrong use");
                bRepair = true;
                continue;
            }

            const SwRect aOldAnchorRect( pItem->maLayoutInfo.mPosition );
            const SwPostItHelper::SwLayoutStatus eOldLayoutStatus = pItem->mLayoutStatus;
            const sal_uLong nOldStartNodeIdx( pItem->maLayoutInfo.mnStartNodeIdx );
            const xub_StrLen nOldStartContent( pItem->maLayoutInfo.mnStartContent );

            {
                // update layout information
                const SwTxtAnnotationFld* pTxtAnnotationFld =
                    dynamic_cast< const SwTxtAnnotationFld* >( pItem->GetFmtFld().GetTxtFld() );
                const ::sw::mark::IMark* pAnnotationMark =
                    pTxtAnnotationFld != NULL ? pTxtAnnotationFld->GetAnnotationMark() : NULL;
                if ( pAnnotationMark != NULL )
                {
                    pItem->mLayoutStatus =
                        SwPostItHelper::getLayoutInfos(
                            pItem->maLayoutInfo,
                            pItem->GetAnchorPosition(),
                            &pAnnotationMark->GetMarkStart() );
                }
                else
                {
                    pItem->mLayoutStatus =
                        SwPostItHelper::getLayoutInfos( pItem->maLayoutInfo, pItem->GetAnchorPosition() );
                }
            }
            bChange = bChange
                      || pItem->maLayoutInfo.mPosition != aOldAnchorRect
                      || pItem->mLayoutStatus != eOldLayoutStatus
                      || pItem->maLayoutInfo.mnStartNodeIdx != nOldStartNodeIdx
                      || pItem->maLayoutInfo.mnStartContent != nOldStartContent;
        }

        // show notes in right order in navigator
        //prevent Anchors during layout to overlap, e.g. when moving a frame
        Sort(SORT_POS);

        // sort the items into the right page vector, so layout can be done by page
        for(std::list<SwSidebarItem*>::iterator i = mvPostItFlds.begin(); i!= mvPostItFlds.end() ; i++)
        {
            SwSidebarItem* pItem = (*i);
            if( SwPostItHelper::INVISIBLE == pItem->mLayoutStatus )
            {
                if (pItem->pPostIt)
                    pItem->pPostIt->HideNote();
                continue;
            }

            if( SwPostItHelper::HIDDEN == pItem->mLayoutStatus )
            {
                if (!mpWrtShell->GetViewOptions()->IsShowHiddenChar())
                {
                    if (pItem->pPostIt)
                        pItem->pPostIt->HideNote();
                    continue;
                }
            }

            const unsigned long aPageNum = pItem->maLayoutInfo.mnPageNumber;
            if (aPageNum > mPages.size())
            {
                const unsigned long nNumberOfPages = mPages.size();
                for (unsigned int j=0; j<aPageNum - nNumberOfPages; ++j)
                    mPages.push_back( new SwPostItPageItem());
            }
            mPages[aPageNum-1]->mList->push_back(pItem);
            mPages[aPageNum-1]->mPageRect = pItem->maLayoutInfo.mPageFrame;
            mPages[aPageNum-1]->eSidebarPosition = pItem->maLayoutInfo.meSidebarPosition;
        }

        if (!bChange && mpWrtShell->getIDocumentSettingAccess()->get(IDocumentSettingAccess::BROWSE_MODE))
        {
            long nLayoutHeight = SwPostItHelper::getLayoutHeight( mpWrtShell->GetLayout() );
            if( nLayoutHeight > mbLayoutHeight )
            {
                if (mPages[0]->bScrollbar || HasScrollbars())
                    bChange = true;
            }
            else if( nLayoutHeight < mbLayoutHeight )
            {
                if (mPages[0]->bScrollbar || !BorderOverPageBorder(1))
                    bChange = true;
            }
        }
    }

    if ( bRepair )
        CheckForRemovedPostIts();

    mbLayoutHeight = SwPostItHelper::getLayoutHeight( mpWrtShell->GetLayout() );
    mbWaitingForCalcRects = false;
    return bChange;
}

bool SwPostItMgr::HasScrollbars() const
{
    for(std::list<SwSidebarItem*>::const_iterator i = mvPostItFlds.begin(); i!= mvPostItFlds.end() ; i++)
	{
        if ((*i)->bShow && (*i)->pPostIt && (*i)->pPostIt->HasScrollbar())
			return true;
	}
	return false;
}

void SwPostItMgr::PreparePageContainer()
{
	// we do not just delete the SwPostItPageItem, so offset/scrollbar is not lost
	long lPageSize = mpWrtShell->GetNumPages();
	long lContainerSize = mPages.size();

	if (lContainerSize < lPageSize)
	{
		for (int i=0; i<lPageSize - lContainerSize;i++)
			mPages.push_back( new SwPostItPageItem());
	}
	else
	if (lContainerSize > lPageSize)
	{
		for (int i=mPages.size()-1; i >= lPageSize;--i)
		{
			delete mPages[i];
			mPages.pop_back();
		}
	}
	// only clear the list, DO NOT delete the objects itself
	for(std::vector<SwPostItPageItem*>::iterator i = mPages.begin(); i!= mPages.end() ; i++)
	{
		(*i)->mList->clear();
		if (mvPostItFlds.empty())
			(*i)->bScrollbar = false;

	}
}

void SwPostItMgr::LayoutPostIts()
{
	if ( !mvPostItFlds.empty() && !mbWaitingForCalcRects )
	{
		mbLayouting = true;

			//loop over all pages and do the layout
			// - create SwPostIt if neccessary
			// - place SwPostIts on their initial position
			// - calculate neccessary height for all PostIts together
			bool bUpdate = false;
			for (unsigned long n=0;n<mPages.size();n++)
			{
				// only layout if there are notes on this page
				if (mPages[n]->mList->size()>0)
				{
                    std::list<SwSidebarWin*>    aVisiblePostItList;
					unsigned long			lNeededHeight = 0;
					long					mlPageBorder = 0;
					long					mlPageEnd = 0;

                    for(SwSidebarItem_iterator i = mPages[n]->mList->begin(); i!= mPages[n]->mList->end(); i++)
					{
                        SwSidebarItem* pItem = (*i);
                        SwSidebarWin* pPostIt = pItem->pPostIt;

                        if (mPages[n]->eSidebarPosition == sw::sidebarwindows::SIDEBAR_LEFT )
						{
							// x value for notes positioning
							mlPageBorder = mpEditWin->LogicToPixel( Point( mPages[n]->mPageRect.Left(), 0)).X() - GetSidebarWidth(true);// - GetSidebarBorderWidth(true);
							//bending point
                            mlPageEnd =
                                mpWrtShell->getIDocumentSettingAccess()->get(IDocumentSettingAccess::BROWSE_MODE)
                                ? pItem->maLayoutInfo.mPagePrtArea.Left()
                                : mPages[n]->mPageRect.Left() + 350;
						}
                        else if (mPages[n]->eSidebarPosition == sw::sidebarwindows::SIDEBAR_RIGHT )
						{
							// x value for notes positioning
							mlPageBorder = mpEditWin->LogicToPixel( Point(mPages[n]->mPageRect.Right(), 0)).X() + GetSidebarBorderWidth(true);
							//bending point
                            mlPageEnd =
                                mpWrtShell->getIDocumentSettingAccess()->get(IDocumentSettingAccess::BROWSE_MODE)
                                ? pItem->maLayoutInfo.mPagePrtArea.Right() :
                                mPages[n]->mPageRect.Right() - 350;
						}

						if (pItem->bShow)
						{
                            long Y = mpEditWin->LogicToPixel( Point(0,pItem->maLayoutInfo.mPosition.Bottom())).Y();
							long aPostItHeight = 0;
							if (!pPostIt)
							{
                                pPostIt = (*i)->GetSidebarWindow( mpView->GetEditWin(),
                                                                  WB_DIALOGCONTROL,
                                                                  *this,
                                                                  0 );
								pPostIt->InitControls();
								pPostIt->SetReadonly(mbReadOnly);
								pItem->pPostIt = pPostIt;
								if (mpAnswer)
								{
									if (pPostIt->CalcFollow()) //do we really have another note in front of this one
                                        static_cast<sw::annotation::SwAnnotationWin*>(pPostIt)->InitAnswer(mpAnswer);
									delete mpAnswer;
									mpAnswer = 0;
								}
							}

                            pPostIt->SetChangeTracking(
                                pItem->mLayoutStatus,
                                GetColorAnchor(pItem->maLayoutInfo.mRedlineAuthor));
                            pPostIt->SetSidebarPosition(mPages[n]->eSidebarPosition);
                            pPostIt->SetFollow(pPostIt->CalcFollow());
                            aPostItHeight = ( pPostIt->GetPostItTextHeight() < pPostIt->GetMinimumSizeWithoutMeta()
                                              ? pPostIt->GetMinimumSizeWithoutMeta()
                                              : pPostIt->GetPostItTextHeight() )
                                            + pPostIt->GetMetaHeight();
                            pPostIt->SetPosSizePixelRect( mlPageBorder ,
                                                          Y - GetInitialAnchorDistance(),
                                                          GetNoteWidth() ,
                                                          aPostItHeight,
                                                          pItem->maLayoutInfo.mPosition,
                                                          mlPageEnd );
                            pPostIt->ChangeSidebarItem( *pItem );

							if (pItem->bFocus)
							{
								mbLayout = true;
                                pPostIt->GrabFocus();
								pItem->bFocus = false;
							}
							// only the visible postits are used for the final layout
							aVisiblePostItList.push_back(pPostIt);
							lNeededHeight += pPostIt->IsFollow() ? aPostItHeight : aPostItHeight+GetSpaceBetween();
						}
						else // we don't want to see it
						{
							if (pPostIt)
								pPostIt->HideNote();
						}
					}

					if ((aVisiblePostItList.size()>0) && ShowNotes())
					{
						bool bOldScrollbar = mPages[n]->bScrollbar;
						if (ShowNotes())
							mPages[n]->bScrollbar = LayoutByPage(aVisiblePostItList, mPages[n]->mPageRect.SVRect(), lNeededHeight);
						else
							mPages[n]->bScrollbar = false;
						if (!mPages[n]->bScrollbar)
						{
							mPages[n]->lOffset = 0;
						}
						else
						{
							//when we changed our zoom level, the offset value can be to big, so lets check for the largest possible zoom value
							long aAvailableHeight = mpEditWin->LogicToPixel(Size(0,mPages[n]->mPageRect.Height())).Height() - 2 * GetSidebarScrollerHeight();
							long lOffset = -1 * GetScrollSize() * (aVisiblePostItList.size() - aAvailableHeight / GetScrollSize());
							if (mPages[n]->lOffset < lOffset)
								mPages[n]->lOffset = lOffset;
						}
						bUpdate = (bOldScrollbar != mPages[n]->bScrollbar) || bUpdate;
						const long aSidebarheight = mPages[n]->bScrollbar ? mpEditWin->PixelToLogic(Size(0,GetSidebarScrollerHeight())).Height() : 0;
						/*
                       					TODO
                       					- enlarge all notes till GetNextBorder(), as we resized to average value before
                       					*/
						//lets hide the ones which overlap the page
                        for(SwSidebarWin_iterator i = aVisiblePostItList.begin(); i!= aVisiblePostItList.end() ; i++)
						{
							if (mPages[n]->lOffset != 0)
								(*i)->TranslateTopPosition(mPages[n]->lOffset);

							bool bBottom  = mpEditWin->PixelToLogic(Point(0,(*i)->VirtualPos().Y()+(*i)->VirtualSize().Height())).Y() <= (mPages[n]->mPageRect.Bottom()-aSidebarheight);
							bool bTop = mpEditWin->PixelToLogic(Point(0,(*i)->VirtualPos().Y())).Y() >= (mPages[n]->mPageRect.Top()+aSidebarheight);
							if ( bBottom && bTop )
							{
								(*i)->ShowNote();
							}
							else
							{
								if (mpEditWin->PixelToLogic(Point(0,(*i)->VirtualPos().Y())).Y() < (mPages[n]->mPageRect.Top()+aSidebarheight))
								{
                                    if ( mPages[n]->eSidebarPosition == sw::sidebarwindows::SIDEBAR_LEFT )
                                        (*i)->ShowAnchorOnly(Point( mPages[n]->mPageRect.Left(),
                                                                    mPages[n]->mPageRect.Top()));
                                    else if ( mPages[n]->eSidebarPosition == sw::sidebarwindows::SIDEBAR_RIGHT )
                                        (*i)->ShowAnchorOnly(Point( mPages[n]->mPageRect.Right(),
                                                                    mPages[n]->mPageRect.Top()));
								}
								else
								{
                                    if ( mPages[n]->eSidebarPosition == sw::sidebarwindows::SIDEBAR_LEFT )
                                        (*i)->ShowAnchorOnly(Point(mPages[n]->mPageRect.Left(),
                                                                   mPages[n]->mPageRect.Bottom()));
                                    else if ( mPages[n]->eSidebarPosition == sw::sidebarwindows::SIDEBAR_RIGHT )
                                        (*i)->ShowAnchorOnly(Point(mPages[n]->mPageRect.Right(),
                                                                   mPages[n]->mPageRect.Bottom()));
								}
								DBG_ASSERT(mPages[n]->bScrollbar,"SwPostItMgr::LayoutByPage(): note overlaps, but bScrollbar is not true");
							}
						}

						// do some magic so we really see the focused note
                        for(SwSidebarWin_iterator i = aVisiblePostItList.begin(); i!= aVisiblePostItList.end() ; i++)
						{
                            				if ((*i)->HasChildPathFocus())
							{
								MakeVisible((*i),n+1);
								break;
							}
						}
					}
					else
					{
                        for(SwSidebarWin_iterator i = aVisiblePostItList.begin(); i!= aVisiblePostItList.end() ; i++)
                                                                (*i)->SetPosAndSize();

                                                        bool bOldScrollbar = mPages[n]->bScrollbar;
                                                        mPages[n]->bScrollbar = false;
                                                        bUpdate = (bOldScrollbar != mPages[n]->bScrollbar) || bUpdate;
					}
					aVisiblePostItList.clear();
				}
				else
				{
					bUpdate = true;
					mPages[n]->bScrollbar = false;
				}
			}

			if (!ShowNotes())
			{       // we do not want to see the notes anymore -> Options-Writer-View-Notes
				bool bRepair = false;
                for(SwSidebarItem_iterator i = mvPostItFlds.begin(); i!= mvPostItFlds.end() ; i++)
				{
                    SwSidebarItem* pItem = (*i);
					if ( !pItem->UseElement() )
					{
						DBG_ERROR("PostIt is not in doc!");
						bRepair = true;
						continue;
					}

					if ((*i)->pPostIt)
					{
						(*i)->pPostIt->HideNote();
						if ((*i)->pPostIt->HasChildPathFocus())
						{
                            SetActiveSidebarWin(0);
							(*i)->pPostIt->GrabFocusToDocument();
						}
					}
				}

				if ( bRepair )
					CheckForRemovedPostIts();
			}


			// notes scrollbar is otherwise not drawn correctly for some cases
			// scrollbar area is enough
			if (bUpdate)
				mpEditWin->Invalidate();
		mbLayouting = false;
	}
}

bool SwPostItMgr::BorderOverPageBorder(unsigned long aPage) const
{
	if ( mPages[aPage-1]->mList->empty() )
	{
		DBG_ERROR("Notes SidePane painted but no rects and page lists calculated!");
		return false;
	}

    SwSidebarItem_iterator aItem = mPages[aPage-1]->mList->end();
	--aItem;
	DBG_ASSERT ((*aItem)->pPostIt,"BorderOverPageBorder: NULL postIt, should never happen");
	if ((*aItem)->pPostIt)
	{
		const long aSidebarheight = mPages[aPage-1]->bScrollbar ? mpEditWin->PixelToLogic(Size(0,GetSidebarScrollerHeight())).Height() : 0;
		const long aEndValue = mpEditWin->PixelToLogic(Point(0,(*aItem)->pPostIt->GetPosPixel().Y()+(*aItem)->pPostIt->GetSizePixel().Height())).Y();
		return aEndValue <= mPages[aPage-1]->mPageRect.Bottom()-aSidebarheight;
	}
	else
		return false;
}

void SwPostItMgr::Scroll(const long lScroll,const unsigned long aPage)
{
	DBG_ASSERT((lScroll % GetScrollSize() )==0,"SwPostItMgr::Scroll: scrolling by wrong value");
	// do not scroll more than neccessary up or down
	if ( ((mPages[aPage-1]->lOffset == 0) && (lScroll>0)) || ( BorderOverPageBorder(aPage) && (lScroll<0)) )
		return;

	const bool bOldUp = ArrowEnabled(KEY_PAGEUP,aPage);
	const bool bOldDown = ArrowEnabled(KEY_PAGEDOWN,aPage);
	const long aSidebarheight = mpEditWin->PixelToLogic(Size(0,GetSidebarScrollerHeight())).Height();
    for(SwSidebarItem_iterator i = mPages[aPage-1]->mList->begin(); i!= mPages[aPage-1]->mList->end(); i++)
	{
        SwSidebarWin* pPostIt = (*i)->pPostIt;
		// if this is an answer, we should take the normal position and not the real, slightly moved position
		pPostIt->SetVirtualPosSize(pPostIt->GetPosPixel(),pPostIt->GetSizePixel());
		pPostIt->TranslateTopPosition(lScroll);

		if ((*i)->bShow)
		{
			bool bBottom  = mpEditWin->PixelToLogic(Point(0,pPostIt->VirtualPos().Y()+pPostIt->VirtualSize().Height())).Y() <= (mPages[aPage-1]->mPageRect.Bottom()-aSidebarheight);
			bool bTop = mpEditWin->PixelToLogic(Point(0,pPostIt->VirtualPos().Y())).Y() >=	 (mPages[aPage-1]->mPageRect.Top()+aSidebarheight);
			if ( bBottom && bTop)
			{
					pPostIt->ShowNote();
			}
			else
			{
				if ( mpEditWin->PixelToLogic(Point(0,pPostIt->VirtualPos().Y())).Y() < (mPages[aPage-1]->mPageRect.Top()+aSidebarheight))
				{
                    if (mPages[aPage-1]->eSidebarPosition == sw::sidebarwindows::SIDEBAR_LEFT)
                        pPostIt->ShowAnchorOnly(Point(mPages[aPage-1]->mPageRect.Left(),mPages[aPage-1]->mPageRect.Top()));
                    else if (mPages[aPage-1]->eSidebarPosition == sw::sidebarwindows::SIDEBAR_RIGHT)
                        pPostIt->ShowAnchorOnly(Point(mPages[aPage-1]->mPageRect.Right(),mPages[aPage-1]->mPageRect.Top()));
				}
				else
				{
                    if (mPages[aPage-1]->eSidebarPosition == sw::sidebarwindows::SIDEBAR_LEFT)
                        pPostIt->ShowAnchorOnly(Point(mPages[aPage-1]->mPageRect.Left(),mPages[aPage-1]->mPageRect.Bottom()));
                    else if (mPages[aPage-1]->eSidebarPosition == sw::sidebarwindows::SIDEBAR_RIGHT)
                        pPostIt->ShowAnchorOnly(Point(mPages[aPage-1]->mPageRect.Right(),mPages[aPage-1]->mPageRect.Bottom()));
				}
			}
		}
	}
	mPages[aPage-1]->lOffset += lScroll;
	if ( (bOldUp != ArrowEnabled(KEY_PAGEUP,aPage)) ||(bOldDown != ArrowEnabled(KEY_PAGEDOWN,aPage)) )
	{
		mpEditWin->Invalidate(GetBottomScrollRect(aPage));
		mpEditWin->Invalidate(GetTopScrollRect(aPage));
	}
}

void SwPostItMgr::AutoScroll(const SwSidebarWin* pPostIt,const unsigned long aPage )
{
	// otherwise all notes are visible
	if (mPages[aPage-1]->bScrollbar)
	{
		const long aSidebarheight = mpEditWin->PixelToLogic(Size(0,GetSidebarScrollerHeight())).Height();
		const bool bBottom  = mpEditWin->PixelToLogic(Point(0,pPostIt->GetPosPixel().Y()+pPostIt->GetSizePixel().Height())).Y() <= (mPages[aPage-1]->mPageRect.Bottom()-aSidebarheight);
		const bool bTop = mpEditWin->PixelToLogic(Point(0,pPostIt->GetPosPixel().Y())).Y() >= (mPages[aPage-1]->mPageRect.Top()+aSidebarheight);
		if ( !(bBottom && bTop))
		{
			const long aDiff = bBottom ? mpEditWin->LogicToPixel(Point(0,mPages[aPage-1]->mPageRect.Top() + aSidebarheight)).Y() - pPostIt->GetPosPixel().Y() :
											mpEditWin->LogicToPixel(Point(0,mPages[aPage-1]->mPageRect.Bottom() - aSidebarheight)).Y() - (pPostIt->GetPosPixel().Y()+pPostIt->GetSizePixel().Height());
			// this just adds the missing value to get the next a* GetScrollSize() after aDiff
			// e.g aDiff= 61 POSTIT_SCOLL=50 --> lScroll = 100
			const long lScroll = bBottom ? (aDiff + ( GetScrollSize() - (aDiff % GetScrollSize()))) : (aDiff - (GetScrollSize() + (aDiff % GetScrollSize())));
			Scroll(lScroll, aPage);
		}
	}
}

void SwPostItMgr::MakeVisible(const SwSidebarWin* pPostIt,long aPage )
{
	if (aPage == -1)
	{
		// we dont know the page yet, lets find it ourselves
		for (unsigned long n=0;n<mPages.size();n++)
		{
			if (mPages[n]->mList->size()>0)
			{
                for(SwSidebarItem_iterator i = mPages[n]->mList->begin(); i!= mPages[n]->mList->end(); i++)
				{
					if ((*i)->pPostIt==pPostIt)
					{
						aPage = n+1;
						break;
					}
				}
			}
		}
	}
	if (aPage!=-1)
		AutoScroll(pPostIt,aPage);
	Rectangle aNoteRect (Point(pPostIt->GetPosPixel().X(),pPostIt->GetPosPixel().Y()-5),pPostIt->GetSizePixel());
	if (!aNoteRect.IsEmpty())
		mpWrtShell->MakeVisible(SwRect(mpEditWin->PixelToLogic(aNoteRect)));
}

bool SwPostItMgr::ArrowEnabled(sal_uInt16 aDirection,unsigned long aPage) const
{
	switch (aDirection)
	{
		case KEY_PAGEUP:
			{
				return (mPages[aPage-1]->lOffset != 0);
			}
		case KEY_PAGEDOWN:
			{
				return (!BorderOverPageBorder(aPage));
			}
		default: return false;
	}
}

Color SwPostItMgr::GetArrowColor(sal_uInt16 aDirection,unsigned long aPage) const
{
	if (ArrowEnabled(aDirection,aPage))
	{
		if (Application::GetSettings().GetStyleSettings().GetHighContrastMode())
			return Color(COL_WHITE);
		else
			return COL_NOTES_SIDEPANE_ARROW_ENABLED;
	}
	else
	{
		return COL_NOTES_SIDEPANE_ARROW_DISABLED;
	}
}

bool SwPostItMgr::LayoutByPage(std::list<SwSidebarWin*> &aVisiblePostItList,const Rectangle aBorder, long lNeededHeight)
{
	/*** General layout idea:***/
	//  - if we have space left, we always move the current one up,
	//    otherwise the next one down
	//  - first all notes are resized
	//	- then the real layout starts
	/*************************************************************/

	//rBorder is the page rect
    const Rectangle	rBorder			= mpEditWin->LogicToPixel( aBorder);
	long			lTopBorder		= rBorder.Top() + 5;
	long			lBottomBorder	= rBorder.Bottom() - 5;
	const long		lVisibleHeight	= lBottomBorder - lTopBorder; //rBorder.GetHeight() ;
	long			lSpaceUsed		= 0;
	long			lTranslatePos	= 0;
	int				loop			= 0;
	bool			bDone			= false;
	bool			bScrollbars		= false;

	// do all neccessary resizings
	if (lVisibleHeight < lNeededHeight)
	{
		// ok, now we have to really resize and adding scrollbars
		const long lAverageHeight = (lVisibleHeight - aVisiblePostItList.size()*GetSpaceBetween()) / aVisiblePostItList.size();
		if (lAverageHeight<GetMinimumSizeWithMeta())
		{
			bScrollbars = true;
			lTopBorder += GetSidebarScrollerHeight() + 10;
			lBottomBorder -= (GetSidebarScrollerHeight() + 10);
                for(SwSidebarWin_iterator i = aVisiblePostItList.begin(); i!= aVisiblePostItList.end() ; i++)
					(*i)->SetSize(Size((*i)->VirtualSize().getWidth(),(*i)->GetMinimumSizeWithMeta()));
		}
		else
		{
            for(SwSidebarWin_iterator i = aVisiblePostItList.begin(); i!= aVisiblePostItList.end() ; i++)
			{
				if ( (*i)->VirtualSize().getHeight() > lAverageHeight)
					(*i)->SetSize(Size((*i)->VirtualSize().getWidth(),lAverageHeight));
			}
		}
	}

	//start the real layout so nothing overlaps anymore
	if (aVisiblePostItList.size()>1)
	{
		// if no window is moved anymore we are finished
		while (!bDone)
		{
			loop++;
  			bDone = true;
			lSpaceUsed = lTopBorder + GetSpaceBetween();
            for(SwSidebarWin_iterator i = aVisiblePostItList.begin(); i!= aVisiblePostItList.end() ; i++)
			{
                SwSidebarWin_iterator aNextPostIt = i;
				++aNextPostIt;

				if (aNextPostIt !=aVisiblePostItList.end())
				{
					lTranslatePos = ( (*i)->VirtualPos().Y() + (*i)->VirtualSize().Height()) - (*aNextPostIt)->VirtualPos().Y();
					if (lTranslatePos > 0) // note windows overlaps the next one
					{
						// we are not done yet, loop at least once more
						bDone = false;
						// if there is space left, move the current note up
						// it could also happen that there is no space left for the first note due to a scrollbar
						// then we also jump into, so we move the current one up and the next one down
						if ( (lSpaceUsed <= (*i)->VirtualPos().Y()) || (i==aVisiblePostItList.begin()))
						{
							// we have space left, so let's move the current one up
							if ( ((*i)->VirtualPos().Y()- lTranslatePos - GetSpaceBetween()) > lTopBorder)
							{
								if ((*aNextPostIt)->IsFollow())
                                    (*i)->TranslateTopPosition(-1*(lTranslatePos+ANCHORLINE_WIDTH));
								else
									(*i)->TranslateTopPosition(-1*(lTranslatePos+GetSpaceBetween()));
							}
							else
							{
								long lMoveUp = (*i)->VirtualPos().Y() - lTopBorder;
								(*i)->TranslateTopPosition(-1* lMoveUp);
								if ((*aNextPostIt)->IsFollow())
                                    (*aNextPostIt)->TranslateTopPosition( (lTranslatePos+ANCHORLINE_WIDTH) - lMoveUp);
								else
									(*aNextPostIt)->TranslateTopPosition( (lTranslatePos+GetSpaceBetween()) - lMoveUp);
							}
						}
						else
						{
							// no space left, left move the next one down
							if ((*aNextPostIt)->IsFollow())
                                (*aNextPostIt)->TranslateTopPosition(lTranslatePos+ANCHORLINE_WIDTH);
							else
								(*aNextPostIt)->TranslateTopPosition(lTranslatePos+GetSpaceBetween());
						}
					}
					else
					{
						// the first one could overlap the topborder instead of a second note
						if (i==aVisiblePostItList.begin())
						{
							long lMoveDown = lTopBorder - (*i)->VirtualPos().Y();
							if (lMoveDown>0)
							{
								bDone = false;
								(*i)->TranslateTopPosition( lMoveDown);
							}
						}
					}
					if (aNextPostIt !=aVisiblePostItList.end() && (*aNextPostIt)->IsFollow())
                        lSpaceUsed += (*i)->VirtualSize().Height() + ANCHORLINE_WIDTH;
					else
						lSpaceUsed += (*i)->VirtualSize().Height() + GetSpaceBetween();
				}
				else
				{
					//(*i) is the last visible item
                    SwSidebarWin_iterator aPrevPostIt = i;
					--aPrevPostIt;
					//lTranslatePos = ( (*aPrevPostIt)->VirtualPos().Y() + (*aPrevPostIt)->VirtualSize().Height() + GetSpaceBetween() ) - (*i)->VirtualPos().Y();
					lTranslatePos = ( (*aPrevPostIt)->VirtualPos().Y() + (*aPrevPostIt)->VirtualSize().Height() ) - (*i)->VirtualPos().Y();
					if (lTranslatePos > 0)
					{
						bDone = false;
						if ( ((*i)->VirtualPos().Y()+ (*i)->VirtualSize().Height()+lTranslatePos) < lBottomBorder)
						{
							if ( (*i)->IsFollow() )
                                (*i)->TranslateTopPosition(lTranslatePos+ANCHORLINE_WIDTH);
							else
								(*i)->TranslateTopPosition(lTranslatePos+GetSpaceBetween());
						}
						else
						{
							(*i)->TranslateTopPosition(lBottomBorder - ((*i)->VirtualPos().Y()+ (*i)->VirtualSize().Height()) );
						}
					}
					else
					{
						// note does not overlap, but we might be over the lower border
                        // only do this if there are no scrollbars, otherwise notes are supposed to overlap the border
						if (!bScrollbars && ((*i)->VirtualPos().Y()+ (*i)->VirtualSize().Height() > lBottomBorder) )
						{
							bDone = false;
							(*i)->TranslateTopPosition(lBottomBorder - ((*i)->VirtualPos().Y()+ (*i)->VirtualSize().Height()));
						}
					}
				}
			}
			// security check so we don't loop forever
			if (loop>MAX_LOOP_COUNT)
			{
				DBG_ERROR("PostItMgr::Layout(): We are looping forever");
				break;
			}
		}
	}
	else
	{
		// only one left, make sure it is not hidden at the top or bottom
        SwSidebarWin_iterator i = aVisiblePostItList.begin();
		lTranslatePos = lTopBorder - (*i)->VirtualPos().Y();
		if (lTranslatePos>0)
		{
			(*i)->TranslateTopPosition(lTranslatePos+GetSpaceBetween());
		}
		lTranslatePos =	lBottomBorder - ((*i)->VirtualPos().Y()+ (*i)->VirtualSize().Height());
		if (lTranslatePos<0)
		{
			(*i)->TranslateTopPosition(lTranslatePos);
		}
	}
	return bScrollbars;
 }

/*
void SwPostItMgr::AddRedlineComments(bool bCheckExistance, bool bFocus)
{
	bool bEmpty = mvPostItFlds.empty();
	const SwRedlineTbl& aTable = mpView->GetDocShell()->GetDoc()->GetRedlineTbl();
	for( sal_uInt16 i = 0; i < aTable.Count(); ++i )
	{
		SwRedline* pRedline = const_cast<SwRedline*>((aTable)[i]);
		if ( pRedline->GetComment() != String(rtl::OUString::createFromAscii("")) )
			InsertItem(pRedline, bCheckExistance, bFocus);
	}
	if (bEmpty && !mvPostItFlds.empty())
		PrepareView(true);
 }
 */

void SwPostItMgr::AddPostIts(bool bCheckExistance, bool bFocus)
{
	bool bEmpty = mvPostItFlds.empty();
	SwFieldType* pType = mpView->GetDocShell()->GetDoc()->GetFldType(RES_POSTITFLD, aEmptyStr,false);
	SwIterator<SwFmtFld,SwFieldType> aIter( *pType );
	SwFmtFld* pSwFmtFld = aIter.First();
	while(pSwFmtFld)
	{
		if ( pSwFmtFld->GetTxtFld())
		{
			if ( pSwFmtFld->IsFldInDoc() )
				InsertItem(pSwFmtFld,bCheckExistance,bFocus);
		}
		pSwFmtFld = aIter.Next();
	}

	// if we just added the first one we have to update the view for centering
	if (bEmpty && !mvPostItFlds.empty())
		PrepareView(true);
}

void SwPostItMgr::RemoveSidebarWin()
{
	if (!mvPostItFlds.empty())
	{
        for(std::list<SwSidebarItem*>::iterator i = mvPostItFlds.begin(); i!= mvPostItFlds.end() ; i++)
		{
			EndListening( *(const_cast<SfxBroadcaster*>((*i)->GetBroadCaster())) );
			if ((*i)->pPostIt)
				delete (*i)->pPostIt;
			delete (*i);
		}
		mvPostItFlds.clear();
	}

	// all postits removed, no items should be left in pages
	PreparePageContainer();
}

// copy to new vector, otherwise RemoveItem would operate and delete stuff on mvPostItFlds as well
// RemoveItem will clean up the core field and visible postit if neccessary
// we cannot just delete everything as before, as postits could move into change tracking
void SwPostItMgr::Delete(String aAuthor)
{
	mpWrtShell->StartAllAction();
    if ( HasActiveSidebarWin() && (GetActiveSidebarWin()->GetAuthor()==aAuthor) )
    {
        SetActiveSidebarWin(0);
    }
	SwRewriter aRewriter;
	String aUndoString = SW_RES(STR_DELETE_AUTHOR_NOTES);
	aUndoString += aAuthor;
	aRewriter.AddRule(UNDO_ARG1, aUndoString);
	mpWrtShell->StartUndo( UNDO_DELETE, &aRewriter );

	std::vector<const SwFmtFld*> aTmp;
    aTmp.reserve( mvPostItFlds.size() );
    for(std::list<SwSidebarItem*>::iterator pPostIt = mvPostItFlds.begin(); pPostIt!= mvPostItFlds.end() ; pPostIt++)
	{
		if ( (*pPostIt)->pPostIt->GetAuthor() == aAuthor )
			aTmp.push_back( &(*pPostIt)->GetFmtFld() );
	}
	for(std::vector<const SwFmtFld*>::iterator i = aTmp.begin(); i!= aTmp.end() ; i++)
	{
		mpWrtShell->GotoField( *(*i) );
		mpWrtShell->DelRight();
	}
    mpWrtShell->EndUndo();
	PrepareView();
	mpWrtShell->EndAllAction();
	mbLayout = true;
	CalcRects();
	LayoutPostIts();
}

void SwPostItMgr::Delete()
{
	mpWrtShell->StartAllAction();
    SetActiveSidebarWin(0);
	SwRewriter aRewriter;
	aRewriter.AddRule(UNDO_ARG1, SW_RES(STR_DELETE_ALL_NOTES) );
	mpWrtShell->StartUndo( UNDO_DELETE, &aRewriter );

    std::vector<const SwFmtFld*> aTmp;
    aTmp.reserve( mvPostItFlds.size() );
    for(std::list<SwSidebarItem*>::iterator pPostIt = mvPostItFlds.begin(); pPostIt!= mvPostItFlds.end() ; pPostIt++)
    {
        aTmp.push_back( &(*pPostIt)->GetFmtFld() );
    }
	for(std::vector<const SwFmtFld*>::iterator i = aTmp.begin(); i!= aTmp.end() ; i++)
	{
		mpWrtShell->GotoField( *(*i) );
		mpWrtShell->DelRight();
	}

/*
	for(std::list<SwPostItItem*>::iterator i = mvPostItFlds.begin(); i!= mvPostItFlds.end() ; i++)
	{
		SwPostItItem* pItem = (*i);
		// stop listening, we delete ourselves
		EndListening( *(pItem->pFmtFld) );
		// delete the actual SwPostItField
		mpWrtShell->GotoField(*pItem->pFmtFld);
		mpWrtShell->DelRight();
		// delete visual representation
		delete pItem->pPostIt;
		// delete struct saving the pointers
		delete pItem;
	}
	mvPostItFlds.clear();
*/

    mpWrtShell->EndUndo();
	PrepareView();
	mpWrtShell->EndAllAction();
	mbLayout = true;
	CalcRects();
	LayoutPostIts();
}
#if 0
void SwPostItMgr::Hide(SwPostItField* pPostItField )
{
    for(std::list<SwSidebarItem*>::iterator i = mvPostItFlds.begin(); i!= mvPostItFlds.end() ; i++)
	{
		if ((*i)->GetFmtFld())
		{
			SwPostItField* pField = static_cast<SwPostItField*>((*i)->GetFmtFld()->GetFld());
			if (pPostItField==pField)
			{
				(*i)->bShow = false;
				(*i)->pPostIt->HideNote();
				break;
			}
		}
	}

	LayoutPostIts();
}
#endif
void SwPostItMgr::Hide( const String& rAuthor )
{
    for(SwSidebarItem_iterator i = mvPostItFlds.begin(); i!= mvPostItFlds.end() ; i++)
	{
		if ( (*i)->pPostIt && ((*i)->pPostIt->GetAuthor() == rAuthor) )
		{
			(*i)->bShow	 = false;
			(*i)->pPostIt->HideNote();
		}
	}

	LayoutPostIts();
}

void SwPostItMgr::Hide()
{
    for(SwSidebarItem_iterator i = mvPostItFlds.begin(); i!= mvPostItFlds.end() ; i++)
	{
		(*i)->bShow = false;
		(*i)->pPostIt->HideNote();
	}
}


void SwPostItMgr::Show()
{
    for(SwSidebarItem_iterator i = mvPostItFlds.begin(); i!= mvPostItFlds.end() ; i++)
	{
		(*i)->bShow = true;
	}
	LayoutPostIts();
}

void SwPostItMgr::Sort(const short aType)
{
	if (mvPostItFlds.size()>1 )
	{
		switch (aType)
		{
			case SORT_POS:
				mvPostItFlds.sort(comp_pos);
				break;
			/*
			case SORT_AUTHOR:
				mvPostItFlds.sort(comp_author);
				break;
			case SORT_DATE:
				mvPostItFlds.sort(comp_date);
				break;
			*/
		}
	}
}

SwSidebarWin* SwPostItMgr::GetSidebarWin( const SfxBroadcaster* pBroadcaster) const
{
	for(const_iterator i = mvPostItFlds.begin(); i!= mvPostItFlds.end() ; i++)
	{
		if ( (*i)->GetBroadCaster() == pBroadcaster)
			return (*i)->pPostIt;
	}
	return NULL;
}

sw::annotation::SwAnnotationWin* SwPostItMgr::GetAnnotationWin(const SwPostItField* pFld) const
{
    for(const_iterator i = mvPostItFlds.begin(); i!= mvPostItFlds.end() ; i++)
    {
        if ( (*i)->GetFmtFld().GetField() == pFld )
            return dynamic_cast<sw::annotation::SwAnnotationWin*>((*i)->pPostIt);
    }
    return NULL;
}

SwSidebarWin* SwPostItMgr::GetNextPostIt( sal_uInt16 aDirection,
                                          SwSidebarWin* aPostIt )
{
	if (mvPostItFlds.size()>1)
	{
        for(SwSidebarItem_iterator i = mvPostItFlds.begin(); i!= mvPostItFlds.end() ; i++)
		{
			if ( (*i)->pPostIt ==aPostIt)
			{
                SwSidebarItem_iterator iNextPostIt  = i;
				if (aDirection==KEY_PAGEUP)
				{
					if ( iNextPostIt==mvPostItFlds.begin() )
					{
						return NULL;
					}
					--iNextPostIt;
				}
				else
				{
					iNextPostIt++;
					if ( iNextPostIt==mvPostItFlds.end() )
					{
						return NULL;
					}
				}
				// lets quit, we are back at the beginng
				if ( (*iNextPostIt)->pPostIt==aPostIt)
					return NULL;
				return (*iNextPostIt)->pPostIt;
			}
		}
		return NULL;
	}
	else
		return NULL;
}

long SwPostItMgr::GetNextBorder()
{
	for (unsigned long n=0;n<mPages.size();n++)
	{
        for(SwSidebarItem_iterator b = mPages[n]->mList->begin(); b!= mPages[n]->mList->end(); b++)
		{
			if ((*b)->pPostIt == mpActivePostIt)
			{
                SwSidebarItem_iterator aNext = b;
				aNext++;
				bool bFollow = (aNext == mPages[n]->mList->end()) ? false : (*aNext)->pPostIt->IsFollow();
				if ( mPages[n]->bScrollbar || bFollow )
				{
					return -1;
				}
				else
				{
					//if this is the last item, return the bottom border otherwise the next item
					if (aNext == mPages[n]->mList->end())
						return mpEditWin->LogicToPixel(Point(0,mPages[n]->mPageRect.Bottom())).Y() - GetSpaceBetween();
					else
						return (*aNext)->pPostIt->GetPosPixel().Y() - GetSpaceBetween();
				}
			}
		}
	}

	DBG_ERROR("SwPostItMgr::GetNextBorder(): We have to find a next border here");
	return -1;
}

void SwPostItMgr::SetShadowState(const SwPostItField* pFld,bool bCursor)
{
	if (pFld)
	{
		if (pFld !=mShadowState.mpShadowFld)
		{
			if (mShadowState.mpShadowFld)
			{
				// reset old one if still alive
				// TODO: does not work properly if mouse and cursor was set
                sw::annotation::SwAnnotationWin* pOldPostIt =
                                    GetAnnotationWin(mShadowState.mpShadowFld);
				if (pOldPostIt && pOldPostIt->Shadow() && (pOldPostIt->Shadow()->GetShadowState() != SS_EDIT))
                    pOldPostIt->SetViewState(VS_NORMAL);
			}
			//set new one, if it is not currently edited
            sw::annotation::SwAnnotationWin* pNewPostIt = GetAnnotationWin(pFld);
			if (pNewPostIt && pNewPostIt->Shadow() && (pNewPostIt->Shadow()->GetShadowState() != SS_EDIT))
			{
                pNewPostIt->SetViewState(VS_VIEW);
				//remember our new field
				mShadowState.mpShadowFld = pFld;
				mShadowState.bCursor = false;
				mShadowState.bMouse = false;
			}
		}
		if (bCursor)
			mShadowState.bCursor = true;
		else
			mShadowState.bMouse = true;
	}
	else
	{
		if (mShadowState.mpShadowFld)
		{
			if (bCursor)
				mShadowState.bCursor = false;
			else
				mShadowState.bMouse = false;
			if (!mShadowState.bCursor && !mShadowState.bMouse)
			{
				// reset old one if still alive
                sw::annotation::SwAnnotationWin* pOldPostIt = GetAnnotationWin(mShadowState.mpShadowFld);
				if (pOldPostIt && pOldPostIt->Shadow() && (pOldPostIt->Shadow()->GetShadowState() != SS_EDIT))
				{
                    pOldPostIt->SetViewState(VS_NORMAL);
					mShadowState.mpShadowFld = 0;
				}
			}
		}
	}
}

void SwPostItMgr::PrepareView(bool bIgnoreCount)
{
	if (!HasNotes() || bIgnoreCount)
	{
		mpWrtShell->StartAllAction();
		//mpEditWin->Invalidate(); // really not needed anymore??
		SwRootFrm* pLayout = mpWrtShell->GetLayout();
        if ( pLayout )
            SwPostItHelper::setSidebarChanged( pLayout,
                mpWrtShell->getIDocumentSettingAccess()->get( IDocumentSettingAccess::BROWSE_MODE ) );
		mpWrtShell->EndAllAction();
	}
}

bool SwPostItMgr::ShowScrollbar(const unsigned long aPage) const
{
	if (mPages.size() > aPage-1)
		return (mPages[aPage-1]->bScrollbar && !mbWaitingForCalcRects);
	else
		return false;
}

bool SwPostItMgr::IsHit(const Point &aPointPixel)
{
	if (HasNotes() && ShowNotes())
	{
		const Point aPoint = mpEditWin->PixelToLogic(aPointPixel);
        const SwRootFrm* pLayout = mpWrtShell->GetLayout();
        SwRect aPageFrm;
		const unsigned long nPageNum = SwPostItHelper::getPageInfo( aPageFrm, pLayout, aPoint );
	    if( nPageNum )
		{
			Rectangle aRect;
			DBG_ASSERT(mPages.size()>nPageNum-1,"SwPostitMgr:: page container size wrong");
            aRect = mPages[nPageNum-1]->eSidebarPosition == sw::sidebarwindows::SIDEBAR_LEFT
                    ? Rectangle(Point(aPageFrm.Left()-GetSidebarWidth()-GetSidebarBorderWidth(),aPageFrm.Top()),Size(GetSidebarWidth(),aPageFrm.Height()))
                    : Rectangle( Point(aPageFrm.Right()+GetSidebarBorderWidth(),aPageFrm.Top()) , Size(GetSidebarWidth(),aPageFrm.Height()));
			if (aRect.IsInside(aPoint))
			{
				// we hit the note's sidebar
				// lets now test for the arrow area
				if (mPages[nPageNum-1]->bScrollbar)
					return ScrollbarHit(nPageNum,aPoint);
				else
					return false;
			}
		}
	}
	return false;
}
Rectangle SwPostItMgr::GetBottomScrollRect(const unsigned long aPage) const
{
	SwRect aPageRect = mPages[aPage-1]->mPageRect;
    Point aPointBottom = mPages[aPage-1]->eSidebarPosition == sw::sidebarwindows::SIDEBAR_LEFT
                         ? Point(aPageRect.Left() - GetSidebarWidth() - GetSidebarBorderWidth() + mpEditWin->PixelToLogic(Size(2,0)).Width(),aPageRect.Bottom()- mpEditWin->PixelToLogic(Size(0,2+GetSidebarScrollerHeight())).Height())
                         : Point(aPageRect.Right() + GetSidebarBorderWidth() + mpEditWin->PixelToLogic(Size(2,0)).Width(),aPageRect.Bottom()- mpEditWin->PixelToLogic(Size(0,2+GetSidebarScrollerHeight())).Height());
	Size aSize(GetSidebarWidth() - mpEditWin->PixelToLogic(Size(4,0)).Width(), mpEditWin->PixelToLogic(Size(0,GetSidebarScrollerHeight())).Height()) ;
	return Rectangle(aPointBottom,aSize);

}

Rectangle SwPostItMgr::GetTopScrollRect(const unsigned long aPage) const
{
	SwRect aPageRect = mPages[aPage-1]->mPageRect;
    Point aPointTop = mPages[aPage-1]->eSidebarPosition == sw::sidebarwindows::SIDEBAR_LEFT
                      ? Point(aPageRect.Left() - GetSidebarWidth() -GetSidebarBorderWidth()+ mpEditWin->PixelToLogic(Size(2,0)).Width(),aPageRect.Top() + mpEditWin->PixelToLogic(Size(0,2)).Height())
                      : Point(aPageRect.Right() + GetSidebarBorderWidth() + mpEditWin->PixelToLogic(Size(2,0)).Width(),aPageRect.Top() + mpEditWin->PixelToLogic(Size(0,2)).Height());
	Size aSize(GetSidebarWidth() - mpEditWin->PixelToLogic(Size(4,0)).Width(), mpEditWin->PixelToLogic(Size(0,GetSidebarScrollerHeight())).Height()) ;
	return Rectangle(aPointTop,aSize);
}


//IMPORTANT: if you change the rects here, also change SwPageFrm::PaintNotesSidebar()
bool SwPostItMgr::ScrollbarHit(const unsigned long aPage,const Point &aPoint)
{
	SwRect aPageRect = mPages[aPage-1]->mPageRect;
    Point aPointBottom = mPages[aPage-1]->eSidebarPosition == sw::sidebarwindows::SIDEBAR_LEFT
                         ? Point(aPageRect.Left() - GetSidebarWidth()-GetSidebarBorderWidth() + mpEditWin->PixelToLogic(Size(2,0)).Width(),aPageRect.Bottom()- mpEditWin->PixelToLogic(Size(0,2+GetSidebarScrollerHeight())).Height())
                         : Point(aPageRect.Right() + GetSidebarBorderWidth()+ mpEditWin->PixelToLogic(Size(2,0)).Width(),aPageRect.Bottom()- mpEditWin->PixelToLogic(Size(0,2+GetSidebarScrollerHeight())).Height());

    Point aPointTop = mPages[aPage-1]->eSidebarPosition == sw::sidebarwindows::SIDEBAR_LEFT
                      ? Point(aPageRect.Left() - GetSidebarWidth()-GetSidebarBorderWidth()+ mpEditWin->PixelToLogic(Size(2,0)).Width(),aPageRect.Top() + mpEditWin->PixelToLogic(Size(0,2)).Height())
                      : Point(aPageRect.Right()+GetSidebarBorderWidth()+ mpEditWin->PixelToLogic(Size(2,0)).Width(),aPageRect.Top() + mpEditWin->PixelToLogic(Size(0,2)).Height());

	Rectangle aRectBottom(GetBottomScrollRect(aPage));
	Rectangle aRectTop(GetTopScrollRect(aPage));

	if (aRectBottom.IsInside(aPoint))
	{
		if (aPoint.X() < long((aPointBottom.X() + GetSidebarWidth()/3)))
			Scroll( GetScrollSize(),aPage);
		else
			Scroll( -1*GetScrollSize(), aPage);
		return true;
	}
	else
	if (aRectTop.IsInside(aPoint))
	{
		if (aPoint.X() < long((aPointTop.X() + GetSidebarWidth()/3*2)))
			Scroll(GetScrollSize(), aPage);
		else
			Scroll(-1*GetScrollSize(), aPage);
		return true;
	}
	return false;
}

void SwPostItMgr::CorrectPositions()
{
   if ( mbWaitingForCalcRects || mbLayouting || mvPostItFlds.empty() )
       return;

   // find first valid note
   SwSidebarWin *pFirstPostIt = 0;
   for(SwSidebarItem_iterator i = mvPostItFlds.begin(); i!= mvPostItFlds.end() ; i++)
   {
       pFirstPostIt = (*i)->pPostIt;
       if (pFirstPostIt)
           break;
   }

   //if we have not found a valid note, forget about it and leave
   if (!pFirstPostIt)
       return;

    // yeah, I know,    if this is a left page it could be wrong, but finding the page and the note is probably not even faster than just doing it
    // --> OD 2010-06-03 #i111964# - check, if anchor overlay object exists.
    const long aAnchorX = pFirstPostIt->Anchor()
                          ? mpEditWin->LogicToPixel( Point((long)(pFirstPostIt->Anchor()->GetSixthPosition().getX()),0)).X()
                          : 0;
    const long aAnchorY = pFirstPostIt->Anchor()
                          ? mpEditWin->LogicToPixel( Point(0,(long)(pFirstPostIt->Anchor()->GetSixthPosition().getY()))).Y() + 1
                          : 0;
    // <--
    if (Point(aAnchorX,aAnchorY) != pFirstPostIt->GetPosPixel())
    {
        long aAnchorPosX = 0;
        long aAnchorPosY = 0;
        for (unsigned long n=0;n<mPages.size();n++)
        {
            for(SwSidebarItem_iterator i = mPages[n]->mList->begin(); i!= mPages[n]->mList->end(); i++)
            {
                if ( (*i)->bShow && (*i)->pPostIt && (*i)->pPostIt->Anchor() )
                {
                    aAnchorPosX = mPages[n]->eSidebarPosition == sw::sidebarwindows::SIDEBAR_LEFT
                        ? mpEditWin->LogicToPixel( Point((long)((*i)->pPostIt->Anchor()->GetSeventhPosition().getX()),0)).X()
                        : mpEditWin->LogicToPixel( Point((long)((*i)->pPostIt->Anchor()->GetSixthPosition().getX()),0)).X();
                    aAnchorPosY = mpEditWin->LogicToPixel( Point(0,(long)((*i)->pPostIt->Anchor()->GetSixthPosition().getY()))).Y() + 1;
                    (*i)->pPostIt->SetPosPixel(Point(aAnchorPosX,aAnchorPosY));
                }
            }
        }
    }
}


bool SwPostItMgr::ShowNotes() const
{
	// we only want to see notes if Options - Writer - View - Notes is ticked
	return mpWrtShell->GetViewOptions()->IsPostIts();
}

bool SwPostItMgr::HasNotes() const
{
	return !mvPostItFlds.empty();
}

unsigned long SwPostItMgr::GetSidebarWidth(bool bPx) const
{
	unsigned long aWidth = (unsigned long)(mpWrtShell->GetViewOptions()->GetZoom() * 1.8);
	if (bPx)
		return aWidth;
	else
		return mpEditWin->PixelToLogic(Size( aWidth ,0)).Width();
}

unsigned long SwPostItMgr::GetSidebarBorderWidth(bool bPx) const
{
	if (bPx)
		return 2;
	else
		return mpEditWin->PixelToLogic(Size(2,0)).Width();
}

unsigned long SwPostItMgr::GetNoteWidth()
{
	return GetSidebarWidth(true);
}

Color SwPostItMgr::GetColorDark(sal_uInt16 aAuthorIndex)
{
	if (!Application::GetSettings().GetStyleSettings().GetHighContrastMode())
	{
		static const Color aArrayNormal[] = {
			COL_AUTHOR1_NORMAL,		COL_AUTHOR2_NORMAL,		COL_AUTHOR3_NORMAL,
			COL_AUTHOR4_NORMAL,		COL_AUTHOR5_NORMAL,		COL_AUTHOR6_NORMAL,
			COL_AUTHOR7_NORMAL,		COL_AUTHOR8_NORMAL,		COL_AUTHOR9_NORMAL };

		return Color( aArrayNormal[ aAuthorIndex % (sizeof( aArrayNormal )/ sizeof( aArrayNormal[0] ))]);
	}
	else
		return Color(COL_WHITE);
}

Color SwPostItMgr::GetColorLight(sal_uInt16 aAuthorIndex)
{
	if (!Application::GetSettings().GetStyleSettings().GetHighContrastMode())
	{
		static const Color aArrayLight[] = {
			COL_AUTHOR1_LIGHT,		COL_AUTHOR2_LIGHT,		COL_AUTHOR3_LIGHT,
			COL_AUTHOR4_LIGHT,		COL_AUTHOR5_LIGHT,		COL_AUTHOR6_LIGHT,
			COL_AUTHOR7_LIGHT,		COL_AUTHOR8_LIGHT,		COL_AUTHOR9_LIGHT };

		return Color( aArrayLight[ aAuthorIndex % (sizeof( aArrayLight )/ sizeof( aArrayLight[0] ))]);
	}
	else
		return Color(COL_WHITE);
}

Color SwPostItMgr::GetColorAnchor(sal_uInt16 aAuthorIndex)
{
	if (!Application::GetSettings().GetStyleSettings().GetHighContrastMode())
	{
        static const Color aArrayAnchor[] = {
			COL_AUTHOR1_DARK,		COL_AUTHOR2_DARK,		COL_AUTHOR3_DARK,
			COL_AUTHOR4_DARK,		COL_AUTHOR5_DARK,		COL_AUTHOR6_DARK,
			COL_AUTHOR7_DARK,		COL_AUTHOR8_DARK,		COL_AUTHOR9_DARK };

        return Color( aArrayAnchor[  aAuthorIndex % (sizeof( aArrayAnchor )  / sizeof( aArrayAnchor[0] ))]);
	}
	else
		return Color(COL_WHITE);
}

void SwPostItMgr::SetActiveSidebarWin( SwSidebarWin* p)
{
	if ( p != mpActivePostIt )
	{
		// we need the temp variable so we can set mpActivePostIt before we call DeactivatePostIt
		// therefore we get a new layout in DOCCHANGED when switching from postit to document,
		// otherwise, GetActivePostIt() would still hold our old postit
        SwSidebarWin* pActive = mpActivePostIt;
		mpActivePostIt = p;
		if (pActive)
		{
			pActive->DeactivatePostIt();
			mShadowState.mpShadowFld = 0;
		}
		if (mpActivePostIt)
		{
			mpActivePostIt->GotoPos();
			mpView->AttrChangedNotify(0);
			mpActivePostIt->ActivatePostIt();
		}
	}
}

IMPL_LINK( SwPostItMgr, CalcHdl, void*, /* pVoid*/  )
{
	mnEventId = 0;
	if ( mbLayouting )
	{
		DBG_ERROR("Reentrance problem in Layout Manager!");
		mbWaitingForCalcRects = false;
		return 0;
	}

	// do not change order, even if it would seem so in the first place, we need the calcrects always
	if (CalcRects() || mbLayout)
	{
		mbLayout = false;
		LayoutPostIts();
	}
	return 0;
}

void SwPostItMgr::Rescale()
{
    for(std::list<SwSidebarItem*>::iterator i = mvPostItFlds.begin(); i!= mvPostItFlds.end() ; i++)
		if ( (*i)->pPostIt )
			(*i)->pPostIt->Rescale();
}

sal_Int32 SwPostItMgr::GetInitialAnchorDistance() const
{
	const Fraction& f( mpEditWin->GetMapMode().GetScaleY() );
    return POSTIT_INITIAL_ANCHOR_DISTANCE * f.GetNumerator() / f.GetDenominator();
}

sal_Int32 SwPostItMgr::GetSpaceBetween() const
{
	const Fraction& f( mpEditWin->GetMapMode().GetScaleY() );
	return ( POSTIT_SPACE_BETWEEN ) * f.GetNumerator() / f.GetDenominator();
}

sal_Int32 SwPostItMgr::GetScrollSize() const
{
	const Fraction& f( mpEditWin->GetMapMode().GetScaleY() );
	return ( POSTIT_SPACE_BETWEEN + POSTIT_MINIMUMSIZE_WITH_META ) * f.GetNumerator() / f.GetDenominator();
}

sal_Int32 SwPostItMgr::GetMinimumSizeWithMeta() const
{
	const Fraction& f( mpEditWin->GetMapMode().GetScaleY() );
	return POSTIT_MINIMUMSIZE_WITH_META * f.GetNumerator() / f.GetDenominator();
}

sal_Int32 SwPostItMgr::GetSidebarScrollerHeight() const
{
	const Fraction& f( mpEditWin->GetMapMode().GetScaleY() );
	return POSTIT_SCROLL_SIDEBAR_HEIGHT * f.GetNumerator() / f.GetDenominator();
}

void SwPostItMgr::SetSpellChecking()
{
    for(std::list<SwSidebarItem*>::iterator i = mvPostItFlds.begin(); i!= mvPostItFlds.end() ; i++)
		if ( (*i)->pPostIt )
			(*i)->pPostIt->SetSpellChecking();
}

void SwPostItMgr::SetReadOnlyState()
{
    for(std::list<SwSidebarItem*>::iterator i = mvPostItFlds.begin(); i!= mvPostItFlds.end() ; i++)
		if ( (*i)->pPostIt )
			(*i)->pPostIt->SetReadonly( mbReadOnly );
}

void SwPostItMgr::CheckMetaText()
{
        for(std::list<SwSidebarItem*>::iterator i = mvPostItFlds.begin(); i!= mvPostItFlds.end() ; i++)
                if ( (*i)->pPostIt )
                       (*i)->pPostIt->CheckMetaText();

}

sal_uInt16 SwPostItMgr::Replace(SvxSearchItem* pItem)
{
    SwSidebarWin* pWin = GetActiveSidebarWin();
    sal_uInt16 aResult = pWin->GetOutlinerView()->StartSearchAndReplace( *pItem );
	if (!aResult)
        SetActiveSidebarWin(0);
	return aResult;
}

sal_uInt16 SwPostItMgr::FinishSearchReplace(const ::com::sun::star::util::SearchOptions& rSearchOptions, bool bSrchForward)
{
    SwSidebarWin* pWin = GetActiveSidebarWin();
	SvxSearchItem aItem(SID_SEARCH_ITEM );
	aItem.SetSearchOptions(rSearchOptions);
	aItem.SetBackward(!bSrchForward);
    sal_uInt16 aResult = pWin->GetOutlinerView()->StartSearchAndReplace( aItem );
	if (!aResult)
        SetActiveSidebarWin(0);
	return aResult;
}

sal_uInt16 SwPostItMgr::SearchReplace(const SwFmtFld &pFld, const ::com::sun::star::util::SearchOptions& rSearchOptions, bool bSrchForward)
{
	sal_uInt16 aResult = 0;
    SwSidebarWin* pWin = GetSidebarWin(&pFld);
	if (pWin)
	{
        ESelection aOldSelection = pWin->GetOutlinerView()->GetSelection();
		if (bSrchForward)
            pWin->GetOutlinerView()->SetSelection(ESelection(0,0,0,0));
		else
            pWin->GetOutlinerView()->SetSelection(ESelection(0xFFFF,0xFFFF,0xFFFF,0xFFFF));
		SvxSearchItem aItem(SID_SEARCH_ITEM );
		aItem.SetSearchOptions(rSearchOptions);
		aItem.SetBackward(!bSrchForward);
        aResult = pWin->GetOutlinerView()->StartSearchAndReplace( aItem );
		if (!aResult)
            pWin->GetOutlinerView()->SetSelection(aOldSelection);
		else
		{
            SetActiveSidebarWin(pWin);
			MakeVisible(pWin);
		}
	}
	return aResult;
}

void SwPostItMgr::AssureStdModeAtShell()
{
	//#i103373# #i103645#
        // deselect any drawing or frame and leave editing mode
      	SdrView* pSdrView = mpWrtShell->GetDrawView();
        if ( pSdrView && pSdrView->IsTextEdit() )
        {
        	sal_Bool bLockView = mpWrtShell->IsViewLocked();
       		mpWrtShell->LockView( sal_True );
        	mpWrtShell->EndTextEdit();
                mpWrtShell->LockView( bLockView );
    	}

        if( mpWrtShell->IsSelFrmMode() || mpWrtShell->IsObjSelected())
        {
                mpWrtShell->UnSelectFrm();
                mpWrtShell->LeaveSelFrmMode();
                mpWrtShell->GetView().LeaveDrawCreate();
                mpWrtShell->EnterStdMode();

                mpWrtShell->DrawSelChanged();
                mpView->StopShellTimer();
        }
}

bool SwPostItMgr::HasActiveSidebarWin() const
{
    return mpActivePostIt != 0;
}

bool SwPostItMgr::HasActiveAnnotationWin() const
{
    return HasActiveSidebarWin() &&
           dynamic_cast<sw::annotation::SwAnnotationWin*>(mpActivePostIt) != 0;
}

void SwPostItMgr::GrabFocusOnActiveSidebarWin()
{
    if ( HasActiveSidebarWin() )
    {
        mpActivePostIt->GrabFocus();
    }
}

void SwPostItMgr::UpdateDataOnActiveSidebarWin()
{
    if ( HasActiveSidebarWin() )
    {
        mpActivePostIt->UpdateData();
    }
}

void SwPostItMgr::DeleteActiveSidebarWin()
{
    if ( HasActiveSidebarWin() )
    {
        mpActivePostIt->Delete();
    }
}

void SwPostItMgr::HideActiveSidebarWin()
{
    if ( HasActiveSidebarWin() )
    {
        mpActivePostIt->Hide();
    }
}

void SwPostItMgr::ToggleInsModeOnActiveSidebarWin()
{
    if ( HasActiveSidebarWin() )
    {
        mpActivePostIt->ToggleInsMode();
    }
}

void SwPostItMgr::ConnectSidebarWinToFrm( const SwFrm& rFrm,
                                          const SwFmtFld& rFmtFld,
                                          SwSidebarWin& rSidebarWin )
{
    if ( mpFrmSidebarWinContainer == 0 )
    {
        mpFrmSidebarWinContainer = new SwFrmSidebarWinContainer();
    }

    const bool bInserted = mpFrmSidebarWinContainer->insert( rFrm, rFmtFld, rSidebarWin );
    if ( bInserted &&
         mpWrtShell->GetAccessibleMap() )
    {
        mpWrtShell->GetAccessibleMap()->InvalidatePosOrSize( 0, 0, &rSidebarWin, SwRect() );
    }
}

void SwPostItMgr::DisconnectSidebarWinFromFrm( const SwFrm& rFrm,
                                               SwSidebarWin& rSidebarWin )
{
    if ( mpFrmSidebarWinContainer != 0 )
    {
        const bool bRemoved = mpFrmSidebarWinContainer->remove( rFrm, rSidebarWin );
        if ( bRemoved &&
             mpWrtShell->GetAccessibleMap() )
        {
            mpWrtShell->GetAccessibleMap()->Dispose( 0, 0, &rSidebarWin );
        }
    }
}

bool SwPostItMgr::HasFrmConnectedSidebarWins( const SwFrm& rFrm )
{
    bool bRet( false );

    if ( mpFrmSidebarWinContainer != 0 )
    {
        bRet = !mpFrmSidebarWinContainer->empty( rFrm );
    }

    return bRet;
}

Window* SwPostItMgr::GetSidebarWinForFrmByIndex( const SwFrm& rFrm,
                                                 const sal_Int32 nIndex )
{
    Window* pSidebarWin( 0 );

    if ( mpFrmSidebarWinContainer != 0 )
    {
        pSidebarWin = mpFrmSidebarWinContainer->get( rFrm, nIndex );
    }

    return pSidebarWin;
}

void SwPostItMgr::GetAllSidebarWinForFrm( const SwFrm& rFrm,
                                          std::vector< Window* >* pChildren )
{
    if ( mpFrmSidebarWinContainer != 0 )
    {
        mpFrmSidebarWinContainer->getAll( rFrm, pChildren );
    }
}

void SwNoteProps::Commit() {}
void SwNoteProps::Notify( const ::com::sun::star::uno::Sequence< rtl::OUString >& ) {}