xref: /AOO41X/main/sfx2/source/bastyp/progress.cxx (revision d119d52d53d0b2180f2ae51341d882123be2af2b)

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

#include <sfx2/progress.hxx>
#include <com/sun/star/uno/Reference.hxx>
#include <com/sun/star/task/XStatusIndicatorFactory.hpp>

#ifndef _SBX_HXX //autogen
#include <basic/sbx.hxx>
#endif

#include <svl/eitem.hxx>
#include <tools/time.hxx>

// wg. nRescheduleLocks
#include "appdata.hxx"
#include <sfx2/request.hxx>
#include <sfx2/frame.hxx>
#include <sfx2/viewfrm.hxx>
#include <sfx2/viewsh.hxx>
#include <sfx2/objsh.hxx>
#include <sfx2/app.hxx>
#include <sfx2/dispatch.hxx>
#include "sfxtypes.hxx"
#include <sfx2/docfile.hxx>
#include "workwin.hxx"
#include "sfx2/sfxresid.hxx"
#include "bastyp.hrc"
#include <sfx2/msg.hxx>

#include <time.h>

using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::frame;
using namespace ::com::sun::star::task;

void AddNumber_Impl( String& aNumber, sal_uInt32 nArg )
{
	if ( nArg >= 10240 )
	{
		aNumber += String::CreateFromInt32( (sal_uInt16)( ( nArg + 512 ) / 1024 ) );
		aNumber += ' ';
		aNumber += SfxResId( STR_KB );
	}
	else
	{
		aNumber += String::CreateFromInt32( nArg );
		aNumber += ' ';
		aNumber += SfxResId( STR_BYTES );
	}
}

struct SfxProgress_Impl
{
    Reference < XStatusIndicator > xStatusInd;
    String                  aText, aStateText;
	sal_uIntPtr					nMax;
	clock_t 				nCreate;
	clock_t					nNextReschedule;
	sal_Bool					bLocked, bAllDocs;
	sal_Bool					bWaitMode;
	sal_Bool					bAllowRescheduling;
	sal_Bool					bRunning;
	sal_Bool                    bIsStatusText;

	SfxProgress*            pActiveProgress;
	SfxObjectShellRef		xObjSh;
	SfxWorkWindow*			pWorkWin;
    SfxViewFrame*           pView;

							SfxProgress_Impl( const String& );
    void                    Enable_Impl( sal_Bool );

};

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

#define TIMEOUT_PROGRESS	 	 5L	/* 10th s */
#define MAXPERCENT_PROGRESS		33

#define TIMEOUT_RESCHEDULE 		10L	/* 10th s */
#define MAXPERCENT_RESCHEDULE 	50

#define Progress
#include "sfxslots.hxx"

#define aTypeLibInfo aProgressTypeLibImpl

//========================================================================
extern sal_uIntPtr Get10ThSec();

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

void SfxProgress_Impl::Enable_Impl( sal_Bool bEnable )
{
    SfxObjectShell* pDoc = bAllDocs ? NULL : (SfxObjectShell*) xObjSh;
	SfxViewFrame *pFrame= SfxViewFrame::GetFirst(pDoc);
	while ( pFrame )
	{
		pFrame->Enable(bEnable);
        pFrame->GetDispatcher()->Lock( !bEnable );
		pFrame = SfxViewFrame::GetNext(*pFrame, pDoc);
	}

    if ( pView )
    {
        pView->Enable( bEnable );
        pView->GetDispatcher()->Lock( !bEnable );
    }

	if ( !pDoc )
        SFX_APP()->GetAppDispatcher_Impl()->Lock( !bEnable );
}

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

SfxProgress_Impl::SfxProgress_Impl( const String &/*rTitle*/ )
    :   pActiveProgress( 0 )
{
}

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

SfxProgress::SfxProgress
(
	SfxObjectShell*	pObjSh, /* SfxObjectShell, an der die Aktion ausgef"uhrt
							   wird. Kann NULL sein, dann wird die Applikation
							   verwendet */

	const String&	rText,	/* Text, der in der Statuszeile vor den Statusmonitor
							   erscheint */

	sal_uIntPtr			nRange, /* Maximalwert des Bereiches */

	sal_Bool			bAll    /* alle Dokumente oder nur das Dokument des ViewFrames
							   disablen (sal_False) */
	,sal_Bool			bWait   /* initial den Wait-Pointer aktivieren (sal_True) */
)

/*	[Beschreibung]

	Der Konstruktor der Klasse SfxProgress schaltet den als Parameter
	"ubergebenen SfxObjectShell und SfxViewFrames, welche dieses Dokument
	anzeigen in einen Progress-Mode. D.h. solange eine dieser SfxViewFrame
	Instanzen aktiv ist, ist der dazugeh"orige SfxDispatcher und das
	dazugeh"orige Window disabled. In der Statuszeile wird ein Balken zur
	Fortschritts-Anzeige angezeigt.
*/

:	pImp( new SfxProgress_Impl( rText ) ),
	nVal(0),
	bSuspended(sal_True)
{
	pImp->bRunning = sal_True;
	pImp->bAllowRescheduling = Application::IsInExecute();;

	pImp->xObjSh = pObjSh;
	pImp->aText = rText;
	pImp->nMax = nRange;
	pImp->bLocked = sal_False;
	pImp->bWaitMode = bWait;
	pImp->bIsStatusText = sal_False;
	pImp->nCreate = Get10ThSec();
	pImp->nNextReschedule = pImp->nCreate;
	DBG( DbgOutf( "SfxProgress: created for '%s' at %luds",
				  rText.GetBuffer(), pImp->nCreate ) );
	pImp->bAllDocs = bAll;
	pImp->pWorkWin = 0;
    pImp->pView = 0;

	pImp->pActiveProgress = GetActiveProgress( pObjSh );
	if ( pObjSh )
		pObjSh->SetProgress_Impl(this);
	else if( !pImp->pActiveProgress )
        SFX_APP()->SetProgress_Impl(this);
	Resume();
}

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

SfxProgress::~SfxProgress()

/*	[Beschreibung]

	Der Destruktor der Klasse SfxProgress restauriert den alten Zustand;
	die Dokumente werden wieder freigeschaltet und die Statuszeile zeigt
	wieder Items an.
*/

{
	Stop();
    if ( pImp->xStatusInd.is() )
        pImp->xStatusInd->end();

	if( pImp->bIsStatusText == sal_True )
		GetpApp()->HideStatusText( );
	delete pImp;
}

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

void SfxProgress::Stop()

/*	[Beschreibung]

	Vorzeitiges Beenden des <SfxProgress>.
*/

{
    if( pImp->pActiveProgress )
    {
        if ( pImp->xObjSh.Is() && pImp->xObjSh->GetProgress() == this )
            pImp->xObjSh->SetProgress_Impl(0);
        return;
    }

	if ( !pImp->bRunning )
		return;
	pImp->bRunning = sal_False;
	DBG( DbgOutf( "SfxProgress: destroyed at %luds", Get10ThSec() ) );

	Suspend();
	if ( pImp->xObjSh.Is() )
		pImp->xObjSh->SetProgress_Impl(0);
	else
        SFX_APP()->SetProgress_Impl(0);
	if ( pImp->bLocked )
        pImp->Enable_Impl(sal_True);
}

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

void SfxProgress::SetText
(
	const String&	/*	neuer Text */
)

/*	[Beschreibung]

	"Andert den Text, der links neben dem Fortschritts-Balken
	angezeigt wird.
*/

{
	if( pImp->pActiveProgress ) return;
    if ( pImp->xStatusInd.is() )
    {
        pImp->xStatusInd->reset();
        pImp->xStatusInd->start( pImp->aText, pImp->nMax );
    }
}

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

const String& SfxProgress::GetStateText_Impl() const
{
	return pImp->aStateText;
}

// -----------------------------------------------------------------------
/*
IMPL_STATIC_LINK( SfxProgress, SetStateHdl, PlugInLoadStatus*, pStatus )
{
	INetRequest* pReq = 0;
	const INetHint *pHint = PTR_CAST( INetHint, pStatus->pHint );
	pReq = PTR_CAST( INetRequest, pStatus->pBC );

	String aString;
	if( pReq )
		aString = SfxMedium::GetStatusString( pHint->GetId(), pReq, pHint );
	if( aString.Len() )
	{
		GetpApp()->ShowStatusText( aString );
		if( pThis )
			pThis->pImp->bIsStatusText = sal_True;
	}
	return 0;
}
*/

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

// muss in AppDaten
static sal_uIntPtr nLastTime = 0;

long TimeOut_Impl( void*, void* pArgV )
{
    Timer *pArg = (Timer*)pArgV;
	if( Time::GetSystemTicks() - nLastTime > 3000 )
	{
		GetpApp()->HideStatusText();
		nLastTime = 0;
		delete pArg;
	}
	else pArg->Start();
	return 0;
}

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

