diff options
Diffstat (limited to 'vcl/source/components')
| -rw-r--r-- | vcl/source/components/dtranscomp.cxx | 467 | ||||
| -rw-r--r-- | vcl/source/components/factory.cxx | 69 | ||||
| -rw-r--r-- | vcl/source/components/fontident.cxx | 176 |
3 files changed, 712 insertions, 0 deletions
diff --git a/vcl/source/components/dtranscomp.cxx b/vcl/source/components/dtranscomp.cxx new file mode 100644 index 0000000000..92554d3fb7 --- /dev/null +++ b/vcl/source/components/dtranscomp.cxx @@ -0,0 +1,467 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#include <sal/config.h> + +#include <comphelper/lok.hxx> +#include <comphelper/processfactory.hxx> +#include <osl/mutex.hxx> +#include <tools/debug.hxx> +#include <vcl/svapp.hxx> + +#include <factory.hxx> +#include <svdata.hxx> +#include <salinst.hxx> + +#include <com/sun/star/lang/IllegalArgumentException.hpp> +#include <com/sun/star/lang/XMultiServiceFactory.hpp> +#include <com/sun/star/lang/XServiceInfo.hpp> +#include <com/sun/star/lang/XSingleServiceFactory.hpp> +#include <com/sun/star/lang/XInitialization.hpp> +#include <com/sun/star/datatransfer/XTransferable.hpp> +#include <com/sun/star/datatransfer/clipboard/LokClipboard.hpp> +#include <com/sun/star/datatransfer/clipboard/XClipboardListener.hpp> +#include <com/sun/star/datatransfer/clipboard/XSystemClipboard.hpp> +#include <com/sun/star/datatransfer/dnd/XDragSource.hpp> +#include <com/sun/star/datatransfer/dnd/XDropTarget.hpp> +#include <com/sun/star/datatransfer/dnd/DNDConstants.hpp> + +#include <comphelper/compbase.hxx> +#include <cppuhelper/supportsservice.hxx> + +using namespace com::sun::star; +using namespace com::sun::star::uno; +using namespace com::sun::star::lang; + +namespace vcl +{ +namespace { + +// generic implementation to satisfy SalInstance +class GenericClipboard : + public comphelper::WeakComponentImplHelper< + datatransfer::clipboard::XSystemClipboard, + XServiceInfo + > +{ + Reference< css::datatransfer::XTransferable > m_aContents; + Reference< css::datatransfer::clipboard::XClipboardOwner > m_aOwner; + std::vector< Reference< css::datatransfer::clipboard::XClipboardListener > > m_aListeners; + +public: + + GenericClipboard() + {} + + /* + * XServiceInfo + */ + + virtual OUString SAL_CALL getImplementationName() override; + virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override; + virtual Sequence< OUString > SAL_CALL getSupportedServiceNames() override; + + static Sequence< OUString > getSupportedServiceNames_static(); + + /* + * XClipboard + */ + + virtual Reference< css::datatransfer::XTransferable > SAL_CALL getContents() override; + + virtual void SAL_CALL setContents( + const Reference< css::datatransfer::XTransferable >& xTrans, + const Reference< css::datatransfer::clipboard::XClipboardOwner >& xClipboardOwner ) override; + + virtual OUString SAL_CALL getName() override; + + /* + * XClipboardEx + */ + + virtual sal_Int8 SAL_CALL getRenderingCapabilities() override; + + /* + * XClipboardNotifier + */ + virtual void SAL_CALL addClipboardListener( + const Reference< css::datatransfer::clipboard::XClipboardListener >& listener ) override; + + virtual void SAL_CALL removeClipboardListener( + const Reference< css::datatransfer::clipboard::XClipboardListener >& listener ) override; +}; + +} + +Sequence< OUString > GenericClipboard::getSupportedServiceNames_static() +{ + Sequence< OUString > aRet { "com.sun.star.datatransfer.clipboard.SystemClipboard" }; + return aRet; +} + +OUString GenericClipboard::getImplementationName() +{ + return "com.sun.star.datatransfer.VCLGenericClipboard"; +} + +Sequence< OUString > GenericClipboard::getSupportedServiceNames() +{ + return getSupportedServiceNames_static(); +} + +sal_Bool GenericClipboard::supportsService( const OUString& ServiceName ) +{ + return cppu::supportsService(this, ServiceName); +} + +Reference< css::datatransfer::XTransferable > GenericClipboard::getContents() +{ + return m_aContents; +} + +void GenericClipboard::setContents( + const Reference< css::datatransfer::XTransferable >& xTrans, + const Reference< css::datatransfer::clipboard::XClipboardOwner >& xClipboardOwner ) +{ + std::unique_lock aGuard( m_aMutex ); + Reference< datatransfer::clipboard::XClipboardOwner > xOldOwner( m_aOwner ); + Reference< datatransfer::XTransferable > xOldContents( m_aContents ); + m_aContents = xTrans; + m_aOwner = xClipboardOwner; + + std::vector< Reference< datatransfer::clipboard::XClipboardListener > > aListeners( m_aListeners ); + datatransfer::clipboard::ClipboardEvent aEv; + aEv.Contents = m_aContents; + + aGuard.unlock(); + + if( xOldOwner.is() && xOldOwner != xClipboardOwner ) + xOldOwner->lostOwnership( this, xOldContents ); + for (auto const& listener : aListeners) + { + listener->changedContents( aEv ); + } +} + +OUString GenericClipboard::getName() +{ + return "CLIPBOARD"; +} + +sal_Int8 GenericClipboard::getRenderingCapabilities() +{ + return 0; +} + +void GenericClipboard::addClipboardListener( const Reference< datatransfer::clipboard::XClipboardListener >& listener ) +{ + std::unique_lock aGuard(m_aMutex); + + m_aListeners.push_back( listener ); +} + +void GenericClipboard::removeClipboardListener( const Reference< datatransfer::clipboard::XClipboardListener >& listener ) +{ + std::unique_lock aGuard(m_aMutex); + + std::erase(m_aListeners, listener); +} + + + +extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface* +vcl_SystemClipboard_get_implementation( + css::uno::XComponentContext* , css::uno::Sequence<css::uno::Any> const& args) +{ + SolarMutexGuard aGuard; + auto xClipboard = ImplGetSVData()->mpDefInst->CreateClipboard( args ); + if (xClipboard.is()) + xClipboard->acquire(); + return xClipboard.get(); +} + +namespace { + +/* +* generic DragSource dummy +*/ +class GenericDragSource : public ::comphelper::WeakComponentImplHelper< + datatransfer::dnd::XDragSource, + XInitialization, + css::lang::XServiceInfo + > +{ + css::uno::Reference<css::datatransfer::XTransferable> m_xTrans; +public: + GenericDragSource() {} + + // XDragSource + virtual sal_Bool SAL_CALL isDragImageSupported() override; + virtual sal_Int32 SAL_CALL getDefaultCursor( sal_Int8 dragAction ) override; + virtual void SAL_CALL startDrag( + const datatransfer::dnd::DragGestureEvent& trigger, + sal_Int8 sourceActions, sal_Int32 cursor, sal_Int32 image, + const Reference< datatransfer::XTransferable >& transferable, + const Reference< datatransfer::dnd::XDragSourceListener >& listener + ) override; + + // XInitialization + virtual void SAL_CALL initialize( const Sequence< Any >& arguments ) override; + + OUString SAL_CALL getImplementationName() override + { return "com.sun.star.datatransfer.dnd.VclGenericDragSource"; } + + sal_Bool SAL_CALL supportsService(OUString const & ServiceName) override + { return cppu::supportsService(this, ServiceName); } + + css::uno::Sequence<OUString> SAL_CALL getSupportedServiceNames() override + { return getSupportedServiceNames_static(); } + + static Sequence< OUString > getSupportedServiceNames_static() + { + return { "com.sun.star.datatransfer.dnd.GenericDragSource" }; + } +}; + +} + +sal_Bool GenericDragSource::isDragImageSupported() +{ + return false; +} + +sal_Int32 GenericDragSource::getDefaultCursor( sal_Int8 ) +{ + return 0; +} + +void GenericDragSource::startDrag( const datatransfer::dnd::DragGestureEvent&, + sal_Int8 /*sourceActions*/, sal_Int32 /*cursor*/, sal_Int32 /*image*/, + const Reference< datatransfer::XTransferable >& rTrans, + const Reference< datatransfer::dnd::XDragSourceListener >& listener + ) +{ + if (comphelper::LibreOfficeKit::isActive()) { + m_xTrans = rTrans; + return; + } + + datatransfer::dnd::DragSourceDropEvent aEv; + aEv.DropAction = datatransfer::dnd::DNDConstants::ACTION_COPY; + aEv.DropSuccess = false; + listener->dragDropEnd( aEv ); +} + +void GenericDragSource::initialize( const Sequence< Any >& ) +{ +} + +Sequence< OUString > DragSource_getSupportedServiceNames() +{ +#if defined MACOSX + return { "com.sun.star.datatransfer.dnd.OleDragSource" }; +#elif defined UNX + return { "com.sun.star.datatransfer.dnd.X11DragSource" }; +#else + return { "com.sun.star.datatransfer.dnd.VclGenericDragSource" }; +#endif +} + +OUString DragSource_getImplementationName() +{ +#if defined MACOSX + return "com.sun.star.comp.datatransfer.dnd.OleDragSource_V1"; +#elif defined UNX + return "com.sun.star.datatransfer.dnd.XdndSupport"; +#else + return "com.sun.star.datatransfer.dnd.VclGenericDragSource"; +#endif +} + +Reference< XInterface > DragSource_createInstance( const Reference< XMultiServiceFactory >& ) +{ + SolarMutexGuard aGuard; + Reference< XInterface > xResult = ImplGetSVData()->mpDefInst->CreateDragSource(); + return xResult; +} + +/* +* generic DragSource dummy +*/ + +namespace { + +class GenericDropTarget : public comphelper::WeakComponentImplHelper< + datatransfer::dnd::XDropTarget, + XInitialization, + css::lang::XServiceInfo + > +{ +public: + GenericDropTarget() {} + + // XInitialization + virtual void SAL_CALL initialize( const Sequence< Any >& args ) override; + + // XDropTarget + virtual void SAL_CALL addDropTargetListener( const Reference< css::datatransfer::dnd::XDropTargetListener >& ) override; + virtual void SAL_CALL removeDropTargetListener( const Reference< css::datatransfer::dnd::XDropTargetListener >& ) override; + virtual sal_Bool SAL_CALL isActive() override; + virtual void SAL_CALL setActive( sal_Bool active ) override; + virtual sal_Int8 SAL_CALL getDefaultActions() override; + virtual void SAL_CALL setDefaultActions( sal_Int8 actions ) override; + + OUString SAL_CALL getImplementationName() override + { return "com.sun.star.datatransfer.dnd.VclGenericDropTarget"; } + + sal_Bool SAL_CALL supportsService(OUString const & ServiceName) override + { return cppu::supportsService(this, ServiceName); } + + css::uno::Sequence<OUString> SAL_CALL getSupportedServiceNames() override + { return getSupportedServiceNames_static(); } + + static Sequence< OUString > getSupportedServiceNames_static() + { + return { "com.sun.star.datatransfer.dnd.GenericDropTarget" }; + } +}; + +} + +void GenericDropTarget::initialize( const Sequence< Any >& ) +{ +} + +void GenericDropTarget::addDropTargetListener( const Reference< css::datatransfer::dnd::XDropTargetListener >& ) +{ +} + +void GenericDropTarget::removeDropTargetListener( const Reference< css::datatransfer::dnd::XDropTargetListener >& ) +{ +} + +sal_Bool GenericDropTarget::isActive() +{ + return false; +} + +void GenericDropTarget::setActive( sal_Bool ) +{ +} + +sal_Int8 GenericDropTarget::getDefaultActions() +{ + return 0; +} + +void GenericDropTarget::setDefaultActions( sal_Int8) +{ +} + +Sequence< OUString > DropTarget_getSupportedServiceNames() +{ +#if defined MACOSX + return { "com.sun.star.datatransfer.dnd.OleDropTarget" }; +#elif defined UNX + return { "com.sun.star.datatransfer.dnd.X11DropTarget" }; +#else + return GenericDropTarget::getSupportedServiceNames_static(); +#endif +} + +OUString DropTarget_getImplementationName() +{ + return + #if defined MACOSX + "com.sun.star.comp.datatransfer.dnd.OleDropTarget_V1" + #elif defined UNX + "com.sun.star.datatransfer.dnd.XdndDropTarget" + #else + "com.sun.star.datatransfer.dnd.VclGenericDropTarget" + #endif + ; +} + +Reference< XInterface > DropTarget_createInstance( const Reference< XMultiServiceFactory >& ) +{ + SolarMutexGuard aGuard; + Reference< XInterface > xResult = ImplGetSVData()->mpDefInst->CreateDropTarget(); + return xResult; +} + +} // namespace vcl + +/* +* SalInstance generic +*/ +Reference< XInterface > SalInstance::CreateClipboard( const Sequence< Any >& arguments ) +{ + if (arguments.hasElements()) { + throw css::lang::IllegalArgumentException( + "non-empty SalInstance::CreateClipboard arguments", {}, -1); + } +#ifdef IOS + return getXWeak(new vcl::GenericClipboard()); +#else + if (comphelper::LibreOfficeKit::isActive()) { + // In LOK, each document view shall have its own clipboard instance (whereas + // in non-LOK below we keep handing out one single instance; see also + // <https://lists.freedesktop.org/archives/libreoffice/2020-April/084824.html> "Re: Linux + // SAL_USE_VCLPLUGIN=svp and the clipboard"): + css::uno::Reference<css::datatransfer::clipboard::XClipboard> xClipboard = + css::datatransfer::clipboard::LokClipboard::create( + comphelper::getProcessComponentContext()); + return xClipboard; + } +#endif + DBG_TESTSOLARMUTEX(); + if (!m_clipboard.is()) { + m_clipboard = getXWeak(new vcl::GenericClipboard()); + } + return m_clipboard; +} + +uno::Reference<uno::XInterface> SalInstance::ImplCreateDragSource(const SystemEnvData*) +{ + return css::uno::Reference<css::uno::XInterface>(); +} + +Reference< XInterface > SalInstance::CreateDragSource(const SystemEnvData* pSysEnv) +{ + // We run unit tests in parallel, which is a problem when touching a shared resource + // the system clipboard, so rather use the dummy GenericClipboard. + if (Application::IsHeadlessModeEnabled() || IsRunningUnitTest()) + return getXWeak(new vcl::GenericDragSource()); + return ImplCreateDragSource(pSysEnv); +} + +uno::Reference<uno::XInterface> SalInstance::ImplCreateDropTarget(const SystemEnvData*) +{ + return css::uno::Reference<css::uno::XInterface>(); +} + +Reference< XInterface > SalInstance::CreateDropTarget(const SystemEnvData* pSysEnv) +{ + // see SalInstance::CreateDragSource + if (Application::IsHeadlessModeEnabled() || IsRunningUnitTest()) + return getXWeak(new vcl::GenericDropTarget()); + return ImplCreateDropTarget(pSysEnv); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/vcl/source/components/factory.cxx b/vcl/source/components/factory.cxx new file mode 100644 index 0000000000..0a5b7e8f6f --- /dev/null +++ b/vcl/source/components/factory.cxx @@ -0,0 +1,69 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#include <cppuhelper/factory.hxx> +#include <com/sun/star/lang/XMultiServiceFactory.hpp> +#include <com/sun/star/lang/XSingleServiceFactory.hpp> +#include <vcl/dllapi.h> + +#include <factory.hxx> + +using namespace com::sun::star::uno; +using namespace com::sun::star::lang; + +extern "C" { + + VCL_DLLPUBLIC void* vcl_component_getFactory( + const char* pImplementationName, + void* pXUnoSMgr, + void* /*pXUnoKey*/ + ) + { + void* pRet = nullptr; + + if( pXUnoSMgr ) + { + Reference< css::lang::XMultiServiceFactory > xMgr( + static_cast< css::lang::XMultiServiceFactory* >( pXUnoSMgr ) + ); + Reference< css::lang::XSingleServiceFactory > xFactory; + if( vcl::DragSource_getImplementationName().equalsAscii( pImplementationName ) ) + { + xFactory = ::cppu::createSingleFactory( + xMgr, vcl::DragSource_getImplementationName(), vcl::DragSource_createInstance, + vcl::DragSource_getSupportedServiceNames() ); + } + else if( vcl::DropTarget_getImplementationName().equalsAscii( pImplementationName ) ) + { + xFactory = ::cppu::createSingleFactory( + xMgr, vcl::DropTarget_getImplementationName(), vcl::DropTarget_createInstance, + vcl::DropTarget_getSupportedServiceNames() ); + } + if( xFactory.is() ) + { + xFactory->acquire(); + pRet = xFactory.get(); + } + } + return pRet; + } + +} /* extern "C" */ + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/vcl/source/components/fontident.cxx b/vcl/source/components/fontident.cxx new file mode 100644 index 0000000000..104981ad43 --- /dev/null +++ b/vcl/source/components/fontident.cxx @@ -0,0 +1,176 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#include <vcl/svapp.hxx> +#include <vcl/font.hxx> + +#include <factory.hxx> +#include <svdata.hxx> + +#include <com/sun/star/lang/XMultiServiceFactory.hpp> +#include <com/sun/star/lang/XServiceInfo.hpp> +#include <com/sun/star/beans/XMaterialHolder.hpp> +#include <com/sun/star/awt/FontDescriptor.hpp> +#include <com/sun/star/awt/FontFamily.hpp> +#include <com/sun/star/awt/FontPitch.hpp> +#include <com/sun/star/awt/FontWeight.hpp> +#include <com/sun/star/awt/FontSlant.hpp> +#include <com/sun/star/lang/XInitialization.hpp> + +#include <cppuhelper/implbase.hxx> +#include <cppuhelper/supportsservice.hxx> + +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::awt; + +namespace vcl +{ + +namespace { + +class FontIdentificator : public ::cppu::WeakImplHelper< XMaterialHolder, XInitialization, XServiceInfo > +{ + Font m_aFont; +public: + FontIdentificator() {} + + // XServiceInfo + virtual OUString SAL_CALL getImplementationName( ) override; + virtual sal_Bool SAL_CALL supportsService( const OUString& ) override; + virtual Sequence< OUString > SAL_CALL getSupportedServiceNames( ) override; + + // XInitialization + virtual void SAL_CALL initialize( const Sequence< Any >& ) override; + + // XMaterialHolder + virtual Any SAL_CALL getMaterial() override; + +}; + +} + +void SAL_CALL FontIdentificator::initialize( const Sequence<Any>& i_rArgs ) +{ + if( !ImplGetSVData() ) + return; // VCL not initialized + + Sequence< sal_Int8 > aFontBuf; + for( const auto& rArg : i_rArgs ) + { + if( rArg >>= aFontBuf ) + { + m_aFont = Font::identifyFont( aFontBuf.getConstArray(), aFontBuf.getLength() ); + break; + } + } +} + +Any SAL_CALL FontIdentificator::getMaterial() +{ + if( !ImplGetSVData() ) + return Any(); // VCL not initialized + + FontDescriptor aFD; + aFD.Name = m_aFont.GetFamilyName(); + aFD.Height = 0; + aFD.Width = 0; + aFD.StyleName = m_aFont.GetStyleName(); + aFD.CharSet = 0; + aFD.CharacterWidth = 0; + aFD.Underline = 0; + aFD.Strikeout = 0; + aFD.Orientation = 0; + aFD.Kerning = false; + aFD.WordLineMode = false; + aFD.Type = 0; + switch( m_aFont.GetFamilyType() ) + { + case FAMILY_DECORATIVE: aFD.Family = css::awt::FontFamily::DECORATIVE;break; + case FAMILY_MODERN: aFD.Family = css::awt::FontFamily::MODERN;break; + case FAMILY_ROMAN: aFD.Family = css::awt::FontFamily::ROMAN;break; + case FAMILY_SCRIPT: aFD.Family = css::awt::FontFamily::SCRIPT;break; + case FAMILY_SWISS: aFD.Family = css::awt::FontFamily::SWISS;break; + case FAMILY_SYSTEM: aFD.Family = css::awt::FontFamily::SYSTEM;break; + default: + aFD.Family = css::awt::FontFamily::DONTKNOW; + break; + } + switch( m_aFont.GetPitch() ) + { + case PITCH_VARIABLE: aFD.Pitch = css::awt::FontPitch::VARIABLE;break; + case PITCH_FIXED: aFD.Pitch = css::awt::FontPitch::FIXED;break; + default: + aFD.Pitch = css::awt::FontPitch::DONTKNOW; + break; + } + switch( m_aFont.GetWeight() ) + { + case WEIGHT_THIN: aFD.Weight = css::awt::FontWeight::THIN;break; + case WEIGHT_ULTRALIGHT: aFD.Weight = css::awt::FontWeight::ULTRALIGHT;break; + case WEIGHT_LIGHT: aFD.Weight = css::awt::FontWeight::LIGHT;break; + case WEIGHT_SEMILIGHT: aFD.Weight = css::awt::FontWeight::SEMILIGHT;break; + case WEIGHT_MEDIUM: + case WEIGHT_NORMAL: aFD.Weight = css::awt::FontWeight::NORMAL;break; + case WEIGHT_SEMIBOLD: aFD.Weight = css::awt::FontWeight::SEMIBOLD;break; + case WEIGHT_BOLD: aFD.Weight = css::awt::FontWeight::BOLD;break; + case WEIGHT_ULTRABOLD: aFD.Weight = css::awt::FontWeight::ULTRABOLD;break; + case WEIGHT_BLACK: aFD.Weight = css::awt::FontWeight::BLACK;break; + default: + aFD.Weight = css::awt::FontWeight::DONTKNOW; + break; + } + switch( m_aFont.GetItalic() ) + { + case ITALIC_OBLIQUE: aFD.Slant = css::awt::FontSlant_OBLIQUE;break; + case ITALIC_NORMAL: aFD.Slant = css::awt::FontSlant_ITALIC;break; + default: + aFD.Slant = css::awt::FontSlant_DONTKNOW; + break; + } + return Any( aFD ); +} + +// XServiceInfo +OUString SAL_CALL FontIdentificator::getImplementationName() +{ + return "vcl::FontIdentificator"; +} + +sal_Bool SAL_CALL FontIdentificator::supportsService( const OUString& i_rServiceName ) +{ + return cppu::supportsService(this, i_rServiceName); +} + +Sequence< OUString > SAL_CALL FontIdentificator::getSupportedServiceNames() +{ + return { "com.sun.star.awt.FontIdentificator" }; +} + +} // namespace vcl + +extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface* +vcl_FontIdentificator_get_implementation( + css::uno::XComponentContext* , css::uno::Sequence<css::uno::Any> const&) +{ + return cppu::acquire(new vcl::FontIdentificator()); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |