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

#include "ViewShellImplementation.hxx"

#include "sdpage.hxx"
#include "drawdoc.hxx"
#include "sdresid.hxx"
#include "glob.hrc"
#include "app.hrc"
#include "strings.hrc"
#include "strings.hrc"
#include "helpids.h"
#include "sdattr.hxx"
#include "sdabstdlg.hxx"
#include "unmodpg.hxx"
#include "Window.hxx"
#include "optsitem.hxx"
#include "DrawDocShell.hxx"
#include "DrawController.hxx"
#include "FactoryIds.hxx"
#include "slideshow.hxx"
#include "ViewShellBase.hxx"
#include "FrameView.hxx"
#include "DrawViewShell.hxx"
#include "ViewShellHint.hxx"
#include "SidebarPanelId.hxx"
#include "framework/FrameworkHelper.hxx"

#include <sfx2/bindings.hxx>
#include <sfx2/dispatch.hxx>
#include <sfx2/request.hxx>
#include <sfx2/sidebar/Sidebar.hxx>
#include <svl/aeitem.hxx>
#include <svx/imapdlg.hxx>
#include <vcl/msgbox.hxx>
#include <basic/sbstar.hxx>
#include "undo/undoobjects.hxx"

#include <com/sun/star/drawing/framework/XControllerManager.hpp>

using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::drawing::framework;
using ::sd::framework::FrameworkHelper;