sal_Bool SfxProgress::SetStateText
(
	sal_uLong			nNewVal,	/* neuer Wert f"ur die Fortschritts-Anzeige */
	const String&	rNewVal,	/* Status als Text */
	sal_uLong			nNewRange	/* neuer Maximalwert, 0 f"ur Beibehaltung des alten */
)

{
	pImp->aStateText = rNewVal;
	return SetState( nNewVal, nNewRange );
}

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

sal_Bool SfxProgress::SetState
(
	sal_uLong	nNewVal,	/* neuer Wert f"ur die Fortschritts-Anzeige */

	sal_uLong	nNewRange	/* neuer Maximalwert, 0 f"ur Beibehaltung des alten */
)
/*	[Beschreibung]

	Setzen des aktuellen Status; nach einem zeitlichen Versatz
	wird Reschedule aufgerufen.


	[R"uckgabewert]

	sal_Bool				TRUE
						Fortfahren mit der Aktion

						FALSE
						Abbrechen der Aktion
*/

{
	// wurde via Stop-Button angehalten?
//	if ( pImp->IsCancelled() )
//		return sal_False;

	if( pImp->pActiveProgress ) return sal_True;

	// neuen Wert "ubernehmen
	sal_Bool bOver=sal_False;
	nVal = nNewVal;

	// neuer Range?
	if ( nNewRange && nNewRange != pImp->nMax )
	{
		DBG( DbgOutf( "SfxProgress: range changed from %lu to %lu",
					  pImp->nMax, nNewRange ) );
		pImp->nMax = nNewRange;
		bOver = sal_True;
	}

    if ( !pImp->xStatusInd.is() )
	{
        // get the active ViewFrame of the document this progress is working on
        // if it doesn't work on a document, take the current ViewFrame
        SfxObjectShell* pObjSh = pImp->xObjSh;
        pImp->pView = SfxViewFrame::Current();
        DBG_ASSERT( pImp->pView || pObjSh, "Can't make progress bar!");
        if ( pObjSh && ( !pImp->pView || pObjSh != pImp->pView->GetObjectShell() ) )
        {
            // current document does not belong to current ViewFrame; take it's first visible ViewFrame
            SfxViewFrame* pDocView = SfxViewFrame::GetFirst( pObjSh );
            if ( pDocView )
                pImp->pView = pDocView;
            else
            {
                // don't show status indicator for hidden documents (only valid while loading)
                SfxMedium* pMedium = pObjSh->GetMedium();
                SFX_ITEMSET_ARG( pMedium->GetItemSet(), pHiddenItem, SfxBoolItem, SID_HIDDEN, sal_False );
                if ( !pHiddenItem || !pHiddenItem->GetValue() )
                {
                    // not in a view, perhaps it's just loading
                    //SfxFrame* pFrame = pMedium->GetLoadTargetFrame();
                    //if ( pFrame && pFrame->GetCurrentViewFrame() )
                    //{
                        // recycling frame
                        //pImp->pView = pFrame->GetCurrentViewFrame();
                    //}
                    //else
                    {
                        SFX_ITEMSET_ARG( pMedium->GetItemSet(), pIndicatorItem, SfxUnoAnyItem, SID_PROGRESS_STATUSBAR_CONTROL, sal_False );
                        Reference< XStatusIndicator > xInd;
                        if ( pIndicatorItem && (pIndicatorItem->GetValue()>>=xInd) )
                            pImp->xStatusInd = xInd;
                    }
                }
            }
        }
        else if ( pImp->pView )
        {
            pImp->pWorkWin = SFX_APP()->GetWorkWindow_Impl( pImp->pView );
            if ( pImp->pWorkWin )
                pImp->xStatusInd = pImp->pWorkWin->GetStatusIndicator();
        }

        if ( pImp->xStatusInd.is() )
        {
            pImp->xStatusInd->start( pImp->aText, pImp->nMax );
            pImp->pView = NULL;
        }
	}

    if ( pImp->xStatusInd.is() )
    {
        pImp->xStatusInd->setValue( nNewVal );
    }

	return sal_True;
}

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

void SfxProgress::Resume()

/*	[Beschreibung]

	Nimmt die Anzeige des Status nach einer Unterbrechung wieder auf.

	[Querverweise]
	<SfxProgress::Suspend()>
*/

