mir/libreoffice
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
ae94e937e6fb459abc61a166c3340076f51f8b5c
libreoffice/svx/source/form/fmview.cxx
Rüdiger Timm fb7aefb971 INTEGRATION: CWS changefileheader (1.52.120); FILE MERGED 
2008/04/01 15:51:03 thb 1.52.120.3: #i85898# Stripping all external header guards
2008/04/01 12:48:54 thb 1.52.120.2: #i85898# Stripping all external header guards
2008/03/31 14:21:57 rt 1.52.120.1: #i87441# Change license header to LPGL v3.
2008-04-11 00:15:53 +00:00

716 lines
24 KiB
C++
Raw Blame History

/*************************************************************************
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright 2008 by Sun Microsystems, Inc.
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: fmview.cxx,v $
* $Revision: 1.53 $
*
* This file is part of OpenOffice.org.
*
* OpenOffice.org is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License version 3
* only, as published by the Free Software Foundation.
*
* OpenOffice.org is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License version 3 for more details
* (a copy is included in the LICENSE file that accompanied this code).
*
* You should have received a copy of the GNU Lesser General Public License
* version 3 along with OpenOffice.org. If not, see
* <http://www.openoffice.org/license.html>
* for a copy of the LGPLv3 License.
*
************************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_svx.hxx"
#include <sfx2/docfile.hxx>
#ifdef REFERENCE
#undef REFERENCE
#endif
#include <svtools/ehdl.hxx>
#include <svtools/moduleoptions.hxx>
#include <com/sun/star/sdb/SQLContext.hpp>
#include <com/sun/star/uno/XNamingService.hpp>
#include <com/sun/star/sdbc/XConnection.hpp>
#include <com/sun/star/sdbc/DataType.hpp>
#include <com/sun/star/form/XLoadable.hpp>
#include <com/sun/star/form/XReset.hpp>
#include "fmvwimp.hxx"
#include <sfx2/objsh.hxx>
#include <sfx2/viewsh.hxx>
#include <sfx2/viewfrm.hxx>
#include <sfx2/bindings.hxx>
#include <sfx2/dispatch.hxx>
#include <basic/sbuno.hxx>
#include <sfx2/macrconf.hxx>
#include <basic/sbx.hxx>
#include "fmitems.hxx"
#include "fmobj.hxx"
#include "svditer.hxx"
#include <svx/svdpagv.hxx>
#include <svx/svdogrp.hxx>
#ifndef _FM_FMVIEW_HXX
#include <svx/fmview.hxx>
#endif
#ifndef _FM_FMMODEL_HXX
#include <svx/fmmodel.hxx>
#endif
#ifndef _FM_FMPAGE_HXX
#include <svx/fmpage.hxx>
#endif
#include <svx/fmshell.hxx>
#ifndef _SVX_FMPGEIMP_HXX
#include "fmpgeimp.hxx"
#endif
#include "fmtools.hxx"
#include "fmshimp.hxx"
#include "fmservs.hxx"
#ifndef _SVX_FMPROP_HRC
#include "fmprop.hrc"
#endif
#include "fmundo.hxx"
#include <svx/dataaccessdescriptor.hxx>
#include <comphelper/processfactory.hxx>
#include <comphelper/namedvaluecollection.hxx>
#include <com/sun/star/ui/dialogs/XExecutableDialog.hpp>
#include <com/sun/star/beans/PropertyValue.hpp>
#include <com/sun/star/beans/PropertyState.hpp>
#include <com/sun/star/form/FormComponentType.hpp>
#include <vcl/svapp.hxx>
#include <tools/urlobj.hxx>
#include <vcl/stdtext.hxx>
#include <svx/fmglob.hxx>
#include <svx/sdrpagewindow.hxx>
#include "sdrpaintwindow.hxx"
using namespace ::com::sun::star;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::lang;
using namespace ::com::sun::star::sdbc;
using namespace ::com::sun::star::sdb;
using namespace ::com::sun::star::ui::dialogs;
using namespace ::com::sun::star::beans;
using namespace ::com::sun::star::container;
using namespace ::com::sun::star::form;
using namespace ::com::sun::star::util;
using namespace ::svxform;
using namespace ::svx;
//========================================================================
//------------------------------------------------------------------------
TYPEINIT1(FmFormView, E3dView);
//------------------------------------------------------------------------
FmFormView::FmFormView( FmFormModel* pModel, OutputDevice* pOut )
:E3dView(pModel,pOut)
{
Init();
}
//------------------------------------------------------------------------
void FmFormView::Init()
{
pFormShell = NULL;
pImpl = new FmXFormView(::comphelper::getProcessServiceFactory(),this);
pImpl->acquire();
//////////////////////////////////////////////////////////////////////
// Model setzen
SdrModel* pModel = GetModel();
DBG_ASSERT( pModel->ISA(FmFormModel), "Falsches Model" );
if( !pModel->ISA(FmFormModel) ) return;
FmFormModel* pFormModel = (FmFormModel*)pModel;
//////////////////////////////////////////////////////////////////////
// DesignMode vom Model holen
sal_Bool bInitDesignMode = pFormModel->GetOpenInDesignMode();
if ( pFormModel->OpenInDesignModeIsDefaulted( ) )
{ // this means that nobody ever explicitly set this on the model, and the model has never
// been loaded from a stream.
// This means this is a newly created document. This means, we want to have it in design
// mode by default (though a newly created model returns true for GetOpenInDesignMode).
// We _want_ to have this because it makes a lot of hacks following the original fix
// for #94595# unnecessary
// #96399# - 2002-10-11 - fs@openoffice.org
DBG_ASSERT( !bInitDesignMode, "FmFormView::Init: doesn't the model default to FALSE anymore?" );
// if this asserts, either the on-contruction default in the model has changed (then this here
// may not be necessary anymore), or we're not dealing with a new document ....
bInitDesignMode = sal_True;
}
SfxObjectShell* pObjShell = pFormModel->GetObjectShell();
if ( pObjShell && pObjShell->GetMedium() )
{
const SfxPoolItem *pItem=0;
if ( pObjShell->GetMedium()->GetItemSet()->GetItemState( SID_COMPONENTDATA, sal_False, &pItem ) == SFX_ITEM_SET )
{
Sequence< PropertyValue > aSeq;
( ((SfxUnoAnyItem*)pItem)->GetValue() ) >>= aSeq;
::comphelper::NamedValueCollection aComponentData( aSeq );
bInitDesignMode = aComponentData.getOrDefault( "ApplyFormDesignMode", bInitDesignMode );
}
}
if( pObjShell && pObjShell->IsReadOnly() )
bInitDesignMode = sal_False;
// dieses wird in der Shell vorgenommen
// bDesignMode = !bInitDesignMode; // erzwingt, dass SetDesignMode ausgefuehrt wird
SetDesignMode( bInitDesignMode );
}
//------------------------------------------------------------------------
FmFormView::~FmFormView()
{
pImpl->notifyViewDying();
pImpl->release();
// Bei der Shell abmelden
if( pFormShell )
pFormShell->SetView( NULL );
}
//------------------------------------------------------------------------
void FmFormView::MarkListHasChanged()
{
E3dView::MarkListHasChanged();
if ( pFormShell && IsDesignMode() )
{
FmFormObj* pObj = getMarkedGrid();
if ( pImpl->m_pMarkedGrid && pImpl->m_pMarkedGrid != pObj )
{
pImpl->m_pMarkedGrid = NULL;
if ( pImpl->m_xWindow.is() )
{
pImpl->m_xWindow->removeFocusListener(pImpl);
pImpl->m_xWindow = NULL;
}
SetMoveOutside(FALSE);
//OLMRefreshAllIAOManagers();
}
pFormShell->GetImpl()->SetSelectionDelayed();
}
}
namespace
{
const SdrPageWindow* findPageWindow( const SdrPaintView* _pView, OutputDevice* _pWindow )
{
SdrPageView* pPageView = _pView->GetSdrPageView();
if(pPageView)
{
for ( sal_uInt32 window = 0; window < pPageView->PageWindowCount(); ++window )
{
const SdrPageWindow* pPageWindow = pPageView->GetPageWindow( window );
if ( !pPageWindow || &pPageWindow->GetPaintWindow().GetOutputDevice() != _pWindow )
continue;
return pPageWindow;
}
}
return NULL;
}
}
//------------------------------------------------------------------------
void FmFormView::AddWindowToPaintView(OutputDevice* pNewWin)
{
E3dView::AddWindowToPaintView(pNewWin);
if ( !pNewWin )
return;
// look up the PageViewWindow for the newly inserted window, and care for it
// #i39269# / 2004-12-20 / frank.schoenheit@sun.com
const SdrPageWindow* pPageWindow = findPageWindow( this, pNewWin );
if ( pPageWindow )
pImpl->addWindow( *pPageWindow );
}
//------------------------------------------------------------------------
void FmFormView::DeleteWindowFromPaintView(OutputDevice* pNewWin)
{
const SdrPageWindow* pPageWindow = findPageWindow( this, pNewWin );
if ( pPageWindow )
pImpl->removeWindow( pPageWindow->GetControlContainer() );
E3dView::DeleteWindowFromPaintView(pNewWin);
}
//------------------------------------------------------------------------
void FmFormView::ChangeDesignMode(sal_Bool bDesign)
{
if (bDesign == IsDesignMode())
return;
FmFormModel* pModel = PTR_CAST(FmFormModel, GetModel());
if (pModel)
{ // fuer die Zeit des Uebergangs das Undo-Environment ausschalten, das sichert, dass man dort auch nicht-transiente
// Properties mal eben aendern kann (sollte allerdings mit Vorsicht genossen und beim Rueckschalten des Modes
// auch immer wieder rueckgaegig gemacht werden. Ein Beispiel ist das Setzen der maximalen Text-Laenge durch das
// FmXEditModel an seinem Control.)
pModel->GetUndoEnv().Lock();
}
// Reihenfolge beim umsetzen !Designmode
// a.) Datenbankforms laden
// b.) Designmode an die ::com::sun::star::sdbcx::View weitergeben
// c.) Controls aktivieren
SdrPageView* pCurPageView = GetSdrPageView();
FmFormPage* pCurPage = pCurPageView ? PTR_CAST(FmFormPage,pCurPageView->GetPage()) : NULL;
if (pCurPage && bDesign)
{
DeactivateControls(pCurPageView);
DBG_ASSERT( pFormShell && pFormShell->GetImpl(), "FmFormView::ChangeDesignMode: no valid shell!" );
// Since fixing 101864, 96009, et.al., we route the deactivation through the FormShell. I _suppose_
// the shell is always existent here, but I am not sure if there is a valid scenario where it isn't.
// Thus this assertion.
if ( pFormShell && pFormShell->GetImpl() )
pFormShell->GetImpl()->viewDeactivated( this );
else
pImpl->Deactivate( sal_True );
}
// <20>ber all angemeldeten Pages iterieren
// nur die aktive wird umgeschaltet
if(GetSdrPageView())
{
FmFormPage* pPage = PTR_CAST(FmFormPage,GetSdrPageView()->GetPage());
if (pPage)
{
// during load the environment covers the error handling
if (!bDesign)
ActivateControls(pCurPageView);
DBG_ASSERT( pFormShell && pFormShell->GetImpl(), "FmFormView::ChangeDesignMode: no valid shell!" );
if ( pFormShell && pFormShell->GetImpl() )
pFormShell->GetImpl()->loadForms( pPage, ( bDesign ? FORMS_UNLOAD : FORMS_LOAD ) );
}
}
SetDesignMode(bDesign);
if (pCurPage)
{
if (bDesign)
{
if ( GetActualOutDev() && GetActualOutDev()->GetOutDevType() == OUTDEV_WINDOW )
{
const Window* pWindow = static_cast< const Window* >( GetActualOutDev() );
const_cast< Window* >( pWindow )->GrabFocus();
}
// redraw UNO objects
if (pCurPageView)
{
SdrObjListIter aIter(*pCurPage);
while( aIter.IsMore() )
{
SdrObject* pObj = aIter.Next();
if (pObj && pObj->IsUnoObj())
{
// For redraw just use ActionChanged()
// pObj->BroadcastObjectChange();
pObj->ActionChanged();
}
}
}
}
else
{
// notify our shell that we have been activated
if ( pFormShell && pFormShell->GetImpl() )
pFormShell->GetImpl()->viewActivated( this );
else
pImpl->Activate();
// set the auto focus to the first control (if indicated by the model to do so)
sal_Bool bForceControlFocus = pModel ? pModel->GetAutoControlFocus() : sal_False;
if (bForceControlFocus)
pImpl->AutoFocus();
}
}
// und mein Undo-Environment wieder an
if (pModel)
pModel->GetUndoEnv().UnLock();
}
//------------------------------------------------------------------------
void FmFormView::GrabFirstControlFocus( sal_Bool _bForceSync )
{
if ( !IsDesignMode() )
pImpl->AutoFocus( _bForceSync );
}
//------------------------------------------------------------------------
SdrPageView* FmFormView::ShowSdrPage(SdrPage* pPage)
{
SdrPageView* pPV = E3dView::ShowSdrPage(pPage);
if (pPage)
{
if (!IsDesignMode())
{
// creating the controllers
ActivateControls(pPV);
// Alles deselektieren
UnmarkAll();
// notify our shell that we have been activated
if ( pFormShell && pFormShell->GetImpl() )
pFormShell->GetImpl()->viewActivated( this );
else
pImpl->Activate( );
} // nur wenn die Shell bereits im DesignMode ist
else if (pFormShell && pFormShell->IsDesignMode())
{
FmXFormShell* pFormShellImpl = pFormShell->GetImpl();
Reference< ::com::sun::star::container::XIndexAccess > xForms(((FmFormPage*)pPage)->GetForms(), UNO_QUERY);
pFormShellImpl->ResetForms(xForms, sal_True);
// damit der Formular-Navigator auf den Seitenwechsel reagieren kann
pFormShell->GetViewShell()->GetViewFrame()->GetBindings().Invalidate(SID_FM_FMEXPLORER_CONTROL , sal_True, sal_False);
pFormShellImpl->SetSelection(GetMarkedObjectList());
}
}
return pPV;
}
//------------------------------------------------------------------------
void FmFormView::HideSdrPage()
{
if (!IsDesignMode())
{
// Controls wieder deaktivieren
DeactivateControls(GetSdrPageView());
if ( pFormShell && pFormShell->GetImpl() )
pFormShell->GetImpl()->viewDeactivated( this );
else
pImpl->Deactivate( sal_True );
}
E3dView::HideSdrPage();
}
//------------------------------------------------------------------------
SdrModel* FmFormView::GetMarkedObjModel() const
{
return E3dView::GetMarkedObjModel();
}
//------------------------------------------------------------------------
sal_Bool FmFormView::Paste(const SdrModel& rMod, const Point& rPos, SdrObjList* pLst, sal_uInt32 nOptions)
{
return E3dView::Paste(rMod, rPos, pLst, nOptions);
}
//------------------------------------------------------------------------
void FmFormView::ActivateControls(SdrPageView* pPageView)
{
if (!pPageView) return;
for (sal_uInt32 i = 0L; i < pPageView->PageWindowCount(); ++i)
{
const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(i);
pImpl->addWindow(rPageWindow);
}
}
//------------------------------------------------------------------------
void FmFormView::DeactivateControls(SdrPageView* pPageView)
{
if( !pPageView ) return;
for (sal_uInt32 i = 0L; i < pPageView->PageWindowCount(); ++i)
{
const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(i);
pImpl->removeWindow(rPageWindow.GetControlContainer() );
}
}
//------------------------------------------------------------------------
void FmFormView::ObjectCreated(FmFormObj* pObj)
{
// it is valid that the form shell's forms collection is not initialized, yet
if ( pFormShell && pFormShell->GetImpl() )
pFormShell->GetImpl()->UpdateForms( sal_True );
Reference< XPropertySet > xSet( pObj->GetUnoControlModel(), UNO_QUERY );
if ( !xSet.is() )
return;
// some initial property defaults
sal_Int16 nClassId = pImpl->implInitializeNewControlModel( xSet, pObj );
if ( !pFormShell->GetImpl()->GetWizardUsing() )
return;
// #i31958# don't call wizards in XForms mode
if ( pFormShell->GetImpl()->isEnhancedForm() )
return;
// #i46898# no wizards if there is no Base installed - currently, all wizards are
// database related
if ( !SvtModuleOptions().IsModuleInstalled( SvtModuleOptions::E_SDATABASE ) )
return;
Reference< XChild > xChild(xSet, UNO_QUERY);
Reference< XRowSet > xForm(xChild->getParent(), UNO_QUERY);
String sWizardName;
Any aObj;
switch (nClassId)
{
case FormComponentType::GRIDCONTROL:
sWizardName.AssignAscii("com.sun.star.sdb.GridControlAutoPilot");
aObj <<= xChild;
break;
case FormComponentType::LISTBOX:
case FormComponentType::COMBOBOX:
sWizardName.AssignAscii("com.sun.star.sdb.ListComboBoxAutoPilot");
aObj <<= xChild;
break;
case FormComponentType::GROUPBOX:
sWizardName.AssignAscii("com.sun.star.sdb.GroupBoxAutoPilot");
aObj <<= xChild;
break;
}
if (sWizardName.Len() != 0)
{
// build the argument list
Sequence< Any > aWizardArgs(1);
// the object affected
aWizardArgs[0] = makeAny(PropertyValue(
::rtl::OUString::createFromAscii("ObjectModel"),
0,
makeAny(xChild),
PropertyState_DIRECT_VALUE
));
// create the wizard object
Reference< XExecutableDialog > xWizard;
try
{
Reference< XMultiServiceFactory > xORB = ::comphelper::getProcessServiceFactory();
xWizard = Reference< XExecutableDialog >(
::comphelper::getProcessServiceFactory()->createInstanceWithArguments(sWizardName, aWizardArgs),
UNO_QUERY);
}
catch(Exception&)
{
}
if (!xWizard.is())
{
ShowServiceNotAvailableError(NULL, sWizardName, sal_True);
return;
}
// execute the wizard
try
{
xWizard->execute();
}
catch(Exception&)
{
DBG_ERROR("FmFormView::ObjectCreated: could not execute the AutoPilot!");
// TODO: real error handling
}
}
}
//------------------------------------------------------------------------
SdrObject* FmFormView::CreateFieldControl( const ODataAccessDescriptor& _rColumnDescriptor )
{
return pImpl->implCreateFieldControl( _rColumnDescriptor );
}
//------------------------------------------------------------------------
SdrObject* FmFormView::CreateXFormsControl( const OXFormsDescriptor &_rDesc )
{
return pImpl->implCreateXFormsControl(_rDesc);
}
//------------------------------------------------------------------------
SdrObject* FmFormView::CreateFieldControl(const UniString& rFieldDesc) const
{
::rtl::OUString sDataSource = rFieldDesc.GetToken(0,sal_Unicode(11));
::rtl::OUString sObjectName = rFieldDesc.GetToken(1,sal_Unicode(11));
sal_uInt16 nObjectType = (sal_uInt16)rFieldDesc.GetToken(2,sal_Unicode(11)).ToInt32();
::rtl::OUString sFieldName = rFieldDesc.GetToken(3,sal_Unicode(11));
if (!sFieldName.getLength() || !sObjectName.getLength() || !sDataSource.getLength())
return NULL;
ODataAccessDescriptor aColumnDescriptor;
aColumnDescriptor.setDataSource(sDataSource);
aColumnDescriptor[ daCommand ] <<= sObjectName;
aColumnDescriptor[ daCommandType ] <<= nObjectType;
aColumnDescriptor[ daColumnName ] <<= sFieldName;
return pImpl->implCreateFieldControl( aColumnDescriptor );
}
//------------------------------------------------------------------------
void FmFormView::InsertControlContainer(const Reference< ::com::sun::star::awt::XControlContainer > & xCC)
{
if( !IsDesignMode() )
{
SdrPageView* pPageView = GetSdrPageView();
if( pPageView )
{
for( sal_uInt32 i = 0L; i < pPageView->PageWindowCount(); i++ )
{
const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(i);
if( rPageWindow.GetControlContainer( false ) == xCC )
{
pImpl->addWindow(rPageWindow);
break;
}
}
}
}
}
//------------------------------------------------------------------------
void FmFormView::RemoveControlContainer(const Reference< ::com::sun::star::awt::XControlContainer > & xCC)
{
if( !IsDesignMode() )
{
pImpl->removeWindow( xCC );
}
}
// -----------------------------------------------------------------------------
BOOL FmFormView::KeyInput(const KeyEvent& rKEvt, Window* pWin)
{
BOOL bDone = FALSE;
const KeyCode& rKeyCode = rKEvt.GetKeyCode();
if ( IsDesignMode()
&& rKeyCode.GetCode() == KEY_RETURN
)
{
// RETURN alone enters grid controls, for keyboard accessibility
if ( pWin
&& !rKeyCode.IsShift()
&& !rKeyCode.IsMod1()
&& !rKeyCode.IsMod2()
)
{
FmFormObj* pObj = getMarkedGrid();
if ( pObj )
{
Reference< awt::XWindow > xWindow( pObj->GetUnoControl( *this, *pWin ), UNO_QUERY );
if ( xWindow.is() )
{
pImpl->m_pMarkedGrid = pObj;
pImpl->m_xWindow = xWindow;
// add as listener to get notified when ESC will be pressed inside the grid
pImpl->m_xWindow->addFocusListener(pImpl);
SetMoveOutside(TRUE);
//OLMRefreshAllIAOManagers();
xWindow->setFocus();
bDone = TRUE;
}
}
}
// Alt-RETURN alone enters shows the properties of the selection
if ( pFormShell
&& pFormShell->GetImpl()
&& !rKeyCode.IsShift()
&& !rKeyCode.IsMod1()
&& rKeyCode.IsMod2()
)
{
pFormShell->GetImpl()->handleShowPropertiesRequest();
}
}
if ( !bDone )
bDone = E3dView::KeyInput(rKEvt,pWin);
return bDone;
}
// -----------------------------------------------------------------------------
sal_Bool FmFormView::checkUnMarkAll(const Reference< XInterface >& _xSource)
{
Reference< ::com::sun::star::awt::XControl> xControl(pImpl->m_xWindow,UNO_QUERY);
sal_Bool bRet = !xControl.is() || !_xSource.is() || _xSource != xControl->getModel();
if ( bRet )
UnmarkAll();
return bRet;
}
// -----------------------------------------------------------------------------
BOOL FmFormView::MouseButtonDown( const MouseEvent& _rMEvt, Window* _pWin )
{
BOOL bReturn = E3dView::MouseButtonDown( _rMEvt, _pWin );
if ( pFormShell && pFormShell->GetImpl() )
{
SdrViewEvent aViewEvent;
PickAnything( _rMEvt, SDRMOUSEBUTTONDOWN, aViewEvent );
pFormShell->GetImpl()->handleMouseButtonDown( aViewEvent );
}
return bReturn;
}
// -----------------------------------------------------------------------------
FmFormObj* FmFormView::getMarkedGrid() const
{
FmFormObj* pObj = NULL;
const SdrMarkList& rMarkList = GetMarkedObjectList();
if ( 1 == rMarkList.GetMarkCount() )
{
SdrMark* pMark = rMarkList.GetMark(0);
if ( pMark )
{
pObj = PTR_CAST(FmFormObj,pMark->GetMarkedSdrObj());
if ( pObj )
{
Reference<XServiceInfo> xServInfo(pObj->GetUnoControlModel(),UNO_QUERY);
if ( !xServInfo.is() || !xServInfo->supportsService(FM_SUN_COMPONENT_GRIDCONTROL) )
pObj = NULL;
}
}
}
return pObj;
}
// -----------------------------------------------------------------------------
void FmFormView::createControlLabelPair(SdrView* _pView,OutputDevice* _pOutDev, sal_Int32 _nXOffsetMM, sal_Int32 _nYOffsetMM,
const Reference< XPropertySet >& _rxField, const Reference< XNumberFormats >& _rxNumberFormats,
sal_uInt16 _nObjID, const ::rtl::OUString& _rFieldPostfix,UINT32 _nInventor,UINT16 _nIndent,
SdrPage* _pLabelPage,SdrPage* _pPage,SdrModel* _pModel,
SdrUnoObj*& _rpLabel, SdrUnoObj*& _rpControl)
{
FmXFormView::createControlLabelPair(_pView,_pOutDev,_nXOffsetMM, _nYOffsetMM,
_rxField, _rxNumberFormats,
_nObjID, _rFieldPostfix,_nInventor,_nIndent,
_pLabelPage,_pPage,_pModel,
_rpLabel, _rpControl);
}
// -----------------------------------------------------------------------------
Reference< XFormController > FmFormView::GetFormController( const Reference< XForm >& _rxForm, const OutputDevice& _rDevice ) const
{
return pImpl->getFormController( _rxForm, _rDevice );
}
Reference in New Issue View Git Blame Copy Permalink