namespace sd {

ViewShell::Implementation::Implementation (ViewShell& rViewShell)
	: mbIsShowingUIControls(false),
	  mbIsMainViewShell(false),
	  mbIsInitialized(false),
	  mbArrangeActive(false),
	  mpSubShellFactory(),
	  mpUpdateLockForMouse(),
	  mrViewShell(rViewShell)
{
}


ViewShell::Implementation::~Implementation (void)
{
	if ( ! mpUpdateLockForMouse.expired())
	{
		::boost::shared_ptr<ToolBarManagerLock> pLock(mpUpdateLockForMouse);
		if (pLock.get() != NULL)
		{
			// Force the ToolBarManagerLock to be released even when the
			// IsUICaptured() returns <TRUE/>.
			pLock->Release(true);
		}
	}
}


void ViewShell::Implementation::ProcessModifyPageSlot (
	SfxRequest& rRequest,
	SdPage* pCurrentPage,
	PageKind ePageKind)
{
	SdDrawDocument* pDocument = mrViewShell.GetDoc();
	SdrLayerAdmin& rLayerAdmin = pDocument->GetLayerAdmin();
	sal_uInt8 aBckgrnd = rLayerAdmin.GetLayerID(String(SdResId(STR_LAYER_BCKGRND)), sal_False);
	sal_uInt8 aBckgrndObj = rLayerAdmin.GetLayerID(String(SdResId(STR_LAYER_BCKGRNDOBJ)), sal_False);
	SetOfByte aVisibleLayers;
	sal_Bool bHandoutMode = sal_False;
	SdPage* pHandoutMPage = NULL;
	String aNewName;

	// #95981#
	String aOldName;

	AutoLayout aNewAutoLayout;

	sal_Bool bBVisible;
	sal_Bool bBObjsVisible;
	const SfxItemSet* pArgs = rRequest.GetArgs();

	if (pCurrentPage != NULL && pCurrentPage->TRG_HasMasterPage())
		aVisibleLayers = pCurrentPage->TRG_GetMasterPageVisibleLayers();
	else
		aVisibleLayers.SetAll();

	do
	{
		if (pCurrentPage == NULL)
			break;

		if (!pArgs || pArgs->Count() == 1 || pArgs->Count() == 2 )
		{
			if (pArgs && pArgs->Count() == 2)
			{
				// We have been called with a request that contains two
				// arguments. One was used as preselected layout in a
				// dialog. We could select that layout in the
				// layout panel instead.
				/*
					SFX_REQUEST_ARG (rRequest, pNewAutoLayout, SfxUInt32Item, ID_VAL_WHATLAYOUT, sal_False);
					eNewAutoLayout = (AutoLayout) pNewAutoLayout->GetValue
					();
				*/
			}

			// Make the layout menu visible in the tool pane.
			sfx2::sidebar::Sidebar::ShowPanel(
				rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ImpressLayoutsPanel")),
				mrViewShell.GetViewFrame()->GetFrame().GetFrameInterface());
			break;
		}
		else if (pArgs->Count() == 4)
		{
			SFX_REQUEST_ARG (rRequest, pNewName, SfxStringItem, ID_VAL_PAGENAME, sal_False);
			SFX_REQUEST_ARG (rRequest, pNewAutoLayout, SfxUInt32Item, ID_VAL_WHATLAYOUT, sal_False);
			SFX_REQUEST_ARG (rRequest, pBVisible, SfxBoolItem, ID_VAL_ISPAGEBACK, sal_False);
			SFX_REQUEST_ARG (rRequest, pBObjsVisible, SfxBoolItem, ID_VAL_ISPAGEOBJ, sal_False);
			AutoLayout aLayout ((AutoLayout)pNewAutoLayout->GetValue ());
			if (aLayout >= AUTOLAYOUT__START
				&& aLayout < AUTOLAYOUT__END)
			{
				aNewName		= pNewName->GetValue ();
				aNewAutoLayout	= (AutoLayout) pNewAutoLayout->GetValue ();
				bBVisible		= pBVisible->GetValue ();
				bBObjsVisible	= pBObjsVisible->GetValue ();
			}
			else
			{
				StarBASIC::FatalError (SbERR_BAD_PROP_VALUE);
				rRequest.Ignore ();
				break;
			}
			if (ePageKind == PK_HANDOUT)
			{
				bHandoutMode = sal_True;
				pHandoutMPage = pDocument->GetMasterSdPage(0, PK_HANDOUT);
			}
		}
		else
		{
			StarBASIC::FatalError (SbERR_WRONG_ARGS);
			rRequest.Ignore ();
			break;
		}

		SdPage* pUndoPage =
			bHandoutMode ? pHandoutMPage : pCurrentPage;

		::svl::IUndoManager* pUndoManager = mrViewShell.GetDocSh()->GetUndoManager();
		DBG_ASSERT(pUndoManager, "No UNDO MANAGER ?!?");

		if( pUndoManager )
		{
			String aComment( SdResId(STR_UNDO_MODIFY_PAGE) );
			pUndoManager->EnterListAction(aComment, aComment);
			ModifyPageUndoAction* pAction = new ModifyPageUndoAction(
				pDocument, pUndoPage, aNewName, aNewAutoLayout, bBVisible, bBObjsVisible);
			pUndoManager->AddUndoAction(pAction);

			// Clear the selection because the selected object may be removed as
			// a result of the assignment of the layout.
			mrViewShell.GetDrawView()->UnmarkAll();

			if (!bHandoutMode)
			{
				if (pCurrentPage->GetName() != aNewName)
				{
					pCurrentPage->SetName(aNewName);

					if (ePageKind == PK_STANDARD)
					{
						sal_uInt16 nPage = (pCurrentPage->GetPageNum()-1) / 2;
						SdPage* pNotesPage = pDocument->GetSdPage(nPage, PK_NOTES);
						if (pNotesPage != NULL)
							pNotesPage->SetName(aNewName);
					}
				}

				pCurrentPage->SetAutoLayout(aNewAutoLayout, sal_True);

				aBckgrnd = rLayerAdmin.GetLayerID(String(SdResId(STR_LAYER_BCKGRND)), sal_False);
				aBckgrndObj = rLayerAdmin.GetLayerID(String(SdResId(STR_LAYER_BCKGRNDOBJ)), sal_False);
				aVisibleLayers.Set(aBckgrnd, bBVisible);
				aVisibleLayers.Set(aBckgrndObj, bBObjsVisible);
				pCurrentPage->TRG_SetMasterPageVisibleLayers(aVisibleLayers);
			}
			else
			{
				pHandoutMPage->SetAutoLayout(aNewAutoLayout, sal_True);
			}

			mrViewShell.GetViewFrame()->GetDispatcher()->Execute(SID_SWITCHPAGE,
				SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD);

			sal_Bool bSetModified = sal_True;

			if (pArgs && pArgs->Count() == 1)
			{
				bSetModified = (sal_Bool) ((SfxBoolItem&) pArgs->Get(SID_MODIFYPAGE)).GetValue();
			}

			pUndoManager->AddUndoAction( new UndoAutoLayoutPosAndSize( *pUndoPage ) );
			pUndoManager->LeaveListAction();

			pDocument->SetChanged(bSetModified);
		}
	}
	while (false);

	mrViewShell.Cancel();
	rRequest.Done ();
}

void ViewShell::Implementation::AssignLayout ( SfxRequest& rRequest, PageKind ePageKind )
{
	const SfxUInt32Item* pWhatPage = static_cast< const SfxUInt32Item* > ( rRequest.GetArg( ID_VAL_WHATPAGE, sal_False, TYPE(SfxUInt32Item) ) );
	const SfxUInt32Item* pWhatLayout = static_cast< const SfxUInt32Item* > ( rRequest.GetArg( ID_VAL_WHATLAYOUT, sal_False, TYPE(SfxUInt32Item) ) );

	SdDrawDocument* pDocument = mrViewShell.GetDoc();
	if( !pDocument )
		return;

	SdPage* pPage = 0;
	if( pWhatPage )
	{
		pPage = pDocument->GetSdPage(static_cast<sal_uInt16>(pWhatPage->GetValue()), ePageKind);
	}

	if( pPage == 0 )
		pPage = mrViewShell.getCurrentPage();

	if( pPage )
	{
		AutoLayout eLayout = pPage->GetAutoLayout();

		if( pWhatLayout )
			eLayout = static_cast< AutoLayout >( pWhatLayout->GetValue() );

		// Transform the given request into the four argument form that is
		// understood by ProcessModifyPageSlot().
		SdrLayerAdmin& rLayerAdmin (mrViewShell.GetViewShellBase().GetDocument()->GetLayerAdmin());
		sal_uInt8 aBackground (rLayerAdmin.GetLayerID(String(SdResId(STR_LAYER_BCKGRND)), sal_False));
		sal_uInt8 aBackgroundObject (rLayerAdmin.GetLayerID(String(SdResId(STR_LAYER_BCKGRNDOBJ)), sal_False));

		SetOfByte aVisibleLayers;

		if( pPage->GetPageKind() == PK_HANDOUT )
			aVisibleLayers.SetAll();
		else
			aVisibleLayers = pPage->TRG_GetMasterPageVisibleLayers();

		SfxRequest aRequest (mrViewShell.GetViewShellBase().GetViewFrame(), SID_MODIFYPAGE);
		aRequest.AppendItem(SfxStringItem (ID_VAL_PAGENAME, pPage->GetName()));
		aRequest.AppendItem(SfxUInt32Item (ID_VAL_WHATLAYOUT, eLayout));
		aRequest.AppendItem(SfxBoolItem(ID_VAL_ISPAGEBACK, aVisibleLayers.IsSet(aBackground)));
		aRequest.AppendItem(SfxBoolItem(ID_VAL_ISPAGEOBJ, aVisibleLayers.IsSet(aBackgroundObject)));

		// Forward the call with the new arguments.
		ProcessModifyPageSlot( aRequest, pPage, pPage->GetPageKind());
	}
}


sal_uInt16 ViewShell::Implementation::GetViewId (void)
{
	switch (mrViewShell.GetShellType())
	{
		case ViewShell::ST_IMPRESS:
		case ViewShell::ST_NOTES:
		case ViewShell::ST_HANDOUT:
			return IMPRESS_FACTORY_ID;

		case ViewShell::ST_DRAW:
			return DRAW_FACTORY_ID;

		case ViewShell::ST_OUTLINE:
			return OUTLINE_FACTORY_ID;

		case ViewShell::ST_SLIDE_SORTER:
			return SLIDE_SORTER_FACTORY_ID;

		case ViewShell::ST_PRESENTATION:
			return PRESENTATION_FACTORY_ID;

		// Since we have to return a view id for every possible shell type
		// and there is not (yet) a proper ViewShellBase sub class for the
		// remaining types we chose the Impress factory as a fall back.
		case ViewShell::ST_SIDEBAR:
		case ViewShell::ST_NONE:
		default:
			return IMPRESS_FACTORY_ID;
	}
}


SvxIMapDlg* ViewShell::Implementation::GetImageMapDialog (void)
{
	SvxIMapDlg* pDialog = NULL;
	SfxChildWindow* pChildWindow = SfxViewFrame::Current()->GetChildWindow(
		SvxIMapDlgChildWindow::GetChildWindowId());
	if (pChildWindow != NULL)
		pDialog = dynamic_cast<SvxIMapDlg*>(pChildWindow->GetWindow());
	return pDialog;
}


//===== ToolBarManagerLock ====================================================

class ViewShell::Implementation::ToolBarManagerLock::Deleter { public:
	void operator() (ToolBarManagerLock* pObject) { delete pObject; }
};

::boost::shared_ptr<ViewShell::Implementation::ToolBarManagerLock>
	ViewShell::Implementation::ToolBarManagerLock::Create (
		const ::boost::shared_ptr<ToolBarManager>& rpManager)
{
	::boost::shared_ptr<ToolBarManagerLock> pLock (
		new ViewShell::Implementation::ToolBarManagerLock(rpManager),
		ViewShell::Implementation::ToolBarManagerLock::Deleter());
	pLock->mpSelf = pLock;
	return pLock;
}


ViewShell::Implementation::ToolBarManagerLock::ToolBarManagerLock (
	const ::boost::shared_ptr<ToolBarManager>& rpManager)
	: mpLock(new ToolBarManager::UpdateLock(rpManager)),
	  maTimer()
{
	// Start a timer that will unlock the ToolBarManager update lock when
	// that is not done explicitly by calling Release().
	maTimer.SetTimeoutHdl(LINK(this,ToolBarManagerLock,TimeoutCallback));
	maTimer.SetTimeout(100);
	maTimer.Start();
}


IMPL_LINK(ViewShell::Implementation::ToolBarManagerLock,TimeoutCallback,Timer*,EMPTYARG)
{
	// If possible then release the lock now. Otherwise start the timer
	// and try again later.
	if (Application::IsUICaptured())
	{
		maTimer.Start();
	}
	else
	{
		mpSelf.reset();
	}
	return 0;
}


void ViewShell::Implementation::ToolBarManagerLock::Release (bool bForce)
{
	// If possible then release the lock now. Otherwise try again when the
	// timer expires.
	if (bForce || ! Application::IsUICaptured())
	{
		mpSelf.reset();
	}
}


ViewShell::Implementation::ToolBarManagerLock::~ToolBarManagerLock (void)
{
	mpLock.reset();
}

} // end of namespace sd