{
	if( pImp->pActiveProgress ) return;
	if ( bSuspended )
	{
		DBG( DbgOutf( "SfxProgress: resumed" ) );
        if ( pImp->xStatusInd.is() )
        {
            pImp->xStatusInd->start( pImp->aText, pImp->nMax );
            pImp->xStatusInd->setValue( nVal );
        }

		if ( pImp->bWaitMode )
		{
			if ( pImp->xObjSh.Is() && !pImp->bAllDocs )
			{
				for ( SfxViewFrame *pFrame = SfxViewFrame::GetFirst(pImp->xObjSh);
						pFrame;
						pFrame = SfxViewFrame::GetNext( *pFrame, pImp->xObjSh ) )
					pFrame->GetWindow().EnterWait();
			}
		}

		if ( pImp->xObjSh )
		{
            SfxViewFrame *pFrame = SfxViewFrame::GetFirst(pImp->xObjSh);
            if ( pFrame )
                pFrame->GetBindings().ENTERREGISTRATIONS();
		}

		bSuspended = sal_False;
	}
}

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

void SfxProgress::Suspend()

/*	[Beschreibung]

	Unterbricht die Anzeige des Status

	[Querverweise]
	<SfxProgress::Resume()>
*/

{
	if( pImp->pActiveProgress ) return;
	if ( !bSuspended )
	{
		DBG( DbgOutf( "SfxProgress: suspended" ) );
		bSuspended = sal_True;

        if ( pImp->xStatusInd.is() )
        {
            pImp->xStatusInd->reset();
        }

		if ( pImp->xObjSh.Is() && !pImp->bAllDocs )
		{
			for ( SfxViewFrame *pFrame =
					SfxViewFrame::GetFirst(pImp->xObjSh);
					pFrame;
					pFrame = SfxViewFrame::GetNext( *pFrame, pImp->xObjSh ) )
				pFrame->GetWindow().LeaveWait();
		}
		if ( pImp->xObjSh.Is() )
		{
			SfxViewFrame *pFrame = SfxViewFrame::GetFirst(pImp->xObjSh);
            if ( pFrame )
                pFrame->GetBindings().LEAVEREGISTRATIONS();
		}
	}
}

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

void SfxProgress::Lock()
{
	if( pImp->pActiveProgress ) return;
	// kein Reschedule bei Embedded-Objekten,
	// da wir gegen das OLE Protokoll wehrlos sind
	if ( !pImp->xObjSh.Is() )
	{
		for ( SfxObjectShell *pDocSh = SfxObjectShell::GetFirst();
			  pDocSh;
			  pDocSh = SfxObjectShell::GetNext(*pDocSh) )
		{
			SfxObjectCreateMode eMode = pDocSh->GetCreateMode();
			if ( ( eMode == SFX_CREATE_MODE_EMBEDDED ) ||
				 ( eMode == SFX_CREATE_MODE_PREVIEW ) )
			{
				DBG( DbgOutf( "SfxProgress: not locked because EMBEDDED/PREVIEW found" ) );
				pImp->bAllowRescheduling = sal_False;
			}
		}
	}
	else
	{
		SfxObjectCreateMode eMode = pImp->xObjSh->GetCreateMode();
		if ( ( eMode == SFX_CREATE_MODE_EMBEDDED ) ||
			 ( eMode == SFX_CREATE_MODE_PREVIEW ) )
		{
			DBG( DbgOutf( "SfxProgress: not locked because ObjectShell is EMBEDDED/PREVIEW" ) );
			pImp->bAllowRescheduling = sal_False;
		}
	}

    pImp->Enable_Impl( sal_False );

	DBG( DbgOutf( "SfxProgress: locked" ) );
	pImp->bLocked = sal_True;
}

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

void SfxProgress::UnLock()
{
	if( pImp->pActiveProgress ) return;
	if ( !pImp->bLocked )
		return;

	DBG( DbgOutf( "SfxProgress: unlocked" ) );
	pImp->bLocked = sal_False;
    pImp->Enable_Impl(sal_True);
}

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

void SfxProgress::Reschedule()

/*	[Beschreibung]

	Reschedule von au"sen rufbar

*/

{
	SFX_STACK(SfxProgress::Reschedule);

	if( pImp->pActiveProgress ) return;
    SfxApplication* pApp = SFX_APP();
    if ( pImp->bLocked && 0 == pApp->Get_Impl()->nRescheduleLocks )
	{
        DBG_ASSERTWARNING( pApp->IsInAsynchronCall_Impl(),
							"Reschedule in synchron-call-stack" );

        SfxAppData_Impl *pAppData = pApp->Get_Impl();
		++pAppData->nInReschedule;
		Application::Reschedule();
		--pAppData->nInReschedule;
	}
}

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

