| /************************************************************** |
| * |
| * 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. |
| * |
| *************************************************************/ |
| |
| |
| |
| #include <tools/rc.h> |
| //#define RESOURCE_PUBLISH_PROTECTED 1 |
| #if RESOURCE_PUBLISH_PROTECTED |
| // ugh, override non-helpful proctection |
| #define protected public |
| #endif /* RESOURCE_PUBLISH_PROTECTED */ |
| #include <tools/rc.hxx> |
| #undef protected |
| |
| |
| #include "wrapper.hxx" |
| |
| #include <awt/vclxplugin.hxx> |
| #include <awt/vclxtabcontrol.hxx> |
| #include <com/sun/star/awt/PosSize.hpp> |
| #include <com/sun/star/awt/VclWindowPeerAttribute.hpp> |
| #include <com/sun/star/awt/WindowAttribute.hpp> |
| #include <com/sun/star/awt/XDialog2.hpp> |
| #include <com/sun/star/awt/XProgressBar.hpp> |
| #include <com/sun/star/awt/XSimpleTabController.hpp> |
| #include <com/sun/star/awt/XTabListener.hpp> |
| #include <com/sun/star/graphic/XGraphic.hpp> |
| #include <comphelper/processfactory.hxx> |
| #include <layout/core/factory.hxx> |
| #include <layout/core/localized-string.hxx> |
| #include <layout/core/root.hxx> |
| #include <toolkit/awt/vclxwindow.hxx> |
| #include <vcl/ctrl.hxx> |
| #include <vcl/dialog.hxx> |
| #include <vcl/image.hxx> |
| #include <vcl/tabctrl.hxx> |
| #include <vcl/tabpage.hxx> |
| #include <vcl/window.hxx> |
| |
| using namespace ::com::sun::star; |
| using rtl::OUString; |
| |
| namespace layout |
| { |
| |
| // Context bits ... |
| class ContextImpl |
| { |
| uno::Reference< awt::XLayoutRoot > mxRoot; |
| uno::Reference< container::XNameAccess > mxNameAccess; |
| PeerHandle mxTopLevel; |
| |
| public: |
| ContextImpl( char const *pPath ) |
| { |
| uno::Sequence< uno::Any > aParams( 1 ); |
| aParams[0] <<= OUString( pPath, strlen( pPath ), RTL_TEXTENCODING_UTF8 ); |
| |
| uno::Reference< lang::XSingleServiceFactory > xFactory( |
| comphelper::createProcessComponent( |
| OUString::createFromAscii( "com.sun.star.awt.Layout" ) ), |
| uno::UNO_QUERY ); |
| if ( !xFactory.is() ) |
| { |
| throw uno::RuntimeException( |
| OUString( RTL_CONSTASCII_USTRINGPARAM( "Layout engine not installed" ) ), |
| uno::Reference< uno::XInterface >() ); |
| } |
| mxRoot = uno::Reference< awt::XLayoutRoot >( |
| xFactory->createInstanceWithArguments( aParams ), |
| uno::UNO_QUERY ); |
| |
| mxNameAccess = uno::Reference< container::XNameAccess >( mxRoot, uno::UNO_QUERY ); |
| } |
| |
| ~ContextImpl() |
| { |
| } |
| |
| PeerHandle getByName( const OUString &rName ) |
| { |
| uno::Any val = mxNameAccess->getByName( rName ); |
| PeerHandle xRet; |
| val >>= xRet; |
| return xRet; |
| } |
| PeerHandle getTopLevel() |
| { |
| return mxTopLevel; |
| } |
| void setTopLevel( PeerHandle xToplevel ) |
| { |
| mxTopLevel = xToplevel; |
| } |
| PeerHandle getRoot() |
| { |
| return mxRoot; |
| } |
| }; |
| |
| Context::Context( const char *pPath ) |
| : pImpl( new ContextImpl( pPath ) ) |
| { |
| } |
| Context::~Context() |
| { |
| delete pImpl; |
| pImpl = NULL; |
| } |
| |
| void Context::setToplevel( PeerHandle xToplevel ) |
| { |
| pImpl->setTopLevel( xToplevel ); |
| } |
| |
| PeerHandle Context::getToplevel() |
| { |
| return pImpl->getTopLevel(); |
| } |
| PeerHandle Context::getRoot() |
| { |
| return pImpl->getRoot(); |
| } |
| |
| PeerHandle Context::GetPeerHandle( const char *id, sal_uInt32 nId ) const |
| { |
| PeerHandle xHandle; |
| xHandle = pImpl->getByName( OUString( id, strlen( id ), RTL_TEXTENCODING_UTF8 ) ); |
| if ( !xHandle.is() ) |
| { |
| DBG_ERROR1( "Failed to fetch widget '%s'", id ); |
| } |
| |
| if ( nId != 0 ) |
| { |
| rtl::OString aStr = rtl::OString::valueOf( (sal_Int32) nId ); |
| xHandle = GetPeerHandle( aStr.getStr(), 0 ); |
| } |
| return xHandle; |
| } |
| |
| WindowImpl::WindowImpl (Context *context, const PeerHandle &peer, Window *window) |
| : mpWindow (window) |
| , mpCtx (context) |
| , mxWindow (peer, uno::UNO_QUERY) |
| , mxVclPeer (peer, uno::UNO_QUERY) |
| , mvclWindow (0) |
| , bFirstTimeVisible (true) |
| { |
| } |
| |
| WindowImpl::~WindowImpl () |
| { |
| if (mpWindow) |
| mpWindow->mpImpl = 0; |
| if (mvclWindow) |
| { |
| VCLXWindow *v = mvclWindow->GetWindowPeer (); |
| v->SetWindow (0); |
| mvclWindow->SetComponentInterface (uno::Reference <awt::XWindowPeer> ()); |
| mvclWindow->SetWindowPeer (uno::Reference <awt::XWindowPeer> (), 0); |
| delete mvclWindow; |
| mvclWindow = 0; |
| } |
| } |
| |
| void WindowImpl::wrapperGone () |
| { |
| mvclWindow = 0; |
| mpWindow->mpImpl = 0; |
| mpWindow = 0; |
| mpCtx = 0; |
| if ( mxWindow.is() ) |
| { |
| uno::Reference< lang::XComponent > xComp( mxWindow, uno::UNO_QUERY ); |
| mxWindow.clear (); |
| if ( xComp.is() ) |
| xComp->dispose(); |
| } |
| } |
| |
| void SAL_CALL WindowImpl::disposing (lang::EventObject const&) |
| throw (uno::RuntimeException) |
| { |
| if (mxWindow.is ()) |
| mxWindow.clear (); |
| } |
| |
| uno::Any WindowImpl::getProperty (char const* name) |
| { |
| if ( !this || !mxVclPeer.is() ) |
| return css::uno::Any(); |
| return mxVclPeer->getProperty |
| ( rtl::OUString( name, strlen( name ), RTL_TEXTENCODING_ASCII_US ) ); |
| } |
| |
| void WindowImpl::setProperty (char const *name, uno::Any any) |
| { |
| if ( !this || !mxVclPeer.is() ) |
| return; |
| mxVclPeer->setProperty |
| ( rtl::OUString( name, strlen( name ), RTL_TEXTENCODING_ASCII_US ), any ); |
| } |
| |
| void WindowImpl::redraw (bool resize) |
| { |
| uno::Reference <awt::XWindow> ref (mxWindow, uno::UNO_QUERY); |
| ::Window* window = VCLXWindow::GetImplementation (ref)->GetWindow (); |
| ::Window* parent = window->GetParent(); |
| ::Rectangle r = Rectangle (parent->GetPosPixel (), |
| parent->GetSizePixel ()); |
| parent->Invalidate (r, INVALIDATE_CHILDREN | INVALIDATE_NOCHILDREN ); |
| if (resize) |
| parent->SetPosSizePixel (0, 0, 1, 1, awt::PosSize::SIZE); |
| else |
| parent->SetPosSizePixel (0, 0, r.nRight - r.nLeft, r.nBottom - r.nTop, |
| awt::PosSize::SIZE); |
| } |
| |
| Window::Window( WindowImpl *pImpl ) |
| : mpImpl( pImpl ) |
| { |
| mpImpl->mvclWindow = GetVCLXWindow () ? GetWindow () : 0; |
| } |
| |
| Window::~Window() |
| { |
| /* likely to be an UNO object - with floating references */ |
| if (mpImpl) |
| mpImpl->wrapperGone (); |
| mpImpl = 0; |
| } |
| |
| ///IMPL_GET_IMPL( Control ); |
| |
| static ControlImpl* null_control_impl = 0; |
| |
| ControlImpl &Control::getImpl () const |
| { |
| if (ControlImpl* c = static_cast<ControlImpl *>(mpImpl)) |
| return *c; |
| return *null_control_impl; |
| } |
| |
| Control::~Control () |
| { |
| SetGetFocusHdl (Link ()); |
| SetLoseFocusHdl (Link ()); |
| } |
| |
| void Window::setRes (ResId const& res) |
| { |
| #if RESOURCE_PUBLISH_PROTECTED |
| // Resources are shut-off from use. Is that really necessary? |
| Resource &r = *GetWindow (); |
| r.GetRes (res); |
| #else /* !RESOURCE_PUBLISH_PROTECTED */ |
| //We *must* derive. Is this also really necessary? |
| //Resource r (res); |
| |
| // ugh, I wonder which solution is cleaner... |
| class Resource_open_up : public Resource |
| { |
| public: |
| Resource_open_up (ResId const& r) |
| : Resource (r) |
| { |
| } |
| static sal_Int32 GetLongRes (void *p) |
| { |
| return Resource::GetLongRes (p); |
| } |
| void* GetClassRes () |
| { |
| return Resource::GetClassRes (); |
| } |
| sal_Int32 ReadLongRes () |
| { |
| return Resource::ReadLongRes (); |
| } |
| UniString ReadStringRes () |
| { |
| return Resource::ReadStringRes (); |
| } |
| rtl::OString ReadByteStringRes() |
| { |
| return Resource::ReadByteStringRes(); |
| } |
| }; |
| |
| Resource_open_up r (res); |
| #endif /* !RESOURCE_PUBLISH_PROTECTED */ |
| sal_uInt32 mask = r.ReadLongRes (); |
| if (mask & WINDOW_HELPID) |
| SetHelpId (r.ReadByteStringRes()); |
| if ( mask & WINDOW_TEXT ) |
| SetText( r.ReadStringRes ()); |
| } |
| |
| void Window::SetParent( ::Window *parent ) |
| { |
| uno::Reference <awt::XWindow> ref( GetPeer(), uno::UNO_QUERY ); |
| if (VCLXWindow *vcl = VCLXWindow::GetImplementation( ref )) |
| if (::Window *window = vcl->GetWindow()) |
| window->SetParent( parent ); |
| } |
| |
| void Window::SetParent( Window *parent ) |
| { |
| /* Let's hear it for C++: poor man's dynamic binding. */ |
| parent->ParentSet (this); |
| } |
| |
| void Window::ParentSet (Window *window) |
| { |
| window->SetParent (GetWindow ()); |
| } |
| |
| Context *Window::getContext() |
| { |
| return this && mpImpl ? mpImpl->mpCtx : NULL; |
| } |
| |
| PeerHandle Window::GetPeer() const |
| { |
| if ( !mpImpl ) |
| return PeerHandle(); |
| return mpImpl->mxWindow; |
| } |
| |
| uno::Reference<awt::XWindow> Window::GetRef() const |
| { |
| return uno::Reference <awt::XWindow> ( GetPeer(), uno::UNO_QUERY ); |
| } |
| |
| VCLXWindow* Window::GetVCLXWindow() const |
| { |
| return VCLXWindow::GetImplementation( GetRef() ); |
| } |
| |
| ::Window* Window::GetWindow() const |
| { |
| return GetVCLXWindow()->GetWindow(); |
| } |
| |
| ::Window* Window::GetParent() const |
| { |
| return GetWindow()->GetParent(); |
| } |
| |
| void Window::SetHelpId( const rtl::OString& id ) |
| { |
| GetWindow()->SetHelpId( id ); |
| } |
| |
| const rtl::OString& Window::GetHelpId() const |
| { |
| return GetWindow()->GetHelpId(); |
| } |
| |
| void Window::EnterWait () |
| { |
| GetWindow()->EnterWait (); |
| } |
| void Window::LeaveWait () |
| { |
| GetWindow()->LeaveWait (); |
| } |
| bool Window::IsWait () const |
| { |
| return GetWindow()->IsWait (); |
| } |
| |
| bool Window::IsVisible () const |
| { |
| if (GetWindow ()) |
| return GetWindow()->IsVisible (); |
| return false; |
| } |
| |
| bool Window::HasChildPathFocus (bool systemWindow) const |
| { |
| return GetWindow()->HasChildPathFocus (systemWindow); |
| } |
| |
| void Window::SetPosPixel (Point const&) |
| { |
| } |
| |
| Point Window::GetPosPixel () const |
| { |
| return Point (); |
| } |
| |
| void Window::SetSizePixel (Size const&) |
| { |
| } |
| |
| void Window::SetPosSizePixel (Point const&, Size const&) |
| { |
| } |
| |
| Size Window::GetSizePixel () const |
| { |
| return Size (); |
| } |
| |
| // void Window::Enable (bool enable, bool child); |
| // { |
| // GetWindow ()->Enable (enable, child); |
| // } |
| |
| // void Window::Disable (bool child) |
| // { |
| // GetWindow ()->Disable (child); |
| // } |
| |
| bool Window::IsEnabled () const |
| { |
| return GetWindow ()->IsEnabled (); |
| // if (getImpl().mxWindow.is ()) |
| // return getImpl ().mxWindow->isEnabled (); |
| // return false; |
| } |
| |
| void Window::EnableInput (bool enable, bool child) |
| { |
| GetWindow ()->EnableInput (enable, child); |
| } |
| |
| bool Window::IsInputEnabled () const |
| { |
| return GetWindow ()->IsInputEnabled (); |
| } |
| |
| bool Window::HasFocus () const |
| { |
| return GetWindow ()->HasFocus (); |
| } |
| |
| Font& Window::GetFont () const |
| { |
| return const_cast <Font&> (GetWindow ()->GetFont ()); |
| } |
| |
| void Window::SetFont (Font const& font) |
| { |
| GetWindow ()->SetFont (font); |
| } |
| |
| void Window::Invalidate (sal_uInt8 flags) |
| { |
| GetWindow ()->Invalidate (flags); |
| } |
| |
| struct ToolkitVclPropsMap |
| { |
| WinBits vclStyle; |
| long initAttr; |
| const char *propName; |
| |
| // the value to give the prop to enable/disable it -- not the most brilliant |
| // type declaration and storage, but does the work... properties are |
| // either a boolean or a short since they are either a directly wrappers for |
| // a WinBit, or aggregates related (like Align for WB_LEFT, _RIGHT and _CENTER). |
| bool isBoolean; |
| short enableProp, disableProp; |
| }; |
| |
| #define TYPE_BOOL true |
| #define TYPE_SHORT false |
| #define NOTYPE 0 |
| static const ToolkitVclPropsMap toolkitVclPropsMap[] = |
| { |
| { WB_BORDER, awt::WindowAttribute::BORDER, "Border", TYPE_SHORT, 1, 0 }, |
| { WB_NOBORDER, awt::VclWindowPeerAttribute::NOBORDER, "Border", TYPE_SHORT, 0, 1 }, |
| { WB_SIZEABLE, awt::WindowAttribute::SIZEABLE, NULL, NOTYPE, 0, 0 }, |
| { WB_MOVEABLE, awt::WindowAttribute::MOVEABLE, NULL, NOTYPE, 0, 0 }, |
| { WB_CLOSEABLE, awt::WindowAttribute::CLOSEABLE, NULL, NOTYPE, 0, 0 }, |
| |
| { WB_HSCROLL, awt::VclWindowPeerAttribute::HSCROLL, NULL, NOTYPE, 0, 0 }, |
| { WB_VSCROLL, awt::VclWindowPeerAttribute::VSCROLL, NULL, NOTYPE, 0, 0 }, |
| { WB_LEFT, awt::VclWindowPeerAttribute::LEFT, "Align", TYPE_SHORT, 0, 0 }, |
| { WB_CENTER, awt::VclWindowPeerAttribute::CENTER, "Align", TYPE_SHORT, 1, 0 }, |
| { WB_RIGHT, awt::VclWindowPeerAttribute::RIGHT, "Align", TYPE_SHORT, 2, 0 }, |
| { WB_SPIN, awt::VclWindowPeerAttribute::SPIN, NULL, NOTYPE, 0, 0 }, |
| { WB_SORT, awt::VclWindowPeerAttribute::SORT, NULL, NOTYPE, 0, 0 }, |
| { WB_DROPDOWN, awt::VclWindowPeerAttribute::DROPDOWN, "Dropdown", TYPE_BOOL, 1, 0 }, |
| { WB_DEFBUTTON, awt::VclWindowPeerAttribute::DEFBUTTON, "DefaultButton", TYPE_BOOL, 1, 0 }, |
| { WB_READONLY, awt::VclWindowPeerAttribute::READONLY, NULL, NOTYPE, 0, 0 }, |
| { WB_CLIPCHILDREN, awt::VclWindowPeerAttribute::CLIPCHILDREN, NULL, NOTYPE, 0, 0 }, |
| { WB_GROUP, awt::VclWindowPeerAttribute::GROUP, NULL, NOTYPE, 0, 0 }, |
| |
| { WB_OK, awt::VclWindowPeerAttribute::OK, NULL, NOTYPE, 0, 0 }, |
| { WB_OK_CANCEL, awt::VclWindowPeerAttribute::OK_CANCEL, NULL, NOTYPE, 0, 0 }, |
| { WB_YES_NO, awt::VclWindowPeerAttribute::YES_NO, NULL, NOTYPE, 0, 0 }, |
| { WB_YES_NO_CANCEL, awt::VclWindowPeerAttribute::YES_NO_CANCEL, NULL, NOTYPE, 1, 0 }, |
| { WB_RETRY_CANCEL, awt::VclWindowPeerAttribute::RETRY_CANCEL, NULL, NOTYPE, 1, 0 }, |
| { WB_DEF_OK, awt::VclWindowPeerAttribute::DEF_OK, NULL, NOTYPE, 0, 0 }, |
| { WB_DEF_CANCEL, awt::VclWindowPeerAttribute::DEF_CANCEL, NULL, NOTYPE, 1, 0 }, |
| { WB_DEF_RETRY, awt::VclWindowPeerAttribute::DEF_RETRY, NULL, NOTYPE, 0, 0 }, |
| { WB_DEF_YES, awt::VclWindowPeerAttribute::DEF_YES, NULL, NOTYPE, 0, 0 }, |
| { WB_DEF_NO, awt::VclWindowPeerAttribute::DEF_NO, NULL, NOTYPE, 0, 0 }, |
| |
| { WB_AUTOHSCROLL, awt::VclWindowPeerAttribute::AUTOHSCROLL, "AutoHScroll", TYPE_BOOL, 1, 0 }, |
| { WB_AUTOVSCROLL, awt::VclWindowPeerAttribute::AUTOVSCROLL, "AutoVScroll", TYPE_BOOL, 1, 0 }, |
| |
| { WB_WORDBREAK, 0, "MultiLine", TYPE_BOOL, 1, 0 }, |
| { WB_NOPOINTERFOCUS, 0, "FocusOnClick", TYPE_BOOL, 1, 0 }, |
| { WB_TOGGLE, 0, "Toggle", TYPE_BOOL, 1, 0 }, |
| { WB_REPEAT, 0, "Repeat", TYPE_BOOL, 1, 0 }, |
| { WB_NOHIDESELECTION, 0, "HideInactiveSelection", TYPE_BOOL, 1, 0 }, |
| }; |
| #undef TYPE_BOOL |
| #undef TYPE_SHORT |
| #undef NOTYPE |
| |
| static const int toolkitVclPropsMapLen = |
| sizeof( toolkitVclPropsMap ) / sizeof( ToolkitVclPropsMap ); |
| |
| void Window::SetStyle( WinBits nStyle ) |
| { |
| uno::Reference< awt::XVclWindowPeer > xPeer = mpImpl->mxVclPeer; |
| for (int i = 0; i < toolkitVclPropsMapLen; i++) |
| { |
| if ( toolkitVclPropsMap[ i ].propName ) |
| { |
| short nValue; |
| if ( nStyle & toolkitVclPropsMap[ i ].vclStyle ) |
| nValue = toolkitVclPropsMap[ i ].enableProp; |
| else |
| nValue = toolkitVclPropsMap[ i ].disableProp; |
| uno::Any aValue; |
| if ( toolkitVclPropsMap[ i ].isBoolean ) |
| aValue = uno::makeAny( (bool) nValue ); |
| else |
| aValue = uno::makeAny( (short) nValue ); |
| mpImpl->setProperty( toolkitVclPropsMap[ i ].propName, aValue ); |
| } |
| } |
| } |
| |
| WinBits Window::GetStyle() |
| { |
| uno::Reference< awt::XVclWindowPeer > xPeer = mpImpl->mxVclPeer; |
| WinBits ret = 0; |
| for (int i = 0; i < toolkitVclPropsMapLen; i++) |
| { |
| if ( toolkitVclPropsMap[ i ].propName ) |
| { |
| short nValue = 0; |
| if ( toolkitVclPropsMap[ i ].isBoolean ) |
| { |
| bool bValue = false; |
| mpImpl->getProperty( toolkitVclPropsMap[ i ].propName ) >>= bValue; |
| nValue = bValue ? 1 : 0; |
| } |
| else |
| mpImpl->getProperty( toolkitVclPropsMap[ i ].propName ) >>= nValue; |
| if ( nValue == toolkitVclPropsMap[ i ].enableProp ) |
| ret |= toolkitVclPropsMap[i].vclStyle; |
| } |
| } |
| return ret; |
| } |
| |
| /* Unpleasant way to get an xToolkit pointer ... */ |
| uno::Reference< awt::XToolkit > getToolkit() |
| { |
| static uno::Reference< awt::XToolkit > xToolkit; |
| if (!xToolkit.is()) |
| { |
| // Urgh ... |
| xToolkit = uno::Reference< awt::XToolkit >( |
| ::comphelper::getProcessServiceFactory()->createInstance( |
| OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.awt.Toolkit" ) ) ), |
| uno::UNO_QUERY ); |
| if ( !xToolkit.is() ) |
| throw uno::RuntimeException( |
| OUString( RTL_CONSTASCII_USTRINGPARAM( "failed to create toolkit!") ), |
| uno::Reference< uno::XInterface >() ); |
| } |
| return xToolkit; |
| } |
| |
| PeerHandle Window::CreatePeer( Window *parent, WinBits nStyle, const char *pName) |
| { |
| long nWinAttrbs = 0; |
| for (int i = 0; i < toolkitVclPropsMapLen; i++) |
| if ( nStyle & toolkitVclPropsMap[ i ].vclStyle ) |
| nWinAttrbs |= toolkitVclPropsMap[ i ].initAttr; |
| |
| return layoutimpl::WidgetFactory::createWidget (getToolkit(), parent->GetPeer(), OUString::createFromAscii( pName ), nWinAttrbs); |
| } |
| |
| void Window::Enable( bool bEnable ) |
| { |
| if ( !getImpl().mxWindow.is() ) |
| return; |
| getImpl().mxWindow->setEnable( bEnable ); |
| } |
| |
| void Window::Show( bool bVisible ) |
| { |
| if ( !getImpl().mxWindow.is() ) |
| return; |
| getImpl().mxWindow->setVisible( bVisible ); |
| if (!bVisible) |
| getImpl ().bFirstTimeVisible = true; |
| else if (GetParent() && getImpl().bFirstTimeVisible) |
| { |
| getImpl().redraw (); |
| getImpl().bFirstTimeVisible = false; |
| } |
| } |
| |
| void Window::GrabFocus() |
| { |
| if ( !getImpl().mxWindow.is() ) |
| return; |
| getImpl().mxWindow->setFocus(); |
| } |
| |
| void Window::SetUpdateMode(bool mode) |
| { |
| GetWindow()->SetUpdateMode( mode ); |
| } |
| |
| void Window::SetPointer( Pointer const& pointer ) |
| { |
| GetWindow()->SetPointer( pointer ); |
| } |
| |
| Pointer const& Window::GetPointer() const |
| { |
| return GetWindow()->GetPointer(); |
| } |
| |
| void Window::SetText( OUString const& str ) |
| { |
| GetWindow()->SetText( str ); |
| } |
| |
| String Window::GetText() const |
| { |
| return GetWindow()->GetText(); |
| } |
| |
| sal_Int32 Window::GetCtrlTextWidth (OUString const&) const |
| { |
| return 0; |
| } |
| |
| sal_Int32 Window::GetTextHeight () const |
| { |
| return 0; |
| } |
| |
| Size Window::LogicToPixel( Size const& size, MapMode const&) const |
| { |
| return size; |
| } |
| |
| ControlImpl::ControlImpl (Context *context, const PeerHandle &peer, Window *window) |
| : WindowImpl( context, peer, window ) |
| { |
| } |
| |
| ControlImpl::~ControlImpl () |
| { |
| if ((!!mGetFocusHdl || !!mLoseFocusHdl) && mxWindow.is ()) |
| /* Disposing will be done @ VCLXWindow::dispose () maFocusListeners.disposeAndClear() |
| don't do it twice */ |
| mxWindow.clear (); |
| } |
| |
| void ControlImpl::SetGetFocusHdl (Link const& link) |
| { |
| if (!mLoseFocusHdl || !link) |
| UpdateListening (link); |
| mGetFocusHdl = link; |
| } |
| |
| Link& ControlImpl::GetGetFocusHdl () |
| { |
| return mGetFocusHdl; |
| } |
| |
| void ControlImpl::SetLoseFocusHdl (Link const& link) |
| { |
| if (!mGetFocusHdl || !link) |
| UpdateListening (link); |
| mLoseFocusHdl = link; |
| } |
| |
| Link& ControlImpl::GetLoseFocusHdl () |
| { |
| return mGetFocusHdl; |
| } |
| |
| void ControlImpl::UpdateListening (Link const& link) |
| { |
| if (!link && (!!mGetFocusHdl || !!mLoseFocusHdl) |
| && (!mGetFocusHdl || !mLoseFocusHdl)) |
| mxWindow->removeFocusListener (this); |
| else if (!!link && !mGetFocusHdl && !mLoseFocusHdl) |
| mxWindow->addFocusListener (this); |
| } |
| |
| void SAL_CALL ControlImpl::disposing (lang::EventObject const&) |
| throw (uno::RuntimeException) |
| { |
| /// mxWindow.clear (); |
| } |
| |
| void SAL_CALL ControlImpl::focusGained (awt::FocusEvent const&) |
| throw (uno::RuntimeException) |
| { |
| mGetFocusHdl.Call (mpWindow); |
| } |
| |
| void SAL_CALL ControlImpl::focusLost (awt::FocusEvent const&) |
| throw (uno::RuntimeException) |
| { |
| mLoseFocusHdl.Call (mpWindow); |
| } |
| |
| Link& Control::GetGetFocusHdl () |
| { |
| return getImpl ().GetGetFocusHdl (); |
| } |
| |
| void Control::SetGetFocusHdl (Link const& link) |
| { |
| if (&getImpl () && getImpl().mxWindow.is ()) |
| getImpl ().SetGetFocusHdl (link); |
| } |
| |
| Link& Control::GetLoseFocusHdl () |
| { |
| return getImpl ().GetLoseFocusHdl (); |
| } |
| |
| void Control::SetLoseFocusHdl (Link const& link) |
| { |
| if (&getImpl () && getImpl().mxWindow.is ()) |
| getImpl ().SetLoseFocusHdl (link); |
| } |
| |
| class DialogImpl : public WindowImpl |
| { |
| public: |
| uno::Reference< awt::XDialog2 > mxDialog; |
| DialogImpl( Context *context, PeerHandle const &peer, Window *window ); |
| }; |
| |
| DialogImpl::DialogImpl( Context *context, const PeerHandle &peer, Window *window ) |
| : WindowImpl( context, peer, window ) |
| , mxDialog( peer, uno::UNO_QUERY ) |
| { |
| } |
| |
| Dialog::Dialog( Window *parent, const char *xml_file, const char *id, sal_uInt32 nId ) |
| : Context( xml_file ) |
| , Window( new DialogImpl( this, Context::GetPeerHandle( id, nId ), this ) ) |
| , bConstruct (true) |
| { |
| if ( parent ) |
| SetParent( parent ); |
| } |
| |
| Dialog::Dialog( ::Window *parent, const char *xml_file, const char *id, sal_uInt32 nId ) |
| : Context( xml_file ) |
| , Window( new DialogImpl( this, Context::GetPeerHandle( id, nId ), this ) ) |
| { |
| if ( parent ) |
| SetParent( parent ); |
| } |
| |
| Dialog::~Dialog () |
| { |
| } |
| |
| IMPL_GET_WINDOW (Dialog); |
| IMPL_GET_IMPL (Dialog); |
| |
| #define MX_DIALOG if (getImpl ().mxDialog.is ()) getImpl ().mxDialog |
| #define RETURN_MX_DIALOG if (getImpl ().mxDialog.is ()) return getImpl ().mxDialog |
| |
| short Dialog::Execute() |
| { |
| RETURN_MX_DIALOG->execute (); |
| return -1; |
| } |
| |
| void Dialog::EndDialog( long result ) |
| { |
| MX_DIALOG->endDialog (result); |
| } |
| |
| void Dialog::SetText( OUString const& str ) |
| { |
| SetTitle (str); |
| } |
| |
| void Dialog::SetTitle( OUString const& str ) |
| { |
| MX_DIALOG->setTitle (str); |
| } |
| |
| bool Dialog::Close () |
| { |
| EndDialog (false); |
| return true; |
| } |
| |
| long Dialog::Notify (NotifyEvent& event) |
| { |
| return GetDialog ()->Notify (event); |
| } |
| |
| void Dialog::Initialize (SfxChildWinInfo*) |
| { |
| } |
| |
| #define MESSAGE_BOX_MEMBER_INIT\ |
| Dialog (parent, xml_file, id)\ |
| , imageError (this, "FI_ERROR")\ |
| , imageInfo (this, "FI_INFO")\ |
| , imageQuery (this, "FI_QUERY")\ |
| , imageWarning (this, "FI_WARNING")\ |
| , messageText (this, "FT_MESSAGE")\ |
| , cancelButton (this, "BTN_CANCEL")\ |
| , helpButton (this, "BTN_HELP")\ |
| , ignoreButton (this, "BTN_IGNORE")\ |
| , noButton (this, "BTN_NO")\ |
| , retryButton (this, "BTN_RETRY")\ |
| , yesButton (this, "BTN_YES") |
| |
| MessageBox::MessageBox (::Window *parent, char const* message, |
| char const* yes, char const* no, const rtl::OString& help_id, |
| char const* xml_file, char const* id) |
| : MESSAGE_BOX_MEMBER_INIT |
| { |
| ignoreButton.Hide (); |
| retryButton.Hide (); |
| init (message, yes, no, help_id); |
| } |
| |
| MessageBox::MessageBox (::Window *parent, OUString const& message, |
| OUString yes, OUString no, const rtl::OString& help_id, |
| char const* xml_file, char const* id) |
| : MESSAGE_BOX_MEMBER_INIT |
| { |
| ignoreButton.Hide (); |
| retryButton.Hide (); |
| init (message, yes, no, help_id); |
| } |
| |
| #if !defined (__GNUC__) |
| #define __PRETTY_FUNCTION__ __FUNCTION__ |
| #endif /* !__GNUC__ */ |
| |
| MessageBox::MessageBox (::Window *parent, WinBits bits, char const* message, |
| char const* yes, char const* no, const rtl::OString& help_id, |
| char const* xml_file, char const* id) |
| : MESSAGE_BOX_MEMBER_INIT |
| { |
| // HIG suggests using verbs instead of yes/no/retry etc. |
| // This constructor provides client-code compatibility: Client code should be fixed. |
| #ifndef __SUNPRO_CC |
| OSL_TRACE ("%s: warning, deprecated vcl/Messbox compatibility", __PRETTY_FUNCTION__); |
| #endif |
| bits_init (bits, OUString::createFromAscii (message), OUString::createFromAscii (yes), OUString::createFromAscii (no), help_id); |
| } |
| |
| MessageBox::MessageBox (::Window *parent, WinBits bits, OUString const& message, |
| OUString yes, OUString no, const rtl::OString& help_id, |
| char const* xml_file, char const* id) |
| : MESSAGE_BOX_MEMBER_INIT |
| { |
| // HIG suggests using verbs instead of yes/no/retry etc. |
| // This constructor provides client-code compatibility: Client code should be fixed. |
| #ifndef __SUNPRO_CC |
| OSL_TRACE ("%s: warning, deprecated vcl/Messbox compatibility", __PRETTY_FUNCTION__); |
| #endif |
| bits_init (bits, message, yes, no, help_id); |
| } |
| |
| void MessageBox::bits_init (WinBits bits, OUString const& message, |
| OUString yes, OUString no, const rtl::OString& help_id) |
| { |
| if ( bits & ( WB_OK_CANCEL | WB_OK )) |
| yes = Button::GetStandardText ( BUTTON_OK ); |
| if ( bits & (WB_YES_NO | WB_YES_NO_CANCEL )) |
| { |
| yes = Button::GetStandardText ( BUTTON_YES ); |
| no = Button::GetStandardText ( BUTTON_NO ); |
| } |
| if (! (bits & (WB_RETRY_CANCEL | WB_YES_NO_CANCEL | WB_ABORT_RETRY_IGNORE ))) |
| cancelButton.Hide (); |
| if (! (bits & (WB_RETRY_CANCEL | WB_ABORT_RETRY_IGNORE))) |
| retryButton.Hide (); |
| if ( bits & WB_ABORT_RETRY_IGNORE ) |
| cancelButton.SetText ( Button::GetStandardText (BUTTON_ABORT)); |
| else |
| ignoreButton.Hide (); |
| if ( !(bits & ( WB_OK | WB_OK_CANCEL | WB_YES_NO | WB_YES_NO_CANCEL))) |
| yesButton.Hide (); |
| if ( !(bits & ( WB_YES_NO | WB_YES_NO_CANCEL))) |
| noButton.Hide (); |
| |
| init (message, yes, no, help_id); |
| } |
| |
| void MessageBox::init (char const* message, char const* yes, char const* no, const rtl::OString& help_id) |
| { |
| init ( OUString::createFromAscii (message), OUString::createFromAscii (yes), OUString::createFromAscii (no), help_id); |
| } |
| |
| void MessageBox::init (OUString const& message, OUString const& yes, OUString const& no, const rtl::OString& help_id) |
| { |
| imageError.Hide (); |
| imageInfo.Hide (); |
| imageQuery.Hide (); |
| imageWarning.Hide (); |
| if (message.getLength ()) |
| messageText.SetText (message); |
| if (yes.getLength ()) |
| { |
| yesButton.SetText (yes); |
| if (yes != OUString (Button::GetStandardText (BUTTON_OK)) |
| && yes != OUString (Button::GetStandardText (BUTTON_YES))) |
| SetTitle (yes); |
| if (no.getLength ()) |
| noButton.SetText (no); |
| else |
| noButton.Hide (); |
| } |
| if( !help_id.isEmpty()) |
| SetHelpId (help_id); |
| else |
| helpButton.Hide (); |
| } |
| |
| #undef MESSAGE_BOX_IMPL |
| #define MESSAGE_BOX_IMPL(Name)\ |
| Name##Box::Name##Box (::Window *parent, char const* message,\ |
| char const* yes, char const* no, const rtl::OString& help_id,\ |
| char const* xml_file, char const* id)\ |
| : MessageBox (parent, message, yes, no, help_id, xml_file, id)\ |
| {\ |
| image##Name.Show ();\ |
| }\ |
| Name##Box::Name##Box (::Window *parent, OUString const& message,\ |
| OUString yes, OUString no, const rtl::OString& help_id,\ |
| char const* xml_file, char const* id)\ |
| : MessageBox (parent, message, yes, no, help_id, xml_file, id)\ |
| {\ |
| image##Name.Show ();\ |
| }\ |
| Name##Box::Name##Box (::Window *parent, WinBits bits, char const* message,\ |
| char const* yes, char const* no, const rtl::OString& help_id,\ |
| char const* xml_file, char const* id)\ |
| : MessageBox (parent, bits, message, yes, no, help_id, xml_file, id)\ |
| {\ |
| image##Name.Show ();\ |
| }\ |
| Name##Box::Name##Box (::Window *parent, WinBits bits, OUString const& message,\ |
| OUString yes, OUString no, const rtl::OString& help_id,\ |
| char const* xml_file, char const* id)\ |
| : MessageBox (parent, bits, message, yes, no, help_id, xml_file, id)\ |
| {\ |
| image##Name.Show ();\ |
| } |
| |
| MESSAGE_BOX_IMPL (Error); |
| MESSAGE_BOX_IMPL (Info); |
| MESSAGE_BOX_IMPL (Query); |
| MESSAGE_BOX_IMPL (Warning); |
| |
| class TabControlImpl |
| : public ControlImpl |
| , public ::cppu::WeakImplHelper1 <awt::XTabListener> |
| { |
| Link mActivatePageHdl; |
| Link mDeactivatePageHdl; |
| |
| public: |
| uno::Reference <awt::XSimpleTabController> mxTabControl; |
| TabControlImpl (Context *context, const PeerHandle &peer, Window *window) |
| : ControlImpl (context, peer, window) |
| , mxTabControl (peer, uno::UNO_QUERY) |
| { |
| } |
| |
| virtual void SAL_CALL disposing (lang::EventObject const& e) |
| throw (uno::RuntimeException) |
| { |
| ControlImpl::disposing (e); |
| mxTabControl.clear (); |
| } |
| |
| Link& GetActivatePageHdl () |
| { |
| return mActivatePageHdl; |
| } |
| |
| void SetActivatePageHdl (Link const& link) |
| { |
| if (!mDeactivatePageHdl || !link) |
| UpdateListening (link); |
| mActivatePageHdl = link; |
| } |
| |
| Link& GetDeactivatePageHdl () |
| { |
| return mDeactivatePageHdl; |
| } |
| |
| void SetDeactivatePageHdl (Link const& link) |
| { |
| if (!mActivatePageHdl || !link) |
| UpdateListening (link); |
| mDeactivatePageHdl = link; |
| } |
| |
| void UpdateListening (Link const& link) |
| { |
| if (!link && (!!mActivatePageHdl || !!mDeactivatePageHdl)) |
| mxTabControl->removeTabListener (this); |
| else if (!!link && !mActivatePageHdl && !mDeactivatePageHdl) |
| mxTabControl->addTabListener (this); |
| } |
| |
| void SAL_CALL activated (sal_Int32) |
| throw (uno::RuntimeException) |
| { |
| mActivatePageHdl.Call (mpWindow); |
| } |
| |
| void SAL_CALL deactivated (sal_Int32) |
| throw (uno::RuntimeException) |
| { |
| mDeactivatePageHdl.Call (mpWindow); |
| } |
| |
| void SAL_CALL inserted (sal_Int32) |
| throw (uno::RuntimeException) |
| { |
| } |
| |
| void SAL_CALL removed (sal_Int32) |
| throw (uno::RuntimeException) |
| { |
| } |
| |
| void SAL_CALL changed (sal_Int32, uno::Sequence <beans::NamedValue> const&) |
| throw (uno::RuntimeException) |
| { |
| } |
| }; |
| |
| IMPL_GET_WINDOW (TabControl); |
| IMPL_GET_LAYOUT_VCLXWINDOW (TabControl); |
| |
| #define MX_TABCONTROL if (getImpl ().mxTabControl.is ()) getImpl ().mxTabControl |
| #define RETURN_MX_TABCONTROL if (getImpl ().mxTabControl.is ()) return getImpl ().mxTabControl |
| |
| TabControl::~TabControl () |
| { |
| SetActivatePageHdl (Link ()); |
| SetDeactivatePageHdl (Link ()); |
| } |
| |
| void TabControl::InsertPage (sal_uInt16 id, OUString const& title, sal_uInt16 pos) |
| { |
| (void) pos; |
| // GetTabControl ()->InsertPage (id, title, pos); |
| // GetTabControl ()->SetTabPage (id, new ::TabPage (GetTabControl ())); |
| |
| MX_TABCONTROL->insertTab (); |
| SetCurPageId (id); |
| |
| #if 1 // colour me loc productive -- NOT |
| #define ADD_PROP( seq, i, name, val )\ |
| { \ |
| beans::NamedValue value; \ |
| value.Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( name ) ); \ |
| value.Value = uno::makeAny( val ); \ |
| seq[i] = value; \ |
| } |
| |
| uno::Sequence< beans::NamedValue > seq (1); |
| ADD_PROP ( seq, 0, "Title", OUString (title) ); |
| MX_TABCONTROL->setTabProps (id, seq); |
| #else |
| GetTabPage (id)->SetText (title); |
| #endif |
| |
| #if 0 |
| /// This so seems the right solution, but it makes the buttons of the |
| /// tabdialog move up |
| |
| ::TabPage *page = GetTabPage (id); |
| if (Window *w = dynamic_cast <Window*> (page)) |
| { |
| w->SetParent (this); |
| //GetVCLXTabControl ()->Box_Base::addChild (uno::Reference <awt::XLayoutConstrains> (w->GetPeer (), uno::UNO_QUERY)); |
| //GetVCLXTabControl ()->Box_Base::AddChild (uno::Reference <awt::XLayoutConstrains> (w->GetPeer (), uno::UNO_QUERY)); |
| //GetVCLXTabControl ()->AddChild (w); |
| //GetVCLXTabControl ()->AddChild (uno::Reference <awt::XLayoutConstrains> (w->GetPeer (), uno::UNO_QUERY)); |
| //uno::Reference <uno::XInterface> x (page->GetWindowPeer()); |
| //GetVCLXTabControl ()->AddChild (uno::Reference <awt::XLayoutConstrains> (page->::Window::GetWindowPeer (), uno::UNO_QUERY)); |
| //GetVCLXTabControl ()->AddChild (uno::Reference <awt::XLayoutConstrains> (page->GetComponentInterface (), uno::UNO_QUERY)); |
| } |
| getImpl ().redraw (); |
| #endif |
| } |
| void TabControl::RemovePage (sal_uInt16 id) |
| { |
| GetTabControl ()->RemovePage (id); |
| } |
| sal_uInt16 TabControl::GetPageCount () const |
| { |
| return GetTabControl ()->GetPageCount (); |
| } |
| sal_uInt16 TabControl::GetPageId (sal_uInt16 pos) const |
| { |
| return GetTabControl ()->GetPageId (pos); |
| } |
| sal_uInt16 TabControl::GetPagePos (sal_uInt16 id) const |
| { |
| getImpl ().redraw (); |
| return GetTabControl ()->GetPagePos (id); |
| } |
| void TabControl::SetCurPageId (sal_uInt16 id) |
| { |
| getImpl ().redraw (); |
| GetTabControl ()->SetCurPageId (id); |
| } |
| sal_uInt16 TabControl::GetCurPageId () const |
| { |
| return GetTabControl ()->GetCurPageId (); |
| } |
| void TabControl::SetTabPage (sal_uInt16 id, ::TabPage* page) |
| { |
| GetTabControl ()->SetTabPage (id, page); |
| |
| #if 0 |
| /// This so seems the right solution, but it makes the buttons of the |
| /// tabdialog move up |
| if (Window *w = dynamic_cast <Window*> (page)) |
| { |
| w->SetParent (this); |
| //GetVCLXTabControl ()->Box_Base::addChild (uno::Reference <awt::XLayoutConstrains> (w->GetPeer (), uno::UNO_QUERY)); |
| //GetVCLXTabControl ()->Box_Base::AddChild (uno::Reference <awt::XLayoutConstrains> (w->GetPeer (), uno::UNO_QUERY)); |
| //GetVCLXTabControl ()->AddChild (w); |
| //GetVCLXTabControl ()->AddChild (uno::Reference <awt::XLayoutConstrains> (w->GetPeer (), uno::UNO_QUERY)); |
| //GetVCLXTabControl ()->AddChild (uno::Reference <awt::XLayoutConstrains> (page->GetWindowPeer (), uno::UNO_QUERY)); |
| //GetVCLXTabControl ()->AddChild (uno::Reference <awt::XLayoutConstrains> (page->GetComponentInterface (), uno::UNO_QUERY)); |
| } |
| #endif |
| getImpl ().redraw (); |
| } |
| ::TabPage* TabControl::GetTabPage (sal_uInt16 id) const |
| { |
| return GetTabControl ()->GetTabPage (id); |
| } |
| void TabControl::SetActivatePageHdl (Link const& link) |
| { |
| if (&getImpl () && getImpl().mxTabControl.is ()) |
| getImpl ().SetActivatePageHdl (link); |
| } |
| Link& TabControl::GetActivatePageHdl () const |
| { |
| return getImpl ().GetActivatePageHdl (); |
| } |
| void TabControl::SetDeactivatePageHdl (Link const& link) |
| { |
| if (&getImpl () && getImpl().mxTabControl.is ()) |
| getImpl ().SetDeactivatePageHdl (link); |
| } |
| Link& TabControl::GetDeactivatePageHdl () const |
| { |
| return getImpl ().GetDeactivatePageHdl (); |
| } |
| void TabControl::SetTabPageSizePixel (Size const& size) |
| { |
| GetTabControl ()->SetTabPageSizePixel (size); |
| // GetParent()->SetSizePixel (size); |
| // GetWindow()->SetSizePixel (size); |
| //GetVCLXTabControl->SetTabSize (size); |
| } |
| Size TabControl::GetTabPageSizePixel () const |
| { |
| #if 0 |
| //return GetTabControl ()->GetTabPageSizePixel (); |
| static size_t const tab_page_first_index = 1; |
| for (size_t i = 0; i < GetPageCount (); i++) |
| { |
| ::TabPage *p = GetTabPage (i + tab_page_first_index); |
| //if (dynamic_cast<Windowt*> (p)) |
| if (i) // URG |
| return p->GetOptimalSize (WINDOWSIZE_MINIMUM); |
| } |
| #endif |
| return GetTabControl ()->GetTabPageSizePixel (); |
| } |
| |
| IMPL_CONSTRUCTORS (TabControl, Control, "tabcontrol"); |
| IMPL_GET_IMPL (TabControl); |
| |
| class TabPageImpl : public WindowImpl |
| { |
| public: |
| uno::Reference< awt::XWindow > mxTabPage; |
| TabPageImpl( Context *context, const PeerHandle &peer, Window *window ) |
| : WindowImpl( context, peer, window ) |
| , mxTabPage( peer, uno::UNO_QUERY ) |
| { |
| } |
| }; |
| |
| ::Window* TabPage::global_parent = 0; |
| TabControl* TabPage::global_tabcontrol = 0; |
| |
| IMPL_GET_IMPL( TabPage ); |
| |
| TabPage::TabPage( Window *parent, const char *xml_file, const char *id, sal_uInt32 nId) |
| : Context( xml_file ) |
| , Window( new TabPageImpl( this, Context::GetPeerHandle( id, nId ), this ) ) |
| { |
| if ( parent ) |
| SetParent( parent ); |
| } |
| |
| TabPage::TabPage( ::Window *parent, const char *xml_file, const char *id, sal_uInt32 nId) |
| : Context( xml_file ) |
| , Window( new TabPageImpl( this, Context::GetPeerHandle( id, nId ), this ) ) |
| { |
| if ( parent ) |
| SetParent( parent ); |
| } |
| |
| TabPage::~TabPage() |
| { |
| delete GetTabPage(); |
| } |
| |
| IMPL_GET_WINDOW( TabPage ); |
| |
| void TabPage::ActivatePage() |
| { |
| } |
| |
| void TabPage::DeactivatePage() |
| { |
| } |
| |
| class FixedLineImpl : public ControlImpl |
| { |
| public: |
| FixedLineImpl( Context *context, const PeerHandle &peer, Window *window ) |
| : ControlImpl( context, peer, window ) |
| { |
| } |
| }; |
| |
| IMPL_CONSTRUCTORS( FixedLine, Control, "hfixedline" ); |
| IMPL_GET_IMPL( FixedLine ); |
| |
| bool FixedLine::IsEnabled() const |
| { |
| //FIXME |
| return true; |
| } |
| |
| class FixedTextImpl : public ControlImpl |
| { |
| public: |
| uno::Reference< awt::XFixedText > mxFixedText; |
| FixedTextImpl( Context *context, const PeerHandle &peer, Window *window ) |
| : ControlImpl( context, peer, window ) |
| , mxFixedText( peer, uno::UNO_QUERY ) |
| { |
| } |
| |
| ~FixedTextImpl (); |
| |
| virtual void SAL_CALL disposing( lang::EventObject const& e ) |
| throw (uno::RuntimeException); |
| }; |
| |
| FixedTextImpl::~FixedTextImpl () |
| { |
| } |
| |
| void SAL_CALL FixedTextImpl::disposing( lang::EventObject const& e ) |
| throw (uno::RuntimeException) |
| { |
| ControlImpl::disposing (e); |
| mxFixedText.clear (); |
| } |
| |
| FixedText::~FixedText () |
| { |
| } |
| |
| IMPL_CONSTRUCTORS( FixedText, Control, "fixedtext" ); |
| IMPL_GET_IMPL( FixedText ); |
| |
| void FixedText::SetText( OUString const& rStr ) |
| { |
| if ( !getImpl().mxFixedText.is() ) |
| return; |
| getImpl().mxFixedText->setText( rStr ); |
| } |
| |
| class FixedInfoImpl : public FixedTextImpl |
| { |
| public: |
| FixedInfoImpl( Context *context, const PeerHandle &peer, Window *window ) |
| : FixedTextImpl( context, peer, window ) |
| { |
| } |
| }; |
| |
| IMPL_CONSTRUCTORS( FixedInfo, FixedText, "fixedinfo" ); |
| IMPL_GET_IMPL( FixedInfo ); |
| |
| class ProgressBarImpl : public ControlImpl |
| { |
| public: |
| uno::Reference< awt::XProgressBar > mxProgressBar; |
| ProgressBarImpl( Context *context, const PeerHandle &peer, Window *window ) |
| : ControlImpl( context, peer, window ) |
| , mxProgressBar( peer, uno::UNO_QUERY ) |
| { |
| } |
| |
| virtual void SAL_CALL disposing( lang::EventObject const& e ) |
| throw (uno::RuntimeException) |
| { |
| ControlImpl::disposing (e); |
| mxProgressBar.clear (); |
| } |
| }; |
| |
| |
| class FixedImageImpl: public ControlImpl |
| { |
| public: |
| uno::Reference< graphic::XGraphic > mxGraphic; |
| FixedImageImpl( Context *context, const PeerHandle &peer, Window *window) |
| // const char *pName ) |
| : ControlImpl( context, peer, window ) |
| //, mxGraphic( layoutimpl::loadGraphic( pName ) ) |
| , mxGraphic( peer, uno::UNO_QUERY ) |
| { |
| if ( !mxGraphic.is() ) |
| { |
| DBG_ERROR( "ERROR: failed to load image: `%s'" /*, pName*/ ); |
| } |
| #if 0 |
| else |
| getImpl().mxGraphic->...(); |
| #endif |
| } |
| }; |
| |
| IMPL_CONSTRUCTORS( FixedImage, Control, "fixedimage" ); |
| IMPL_GET_IMPL( FixedImage ) |
| |
| void FixedImage::setImage( ::Image const& i ) |
| { |
| (void) i; |
| if ( !getImpl().mxGraphic.is() ) |
| return; |
| //FIXME: hack moved to proplist |
| //getImpl().mxGraphic = |
| } |
| |
| #if 0 |
| |
| FixedImage::FixedImage( const char *pName ) |
| : pImpl( new FixedImageImpl( pName ) ) |
| { |
| } |
| |
| FixedImage::~FixedImage() |
| { |
| delete pImpl; |
| } |
| |
| #endif |
| |
| |
| IMPL_CONSTRUCTORS( ProgressBar, Control, "ProgressBar" ); |
| IMPL_GET_IMPL( ProgressBar ); |
| |
| void ProgressBar::SetForegroundColor( util::Color color ) |
| { |
| if ( !getImpl().mxProgressBar.is() ) |
| return; |
| getImpl().mxProgressBar->setForegroundColor( color ); |
| } |
| |
| void ProgressBar::SetBackgroundColor( util::Color color ) |
| { |
| if ( !getImpl().mxProgressBar.is() ) |
| return; |
| getImpl().mxProgressBar->setBackgroundColor( color ); |
| } |
| |
| void ProgressBar::SetValue( sal_Int32 i ) |
| { |
| if ( !getImpl().mxProgressBar.is() ) |
| return; |
| getImpl().mxProgressBar->setValue( i ); |
| } |
| |
| void ProgressBar::SetRange( sal_Int32 min, sal_Int32 max ) |
| { |
| if ( !getImpl().mxProgressBar.is() ) |
| return; |
| getImpl().mxProgressBar->setRange( min, max ); |
| } |
| |
| sal_Int32 ProgressBar::GetValue() |
| { |
| if ( !getImpl().mxProgressBar.is() ) |
| return 0; |
| return getImpl().mxProgressBar->getValue(); |
| } |
| |
| class PluginImpl: public ControlImpl |
| { |
| public: |
| ::Control *mpPlugin; |
| |
| PluginImpl( Context *context, const PeerHandle &peer, Window *window, :: Control *plugin ) |
| : ControlImpl( context, peer, window ) |
| , mpPlugin( plugin ) |
| { |
| uno::Reference <awt::XWindow> ref( mxWindow, uno::UNO_QUERY ); |
| layoutimpl::VCLXPlugin *vcl |
| = static_cast<layoutimpl::VCLXPlugin*>( VCLXWindow::GetImplementation( ref ) ); |
| ::Window *parent = vcl->mpWindow->GetParent(); |
| vcl->SetWindow( plugin ); |
| vcl->SetPlugin( mpPlugin ); |
| plugin->SetParent( parent ); |
| plugin->SetStyle( vcl->mStyle ); |
| plugin->SetCreatedWithToolkit( true ); |
| plugin->SetComponentInterface( vcl ); |
| plugin->Show(); |
| } |
| }; |
| |
| Plugin::Plugin( Context *context, char const *id, ::Control *plugin ) |
| : Control( new PluginImpl( context, context->GetPeerHandle( id, 0 ), this, plugin ) ) |
| , mpPlugin( plugin ) |
| { |
| } |
| |
| IMPL_GET_IMPL( Plugin ); |
| |
| class LocalizedStringImpl : public WindowImpl |
| { |
| public: |
| layoutimpl::LocalizedString *mpString; |
| OUString maString; |
| LocalizedStringImpl( Context *context, const PeerHandle &peer, Window *window ) |
| : WindowImpl( context, peer, window ) |
| , mpString( static_cast<layoutimpl::LocalizedString*>( VCLXWindow::GetImplementation( uno::Reference <awt::XWindow> ( mxWindow, uno::UNO_QUERY ) ) ) ) |
| , maString () |
| { |
| } |
| OUString getText() |
| { |
| if (mpString) |
| maString = mpString->getText (); |
| return maString; |
| } |
| void setText( OUString const& s ) |
| { |
| if (mpString) |
| mpString->setText( s ); |
| } |
| }; |
| |
| IMPL_GET_IMPL( LocalizedString ); |
| |
| LocalizedString::LocalizedString( Context *context, char const* id ) |
| : Window( new LocalizedStringImpl( context, context->GetPeerHandle( id, 0 ), this ) ) |
| { |
| } |
| |
| String LocalizedString::getString () |
| { |
| return getImpl ().getText (); |
| } |
| |
| OUString LocalizedString::getOUString () |
| { |
| return getImpl ().getText (); |
| } |
| |
| LocalizedString::operator OUString () |
| { |
| return getOUString (); |
| } |
| |
| LocalizedString::operator OUString const& () |
| { |
| getOUString (); |
| return getImpl ().maString; |
| } |
| |
| LocalizedString::operator String() |
| { |
| getOUString (); |
| return getImpl ().maString; |
| } |
| |
| String LocalizedString::GetToken (sal_uInt16 i, sal_Char c) |
| { |
| return getString ().GetToken (i, c); |
| } |
| |
| OUString LocalizedString::operator= (OUString const& s) |
| { |
| getImpl().setText( s ); |
| return getImpl().getText(); |
| } |
| |
| OUString LocalizedString::operator+= (OUString const& b) |
| { |
| OUString a = getImpl ().getText (); |
| a += b; |
| getImpl ().setText (a); |
| return getImpl ().getText (); |
| } |
| |
| OUString LocalizedString::operator+= (sal_Unicode const b) |
| { |
| String a = getImpl ().getText (); |
| a += b; |
| getImpl ().setText (a); |
| return getImpl ().getText (); |
| } |
| |
| class InPlugImpl : public WindowImpl |
| { |
| public: |
| InPlugImpl (Context *context, const PeerHandle &peer, Window *window) |
| : WindowImpl (context, peer, window) |
| { |
| } |
| }; |
| |
| IMPL_GET_IMPL (InPlug); |
| |
| static char const *FIXME_set_parent (::Window *parent, char const *xml_file) |
| { |
| layout::TabPage::global_parent = parent; |
| return xml_file; |
| } |
| |
| InPlug::InPlug (Window *parent, char const* xml_file, char const* id, sal_uInt32 nId) |
| : Context (FIXME_set_parent (parent ? parent->GetWindow () : 0, xml_file)) |
| , layout::Window (new InPlugImpl (this, Context::GetPeerHandle (id, nId), this)) |
| { |
| if (parent) |
| SetParent (parent); |
| if (::Window *w = dynamic_cast< ::Window* > (this)) |
| w->SetComponentInterface (GetVCLXWindow ()); |
| } |
| |
| InPlug::InPlug (::Window *parent, char const* xml_file, char const* id, sal_uInt32 nId) |
| : Context (FIXME_set_parent (parent, xml_file)) |
| , layout::Window (new InPlugImpl (this, Context::GetPeerHandle (id, nId), this)) |
| { |
| if (parent) |
| layout::Window::SetParent (parent); |
| if (::Window *w = dynamic_cast< ::Window* > (this)) |
| w->SetComponentInterface (GetVCLXWindow ()); |
| } |
| |
| void InPlug::ParentSet (Window *window) |
| { |
| window->SetParent (dynamic_cast< ::Window* > (this)); |
| |
| /// FIXME: for standalone run of layout::SfxTabDialog |
| SetParent (window->GetParent ()); |
| } |
| |
| } // namespace layout |