void SfxProgress::SetWaitMode
(
	sal_Bool	bWait		/*	TRUE
							Wartecursor wird verwendet

							FALSE
							Es wird kein Wartecursor verwendet */
)

/*	[Beschreibung]

	Wartecursor-Modus umschalten.

*/

{
	if( pImp->pActiveProgress ) return;
	if ( !bSuspended && pImp->bWaitMode != bWait )
	{
		if ( bWait )
		{
			if ( pImp->xObjSh.Is() && !pImp->bAllDocs )
			{
				for ( SfxViewFrame *pFrame =
						SfxViewFrame::GetFirst(pImp->xObjSh);
						pFrame;
						pFrame = SfxViewFrame::GetNext( *pFrame, pImp->xObjSh ) )
					pFrame->GetWindow().EnterWait();
			}
		}
		else
		{
			if ( pImp->xObjSh.Is() && !pImp->bAllDocs )
			{
				for ( SfxViewFrame *pFrame =
						SfxViewFrame::GetFirst(pImp->xObjSh);
						pFrame;
						pFrame = SfxViewFrame::GetNext( *pFrame, pImp->xObjSh ) )
					pFrame->GetWindow().LeaveWait();
			}
		}
	}

	pImp->bWaitMode = bWait;
}

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

sal_Bool SfxProgress::GetWaitMode() const

/*	[Beschreibung]

	Wartecursor-Modus abfragen.

*/

{
	return pImp->bWaitMode;
}

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

SfxProgress* SfxProgress::GetActiveProgress
(
	SfxObjectShell* pDocSh	  /*  <SfxObjectShell>, die nach einem laufenden
									<SfxProgress> gefragt werden soll, oder
									0, wenn ein f"ur die gesamte Applikation
									laufender SfxProgress erfragt werden soll.
									Der Pointer braucht nur zum Zeitpunkt des
									Aufrufs g"ultig zu sein. */
)

/*	[Beschreibung]

	Mit dieser Methode kann erfragt werden, ob und welcher <SfxProgress>-
	f"ur eine bestimmte Instanz von SfxObjectShell oder gar die gesamte
	Applikation zur Zeit aktiv ist. Dies kann z.B. zum Abfangen von
	Time-Out-Events etc. verwendet werden.

	Anstelle eines Pointer auf den SfxProgress der SfxObjectShell wird
	ggf. der auf den SfxProgress der Applikation geliefert, mit der
	Abfrage 'SfxProgress::GetActiveProgress(pMyDocSh)' wird also
	insofern vorhanden der SfxProgress von 'pMyDocSh' geliefert,
	sonst der SfxProgress der Applikation bzw. ein 0-Pointer.


	[Anmerkung]

	"auft kein SfxProgress an der Applikation und ebenfalls keiner an
	der angegebenen SfxObjectShell, dann wird immer 0 zur"uckgeliefert,
	auch wenn an einer anderen SfxObjectShell ein SfxProgress l"uft.


	[Querverweise]

	<SfxApplication::GetProgress()const>
	<SfxObjectShell::GetProgress()const>
*/

{
    if ( !SfxApplication::Get() )
        return 0;

	SfxProgress *pProgress = 0;
	if ( pDocSh )
		pProgress = pDocSh->GetProgress();
	if ( !pProgress )
		pProgress = SFX_APP()->GetProgress();
	return pProgress;
}

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

void SfxProgress::EnterLock()
{
	SFX_APP()->Get_Impl()->nRescheduleLocks++;
}

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

void SfxProgress::LeaveLock()
{
	SfxAppData_Impl *pImp = SFX_APP()->Get_Impl();
	DBG_ASSERT( 0 != pImp->nRescheduleLocks, "SFxProgress::LeaveLock but no locks" );
	pImp->nRescheduleLocks--;
}

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

FASTBOOL SfxProgress::StatusBarManagerGone_Impl
(
	SfxStatusBarManager	*	// dieser <SfxStatusBarManager> wird zerst"ort
)

/*	[Beschreibung]

	Interne Methode zum Benachrichtigen des SfxProgress, da\s der angegebene
	SfxStatusBarManger zerst"ort wird. Damit der Progress ihn loslassen
	kann.
*/

{
	return sal_True;
}