summaryrefslogtreecommitdiffstats
path: root/xmlhelp/source/treeview
diff options
context:
space:
mode:
Diffstat (limited to 'xmlhelp/source/treeview')
-rw-r--r--xmlhelp/source/treeview/tvfactory.cxx131
-rw-r--r--xmlhelp/source/treeview/tvread.cxx1133
2 files changed, 1264 insertions, 0 deletions
diff --git a/xmlhelp/source/treeview/tvfactory.cxx b/xmlhelp/source/treeview/tvfactory.cxx
new file mode 100644
index 000000000..ec2790032
--- /dev/null
+++ b/xmlhelp/source/treeview/tvfactory.cxx
@@ -0,0 +1,131 @@
+/* -*- 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 <com/sun/star/lang/XSingleServiceFactory.hpp>
+#include <com/sun/star/container/XHierarchicalNameAccess.hpp>
+#include <com/sun/star/beans/PropertyValue.hpp>
+#include <comphelper/processfactory.hxx>
+#include <comphelper/propertysequence.hxx>
+#include <cppuhelper/supportsservice.hxx>
+#include <cppuhelper/factory.hxx>
+#include <tvfactory.hxx>
+#include <tvread.hxx>
+
+using namespace treeview;
+using namespace com::sun::star;
+using namespace com::sun::star::uno;
+using namespace com::sun::star::lang;
+using namespace com::sun::star::beans;
+using namespace com::sun::star::container;
+
+TVFactory::TVFactory( const uno::Reference< XComponentContext >& xContext )
+ : m_xContext( xContext )
+{
+}
+
+TVFactory::~TVFactory()
+{
+}
+
+// XServiceInfo methods.
+
+OUString SAL_CALL
+TVFactory::getImplementationName()
+{
+ return "com.sun.star.help.TreeViewImpl";
+}
+
+sal_Bool SAL_CALL TVFactory::supportsService( const OUString& ServiceName )
+{
+ return cppu::supportsService( this, ServiceName );
+}
+
+Sequence< OUString > SAL_CALL
+TVFactory::getSupportedServiceNames()
+{
+ return { "com.sun.star.help.TreeView", "com.sun.star.ucb.HiearchyDataSource" };
+}
+
+// XMultiServiceFactory
+
+Reference< XInterface > SAL_CALL
+TVFactory::createInstance(
+ const OUString& aServiceSpecifier )
+{
+ uno::Sequence<uno::Any> seq(comphelper::InitAnyPropertySequence(
+ {
+ {"nodepath", uno::Any(OUString())}
+ }));
+
+ return createInstanceWithArguments( aServiceSpecifier, seq );
+}
+
+Reference< XInterface > SAL_CALL
+TVFactory::createInstanceWithArguments(
+ const OUString& /*ServiceSpecifier*/,
+ const Sequence< Any >& Arguments )
+{
+ if( ! m_xHDS.is() )
+ {
+ m_xHDS = static_cast<cppu::OWeakObject*>(new TVChildTarget( m_xContext ));
+ }
+
+ OUString hierview;
+ for( const auto& rArgument : Arguments )
+ {
+ PropertyValue pV;
+ if( ! ( rArgument >>= pV ) )
+ continue;
+
+ if( pV.Name != "nodepath" )
+ continue;
+
+ if( ! ( pV.Value >>= hierview ) )
+ continue;
+
+ break;
+ }
+
+ if( !hierview.isEmpty() )
+ {
+ Reference< XHierarchicalNameAccess > xhieraccess( m_xHDS,UNO_QUERY );
+ Any aAny = xhieraccess->getByHierarchicalName( hierview );
+ Reference< XInterface > xInterface;
+ aAny >>= xInterface;
+ return xInterface;
+ }
+ else
+ return m_xHDS;
+}
+
+Sequence< OUString > SAL_CALL
+TVFactory::getAvailableServiceNames( )
+{
+ return { "com.sun.star.ucb.HierarchyDataReadAccess" };
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
+com_sun_star_help_TreeViewImpl_get_implementation(
+ css::uno::XComponentContext* context, css::uno::Sequence<css::uno::Any> const&)
+{
+ return cppu::acquire(new TVFactory(context));
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmlhelp/source/treeview/tvread.cxx b/xmlhelp/source/treeview/tvread.cxx
new file mode 100644
index 000000000..1a56533fd
--- /dev/null
+++ b/xmlhelp/source/treeview/tvread.cxx
@@ -0,0 +1,1133 @@
+/* -*- 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 <string.h>
+#include <rtl/character.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <sal/log.hxx>
+#include <o3tl/safeint.hxx>
+#include <o3tl/string_view.hxx>
+#include <osl/diagnose.h>
+#include <tvread.hxx>
+#include <expat.h>
+#include <osl/file.hxx>
+#include <unotools/configmgr.hxx>
+#include <com/sun/star/configuration/theDefaultProvider.hpp>
+#include <com/sun/star/ucb/SimpleFileAccess.hpp>
+
+#include <comphelper/processfactory.hxx>
+#include <comphelper/propertysequence.hxx>
+#include <com/sun/star/deployment/thePackageManagerFactory.hpp>
+#include <com/sun/star/util/theMacroExpander.hpp>
+#include <com/sun/star/uri/UriReferenceFactory.hpp>
+#include <com/sun/star/uri/XVndSunStarExpandUrl.hpp>
+#include <i18nlangtag/languagetag.hxx>
+#include <unotools/pathoptions.hxx>
+#include <memory>
+
+namespace treeview {
+
+ class TVDom
+ {
+ friend class TVChildTarget;
+ friend class TVRead;
+
+ public:
+
+ explicit TVDom( TVDom* arent = nullptr )
+ : kind( Kind::other ),
+ parent( arent ),
+ children( 0 )
+ {
+ }
+
+ TVDom* newChild()
+ {
+ children.emplace_back( new TVDom( this ) );
+ return children.back().get();
+ }
+
+ void newChild(std::unique_ptr<TVDom> p)
+ {
+ children.emplace_back(std::move(p));
+ children.back()->parent = this;
+ }
+
+ TVDom* getParent() const
+ {
+ if( parent )
+ return parent;
+ else
+ return const_cast<TVDom*>(this); // I am my own parent, if I am the root
+ }
+
+ enum class Kind {
+ tree_node,
+ tree_leaf,
+ other
+ };
+
+ bool isLeaf() const { return kind == TVDom::Kind::tree_leaf; }
+ void setKind( Kind ind ) { kind = ind; }
+
+ void setApplication( const char* appl )
+ {
+ application = OUString( appl,
+ strlen( appl ),
+ RTL_TEXTENCODING_UTF8 );
+ }
+
+ void setTitle( const char* itle )
+ {
+ title += OUString( itle,
+ strlen( itle ),
+ RTL_TEXTENCODING_UTF8 );
+ }
+
+ void setTitle( const XML_Char* itle,int len )
+ {
+ title += OUString( itle,
+ len,
+ RTL_TEXTENCODING_UTF8 );
+ }
+
+ void setId( const char* d )
+ {
+ id = OUString( d,
+ strlen( d ),
+ RTL_TEXTENCODING_UTF8 );
+ }
+
+ void setAnchor( const char* nchor )
+ {
+ anchor = OUString( nchor,
+ strlen( nchor ),
+ RTL_TEXTENCODING_UTF8 );
+ }
+
+ OUString const & getTargetURL()
+ {
+ if( targetURL.isEmpty() )
+ {
+ targetURL = "vnd.sun.star.help://" + id;
+ }
+
+ return targetURL;
+ }
+
+ private:
+
+ Kind kind;
+ OUString application;
+ OUString title;
+ OUString id;
+ OUString anchor;
+ OUString targetURL;
+
+ TVDom *parent;
+ std::vector< std::unique_ptr<TVDom> > children;
+ };
+
+}
+
+using namespace treeview;
+using namespace com::sun::star;
+using namespace com::sun::star::uno;
+using namespace com::sun::star::beans;
+using namespace com::sun::star::configuration;
+using namespace com::sun::star::lang;
+using namespace com::sun::star::util;
+using namespace com::sun::star::container;
+using namespace com::sun::star::deployment;
+
+const char prodName[] = "%PRODUCTNAME";
+const char vendName[] = "%VENDORNAME";
+const char vendVersion[] = "%VENDORVERSION";
+const char vendShort[] = "%VENDORSHORT";
+const char prodVersion[] = "%PRODUCTVERSION";
+
+ConfigData::ConfigData()
+{
+}
+
+void ConfigData::replaceName( OUString& oustring ) const
+{
+ sal_Int32 idx = -1,k = 0,off;
+ bool cap = false;
+ OUStringBuffer aStrBuf( 0 );
+
+ while( ( idx = oustring.indexOf( '%', ++idx ) ) != -1 )
+ {
+ if( oustring.indexOf( prodName,idx ) == idx )
+ off = PRODUCTNAME;
+ else if( oustring.indexOf( prodVersion,idx ) == idx )
+ off = PRODUCTVERSION;
+ else if( oustring.indexOf( vendName,idx ) == idx )
+ off = VENDORNAME;
+ else if( oustring.indexOf( vendVersion,idx ) == idx )
+ off = VENDORVERSION;
+ else if( oustring.indexOf( vendShort,idx ) == idx )
+ off = VENDORSHORT;
+ else
+ off = -1;
+
+ if( off != -1 )
+ {
+ if( ! cap )
+ {
+ cap = true;
+ aStrBuf.ensureCapacity( 256 );
+ }
+
+ aStrBuf.append( &oustring.getStr()[k],idx - k );
+ aStrBuf.append( m_vReplacement[off] );
+ k = idx + m_vAdd[off];
+ }
+ }
+
+ if( cap )
+ {
+ if( k < oustring.getLength() )
+ aStrBuf.append( &oustring.getStr()[k],oustring.getLength()-k );
+ oustring = aStrBuf.makeStringAndClear();
+ }
+}
+
+// TVRead
+
+TVRead::TVRead( const ConfigData& configData,TVDom* tvDom )
+{
+ if( ! tvDom )
+ return;
+
+ Title = tvDom->title;
+ configData.replaceName( Title );
+ if( tvDom->isLeaf() )
+ {
+ TargetURL = tvDom->getTargetURL() + configData.appendix;
+ if( !tvDom->anchor.isEmpty() )
+ TargetURL += "#" + tvDom->anchor;
+ }
+ else
+ Children = new TVChildTarget( configData,tvDom );
+}
+
+TVRead::~TVRead()
+{
+}
+
+// XNameAccess
+
+Any SAL_CALL
+TVRead::getByName( const OUString& aName )
+{
+ bool found( true );
+ Any aAny;
+ if( aName == "Title" )
+ aAny <<= Title;
+ else if( aName == "TargetURL" )
+ aAny <<= TargetURL;
+ else if( aName == "Children" )
+ {
+ cppu::OWeakObject* p = Children.get();
+ aAny <<= Reference< XInterface >( p );
+ }
+ else
+ found = false;
+
+ if( found )
+ return aAny;
+
+ throw NoSuchElementException();
+}
+
+Sequence< OUString > SAL_CALL
+TVRead::getElementNames( )
+{
+ return { "Title", "TargetURL", "Children" };
+}
+
+sal_Bool SAL_CALL
+TVRead::hasByName( const OUString& aName )
+{
+ if( aName == "Title" ||
+ aName == "TargetURL" ||
+ aName == "Children" )
+ return true;
+
+ return false;
+}
+
+// XHierarchicalNameAccess
+
+Any SAL_CALL
+TVRead::getByHierarchicalName( const OUString& aName )
+{
+ OUString aRest;
+ if( aName.startsWith("Children/", &aRest) )
+ return Children->getByHierarchicalName( aRest );
+
+ return getByName( aName );
+}
+
+sal_Bool SAL_CALL
+TVRead::hasByHierarchicalName( const OUString& aName )
+{
+ OUString aRest;
+ if( aName.startsWith("Children/", &aRest) )
+ return Children->hasByHierarchicalName( aRest );
+
+ return hasByName( aName );
+}
+
+/**************************************************************************/
+/* */
+/* TVChildTarget */
+/* */
+/**************************************************************************/
+
+extern "C" {
+
+static void start_handler(void *userData,
+ const XML_Char *name,
+ const XML_Char **atts)
+{
+ TVDom::Kind kind;
+
+ if( strcmp( name,"help_section" ) == 0 ||
+ strcmp( name,"node" ) == 0 )
+ kind = TVDom::Kind::tree_node;
+ else if( strcmp( name,"topic" ) == 0 )
+ kind = TVDom::Kind::tree_leaf;
+ else
+ return;
+
+ TVDom **tvDom = static_cast< TVDom** >( userData );
+ TVDom *p;
+ p = *tvDom;
+
+ *tvDom = p->newChild();
+ p = *tvDom;
+
+ p->setKind( kind );
+ while( *atts )
+ {
+ if( strcmp( *atts,"application" ) == 0 )
+ p->setApplication( *(atts+1) );
+ else if( strcmp( *atts,"title" ) == 0 )
+ p->setTitle( *(atts+1) );
+ else if( strcmp( *atts,"id" ) == 0 )
+ p->setId( *(atts+1) );
+ else if( strcmp( *atts,"anchor" ) == 0 )
+ p->setAnchor( *(atts+1) );
+
+ atts+=2;
+ }
+}
+
+static void end_handler(void *userData,
+ SAL_UNUSED_PARAMETER const XML_Char * )
+{
+ TVDom **tvDom = static_cast< TVDom** >( userData );
+ *tvDom = (*tvDom)->getParent();
+}
+
+static void data_handler( void *userData,
+ const XML_Char *s,
+ int len)
+{
+ TVDom **tvDom = static_cast< TVDom** >( userData );
+ if( (*tvDom)->isLeaf() )
+ (*tvDom)->setTitle( s,len );
+}
+
+}
+
+TVChildTarget::TVChildTarget( const ConfigData& configData,TVDom* tvDom )
+{
+ Elements.resize( tvDom->children.size() );
+ for( size_t i = 0; i < Elements.size(); ++i )
+ Elements[i] = new TVRead( configData,tvDom->children[i].get() );
+}
+
+TVChildTarget::TVChildTarget( const Reference< XComponentContext >& xContext )
+{
+ ConfigData configData = init( xContext );
+
+ if( configData.locale.isEmpty() || configData.system.isEmpty() )
+ return;
+
+ sal_uInt64 ret,len = 0;
+ int j = configData.vFileURL.size();
+
+ TVDom tvDom;
+ TVDom* pTVDom = &tvDom;
+
+ while( j )
+ {
+ len = configData.vFileLen[--j];
+ std::unique_ptr<char[]> s(new char[ int(len) ]); // the buffer to hold the installed files
+ osl::File aFile( configData.vFileURL[j] );
+ (void)aFile.open( osl_File_OpenFlag_Read );
+ aFile.read( s.get(),len,ret );
+ aFile.close();
+
+ XML_Parser parser = XML_ParserCreate( nullptr );
+ XML_SetElementHandler( parser,
+ start_handler,
+ end_handler );
+ XML_SetCharacterDataHandler( parser,
+ data_handler);
+ XML_SetUserData( parser,&pTVDom ); // does not return this
+
+ XML_Status const parsed = XML_Parse(parser, s.get(), int(len), j==0);
+ SAL_WARN_IF(XML_STATUS_ERROR == parsed, "xmlhelp",
+ "TVChildTarget::TVChildTarget(): Tree file parsing failed");
+
+ XML_ParserFree( parser );
+
+ Check(pTVDom);
+ }
+ // now TVDom holds the relevant information
+
+ Elements.resize( tvDom.children.size() );
+ for( size_t i = 0; i < Elements.size(); ++i )
+ Elements[i] = new TVRead( configData,tvDom.children[i].get() );
+}
+
+TVChildTarget::~TVChildTarget()
+{
+}
+
+void TVChildTarget::Check(TVDom* tvDom)
+{
+ if (tvDom->children.empty())
+ {
+ return;
+ }
+
+ unsigned i = 0;
+ bool h = false;
+
+ while((i<tvDom->children.size()-1) && (!h))
+ {
+ if (((tvDom->children[i])->application == (tvDom->children[tvDom->children.size()-1])->application) &&
+ ((tvDom->children[i])->id == (tvDom->children[tvDom->children.size()-1])->id))
+ {
+ TVDom* p = tvDom->children.back().get();
+
+ for(auto & k : p->children)
+ {
+ std::unique_ptr<TVDom> tmp(SearchAndInsert(std::move(k), tvDom->children[i].get()));
+ if (tmp)
+ {
+ tvDom->children[i]->newChild(std::move(tmp));
+ }
+ }
+
+ tvDom->children.pop_back();
+ h = true;
+ }
+ ++i;
+ }
+}
+
+std::unique_ptr<TVDom>
+TVChildTarget::SearchAndInsert(std::unique_ptr<TVDom> p, TVDom* tvDom)
+{
+ if (p->isLeaf()) return p;
+
+ bool h = false;
+ sal_Int32 max = 0;
+
+ std::vector< std::unique_ptr<TVDom> >::iterator max_It, i;
+ max_It = tvDom->children.begin();
+
+ sal_Int32 c_int;
+ sal_Int32 p_int = p->id.toInt32();
+
+ for(i = tvDom->children.begin(); i!=tvDom->children.end(); ++i)
+ if (!((*i)->isLeaf()) &&
+ ((*i)->id.getLength() == p->id.getLength()) &&
+ (p->id.replaceAt((*i)->parent->id.getLength(), p->id.getLength()-(*i)->parent->id.getLength(), u"") == (*i)->parent->id)) //prefix check
+ {
+ h = true;
+ c_int = (*i)->id.toInt32();
+
+ if (p_int==c_int)
+ {
+ (*(tvDom->children.insert(i+1, std::move(p))))->parent = tvDom;
+ return nullptr;
+ }
+ else if(c_int>max && c_int < p_int)
+ {
+ max = c_int;
+ max_It = i+1;
+ }
+ }
+ if (h)
+ {
+ (*(tvDom->children.insert(max_It, std::move(p))))->parent = tvDom;
+ return nullptr;
+ }
+ else
+ {
+ for (auto& child : tvDom->children)
+ {
+ p = SearchAndInsert(std::move(p), child.get());
+ if (p == nullptr)
+ break;
+ }
+ return p;
+ }
+}
+
+Any SAL_CALL
+TVChildTarget::getByName( const OUString& aName )
+{
+ std::u16string_view num( aName.subView( 2, aName.getLength()-4 ) );
+ sal_Int32 idx = o3tl::toInt32(num) - 1;
+ if( idx < 0 || Elements.size() <= o3tl::make_unsigned( idx ) )
+ throw NoSuchElementException();
+
+ cppu::OWeakObject* p = Elements[idx].get();
+ return Any( Reference< XInterface >( p ) );
+}
+
+Sequence< OUString > SAL_CALL
+TVChildTarget::getElementNames( )
+{
+ Sequence< OUString > seq( Elements.size() );
+ auto seqRange = asNonConstRange(seq);
+ for( size_t i = 0; i < Elements.size(); ++i )
+ seqRange[i] = OUString::number( 1+i );
+
+ return seq;
+}
+
+sal_Bool SAL_CALL
+TVChildTarget::hasByName( const OUString& aName )
+{
+ std::u16string_view num( aName.subView( 2, aName.getLength()-4 ) );
+ sal_Int32 idx = o3tl::toInt32(num) - 1;
+ if( idx < 0 || Elements.size() <= o3tl::make_unsigned( idx ) )
+ return false;
+
+ return true;
+}
+
+// XHierarchicalNameAccess
+
+Any SAL_CALL
+TVChildTarget::getByHierarchicalName( const OUString& aName )
+{
+ sal_Int32 idx;
+
+ if( ( idx = aName.indexOf( '/' ) ) != -1 )
+ {
+ std::u16string_view num( aName.subView( 2, idx-4 ) );
+ sal_Int32 pref = o3tl::toInt32(num) - 1;
+
+ if( pref < 0 || Elements.size() <= o3tl::make_unsigned( pref ) )
+ throw NoSuchElementException();
+
+ return Elements[pref]->getByHierarchicalName( aName.copy( 1 + idx ) );
+ }
+ else
+ return getByName( aName );
+}
+
+sal_Bool SAL_CALL
+TVChildTarget::hasByHierarchicalName( const OUString& aName )
+{
+ sal_Int32 idx;
+
+ if( ( idx = aName.indexOf( '/' ) ) != -1 )
+ {
+ std::u16string_view num( aName.subView( 2, idx-4 ) );
+ sal_Int32 pref = o3tl::toInt32(num) - 1;
+ if( pref < 0 || Elements.size() <= o3tl::make_unsigned( pref ) )
+ return false;
+
+ return Elements[pref]->hasByHierarchicalName( aName.copy( 1 + idx ) );
+ }
+ else
+ return hasByName( aName );
+}
+
+ConfigData TVChildTarget::init( const Reference< XComponentContext >& xContext )
+{
+ ConfigData configData;
+ Reference< XMultiServiceFactory > sProvider( getConfiguration(xContext) );
+
+ /**********************************************************************/
+ /* reading Office.Common */
+ /**********************************************************************/
+
+ Reference< XHierarchicalNameAccess > xHierAccess( getHierAccess( sProvider,
+ "org.openoffice.Office.Common" ) );
+ OUString system( getKey( xHierAccess,"Help/System" ) );
+ bool showBasic( getBooleanKey(xHierAccess,"Help/ShowBasic") );
+ OUString instPath( getKey( xHierAccess,"Path/Current/Help" ) );
+ if( instPath.isEmpty() )
+ // try to determine path from default
+ instPath = "$(instpath)/help";
+
+ // replace anything like $(instpath);
+ subst( instPath );
+
+ /**********************************************************************/
+ /* reading setup */
+ /**********************************************************************/
+
+ xHierAccess = getHierAccess( sProvider,
+ "org.openoffice.Setup" );
+
+ OUString setupversion( getKey( xHierAccess,"Product/ooSetupVersion" ) );
+ OUString setupextension;
+
+ try
+ {
+ Reference< lang::XMultiServiceFactory > xConfigProvider = theDefaultProvider::get( xContext );
+
+ uno::Sequence<uno::Any> lParams(comphelper::InitAnyPropertySequence(
+ {
+ {"nodepath", uno::Any(OUString("/org.openoffice.Setup/Product"))}
+ }));
+
+ // open it
+ uno::Reference< uno::XInterface > xCFG( xConfigProvider->createInstanceWithArguments(
+ "com.sun.star.configuration.ConfigurationAccess",
+ lParams) );
+
+ uno::Reference< container::XNameAccess > xDirectAccess(xCFG, uno::UNO_QUERY);
+ uno::Any aRet = xDirectAccess->getByName("ooSetupExtension");
+
+ aRet >>= setupextension;
+ }
+ catch ( uno::Exception& )
+ {
+ }
+
+ OUString productVersion( setupversion + " " + setupextension );
+ OUString locale( getKey( xHierAccess,"L10N/ooLocale" ) );
+
+ // Determine fileurl from url and locale
+ OUString url;
+ osl::FileBase::RC errFile = osl::FileBase::getFileURLFromSystemPath( instPath,url );
+ if( errFile != osl::FileBase::E_None ) return configData;
+ if( !url.endsWith("/") )
+ url += "/";
+ OUString ret;
+ sal_Int32 idx;
+ osl::DirectoryItem aDirItem;
+ if( osl::FileBase::E_None == osl::DirectoryItem::get( url + locale,aDirItem ) )
+ ret = locale;
+ else if( ( ( idx = locale.indexOf( '-' ) ) != -1 ||
+ ( idx = locale.indexOf( '_' ) ) != -1 ) &&
+ osl::FileBase::E_None == osl::DirectoryItem::get( url + locale.subView( 0,idx ),
+ aDirItem ) )
+ ret = locale.copy( 0,idx );
+ else
+ {
+ locale = "en-US";
+ ret = "en";
+ }
+ url += ret;
+
+ // first of all, try do determine whether there are any *.tree files present
+
+ // Start with extensions to set them at the end of the list
+ TreeFileIterator aTreeIt( locale );
+ OUString aTreeFile;
+ sal_Int32 nFileSize;
+ for (;;)
+ {
+ aTreeFile = aTreeIt.nextTreeFile( nFileSize );
+ if( aTreeFile.isEmpty() )
+ break;
+ configData.vFileLen.push_back( nFileSize );
+ configData.vFileURL.push_back( aTreeFile );
+ }
+
+ osl::Directory aDirectory( url );
+ osl::FileStatus aFileStatus(
+ osl_FileStatus_Mask_FileName | osl_FileStatus_Mask_FileURL );
+ if( osl::Directory::E_None == aDirectory.open() )
+ {
+ OUString aFileUrl, aFileName;
+ while( aDirectory.getNextItem( aDirItem ) == osl::FileBase::E_None &&
+ aDirItem.getFileStatus( aFileStatus ) == osl::FileBase::E_None &&
+ aFileStatus.isValid( osl_FileStatus_Mask_FileURL ) &&
+ aFileStatus.isValid( osl_FileStatus_Mask_FileName ) )
+ {
+ aFileUrl = aFileStatus.getFileURL();
+ aFileName = aFileStatus.getFileName();
+ int idx_ = aFileName.lastIndexOf( '.' );
+ if( idx_ == -1 )
+ continue;
+
+ const sal_Unicode* str = aFileName.getStr();
+
+ if( aFileName.getLength() == idx_ + 5 &&
+ ( str[idx_ + 1] == 't' || str[idx_ + 1] == 'T' ) &&
+ ( str[idx_ + 2] == 'r' || str[idx_ + 2] == 'R' ) &&
+ ( str[idx_ + 3] == 'e' || str[idx_ + 3] == 'E' ) &&
+ ( str[idx_ + 4] == 'e' || str[idx_ + 4] == 'E' ) )
+ {
+ OUString baseName = aFileName.copy(0,idx_).toAsciiLowerCase();
+ if(! showBasic && baseName == "sbasic" )
+ continue;
+ osl::File aFile( aFileUrl );
+ if( osl::FileBase::E_None == aFile.open( osl_File_OpenFlag_Read ) )
+ {
+ // use the file size, not aFileStatus size, in case the
+ // tree file is a symlink
+ sal_uInt64 nSize;
+ aFile.getSize( nSize );
+ configData.vFileLen.push_back( nSize );
+ configData.vFileURL.push_back( aFileUrl );
+ aFile.close();
+ }
+ }
+ }
+ aDirectory.close();
+ }
+
+ configData.m_vAdd[0] = 12;
+ configData.m_vAdd[1] = 15;
+ configData.m_vAdd[2] = 11;
+ configData.m_vAdd[3] = 14;
+ configData.m_vAdd[4] = 12;
+ configData.m_vReplacement[0] = utl::ConfigManager::getProductName();
+ configData.m_vReplacement[1] = productVersion;
+ // m_vReplacement[2...4] (vendorName/-Version/-Short) are empty strings
+
+ configData.system = system;
+ configData.locale = locale;
+ configData.appendix =
+ "?Language=" +
+ configData.locale +
+ "&System=" +
+ configData.system +
+ "&UseDB=no";
+
+ return configData;
+}
+
+Reference< XMultiServiceFactory >
+TVChildTarget::getConfiguration(const Reference< XComponentContext >& rxContext)
+{
+ Reference< XMultiServiceFactory > xProvider;
+ if( rxContext.is() )
+ {
+ try
+ {
+ xProvider = theDefaultProvider::get( rxContext );
+ }
+ catch( const css::uno::Exception& )
+ {
+ OSL_ENSURE( xProvider.is(),"can not instantiate configuration" );
+ }
+ }
+
+ return xProvider;
+}
+
+Reference< XHierarchicalNameAccess >
+TVChildTarget::getHierAccess( const Reference< XMultiServiceFactory >& sProvider,
+ const char* file )
+{
+ Reference< XHierarchicalNameAccess > xHierAccess;
+
+ if( sProvider.is() )
+ {
+ try
+ {
+ xHierAccess =
+ Reference< XHierarchicalNameAccess >
+ ( sProvider->createInstanceWithArguments( "com.sun.star.configuration.ConfigurationAccess", { Any(OUString::createFromAscii(file)) }),
+ UNO_QUERY );
+ }
+ catch( const css::uno::Exception& )
+ {
+ }
+ }
+
+ return xHierAccess;
+}
+
+OUString
+TVChildTarget::getKey( const Reference< XHierarchicalNameAccess >& xHierAccess,
+ const char* key )
+{
+ OUString instPath;
+ if( xHierAccess.is() )
+ {
+ Any aAny;
+ try
+ {
+ aAny =
+ xHierAccess->getByHierarchicalName( OUString::createFromAscii( key ) );
+ }
+ catch( const css::container::NoSuchElementException& )
+ {
+ }
+ aAny >>= instPath;
+ }
+ return instPath;
+}
+
+bool
+TVChildTarget::getBooleanKey(const Reference<
+ XHierarchicalNameAccess >& xHierAccess,
+ const char* key)
+{
+ bool ret = false;
+ if( xHierAccess.is() )
+ {
+ Any aAny;
+ try
+ {
+ aAny =
+ xHierAccess->getByHierarchicalName(
+ OUString::createFromAscii(key));
+ }
+ catch( const css::container::NoSuchElementException& )
+ {
+ }
+ aAny >>= ret;
+ }
+ return ret;
+}
+
+void TVChildTarget::subst( OUString& instpath )
+{
+ SvtPathOptions aOptions;
+ instpath = aOptions.SubstituteVariable( instpath );
+}
+
+
+const char aHelpMediaType[] = "application/vnd.sun.star.help";
+
+TreeFileIterator::TreeFileIterator( const OUString& aLanguage )
+ : m_eState( IteratorState::UserExtensions )
+ , m_aLanguage( aLanguage )
+{
+ m_xContext = ::comphelper::getProcessComponentContext();
+ if( !m_xContext.is() )
+ {
+ throw RuntimeException( "TreeFileIterator::TreeFileIterator(), no XComponentContext" );
+ }
+
+ m_xSFA = ucb::SimpleFileAccess::create(m_xContext);
+
+ m_bUserPackagesLoaded = false;
+ m_bSharedPackagesLoaded = false;
+ m_bBundledPackagesLoaded = false;
+ m_iUserPackage = 0;
+ m_iSharedPackage = 0;
+ m_iBundledPackage = 0;
+}
+
+Reference< deployment::XPackage > TreeFileIterator::implGetHelpPackageFromPackage
+ ( const Reference< deployment::XPackage >& xPackage, Reference< deployment::XPackage >& o_xParentPackageBundle )
+{
+ o_xParentPackageBundle.clear();
+
+ Reference< deployment::XPackage > xHelpPackage;
+ if( !xPackage.is() )
+ return xHelpPackage;
+
+ // Check if parent package is registered
+ beans::Optional< beans::Ambiguous<sal_Bool> > option( xPackage->isRegistered
+ ( Reference<task::XAbortChannel>(), Reference<ucb::XCommandEnvironment>() ) );
+ bool bRegistered = false;
+ if( option.IsPresent )
+ {
+ beans::Ambiguous<sal_Bool> const & reg = option.Value;
+ if( !reg.IsAmbiguous && reg.Value )
+ bRegistered = true;
+ }
+ if( !bRegistered )
+ return xHelpPackage;
+
+ if( xPackage->isBundle() )
+ {
+ const Sequence< Reference< deployment::XPackage > > aPkgSeq = xPackage->getBundle
+ ( Reference<task::XAbortChannel>(), Reference<ucb::XCommandEnvironment>() );
+ auto pSubPkg = std::find_if(aPkgSeq.begin(), aPkgSeq.end(),
+ [](const Reference< deployment::XPackage >& xSubPkg) {
+ const Reference< deployment::XPackageTypeInfo > xPackageTypeInfo = xSubPkg->getPackageType();
+ OUString aMediaType = xPackageTypeInfo->getMediaType();
+ return aMediaType == aHelpMediaType;
+ });
+ if (pSubPkg != aPkgSeq.end())
+ {
+ xHelpPackage = *pSubPkg;
+ o_xParentPackageBundle = xPackage;
+ }
+ }
+ else
+ {
+ const Reference< deployment::XPackageTypeInfo > xPackageTypeInfo = xPackage->getPackageType();
+ OUString aMediaType = xPackageTypeInfo->getMediaType();
+ if( aMediaType == aHelpMediaType )
+ xHelpPackage = xPackage;
+ }
+
+ return xHelpPackage;
+}
+
+Reference< deployment::XPackage > TreeFileIterator::implGetNextUserHelpPackage
+ ( Reference< deployment::XPackage >& o_xParentPackageBundle )
+{
+ Reference< deployment::XPackage > xHelpPackage;
+
+ if( !m_bUserPackagesLoaded )
+ {
+ Reference< XPackageManager > xUserManager =
+ thePackageManagerFactory::get( m_xContext )->getPackageManager("user");
+ m_aUserPackagesSeq = xUserManager->getDeployedPackages
+ ( Reference< task::XAbortChannel >(), Reference< ucb::XCommandEnvironment >() );
+
+ m_bUserPackagesLoaded = true;
+ }
+
+ if( m_iUserPackage == m_aUserPackagesSeq.getLength() )
+ {
+ m_eState = IteratorState::SharedExtensions; // Later: SHARED_MODULE
+ }
+ else
+ {
+ const Reference< deployment::XPackage >* pUserPackages = m_aUserPackagesSeq.getConstArray();
+ Reference< deployment::XPackage > xPackage = pUserPackages[ m_iUserPackage++ ];
+ OSL_ENSURE( xPackage.is(), "TreeFileIterator::implGetNextUserHelpPackage(): Invalid package" );
+ xHelpPackage = implGetHelpPackageFromPackage( xPackage, o_xParentPackageBundle );
+ }
+
+ return xHelpPackage;
+}
+
+Reference< deployment::XPackage > TreeFileIterator::implGetNextSharedHelpPackage
+ ( Reference< deployment::XPackage >& o_xParentPackageBundle )
+{
+ Reference< deployment::XPackage > xHelpPackage;
+
+ if( !m_bSharedPackagesLoaded )
+ {
+ Reference< XPackageManager > xSharedManager =
+ thePackageManagerFactory::get( m_xContext )->getPackageManager("shared");
+ m_aSharedPackagesSeq = xSharedManager->getDeployedPackages
+ ( Reference< task::XAbortChannel >(), Reference< ucb::XCommandEnvironment >() );
+
+ m_bSharedPackagesLoaded = true;
+ }
+
+ if( m_iSharedPackage == m_aSharedPackagesSeq.getLength() )
+ {
+ m_eState = IteratorState::BundledExtensions;
+ }
+ else
+ {
+ const Reference< deployment::XPackage >* pSharedPackages = m_aSharedPackagesSeq.getConstArray();
+ Reference< deployment::XPackage > xPackage = pSharedPackages[ m_iSharedPackage++ ];
+ OSL_ENSURE( xPackage.is(), "TreeFileIterator::implGetNextSharedHelpPackage(): Invalid package" );
+ xHelpPackage = implGetHelpPackageFromPackage( xPackage, o_xParentPackageBundle );
+ }
+
+ return xHelpPackage;
+}
+
+Reference< deployment::XPackage > TreeFileIterator::implGetNextBundledHelpPackage
+ ( Reference< deployment::XPackage >& o_xParentPackageBundle )
+{
+ Reference< deployment::XPackage > xHelpPackage;
+
+ if( !m_bBundledPackagesLoaded )
+ {
+ Reference< XPackageManager > xBundledManager =
+ thePackageManagerFactory::get( m_xContext )->getPackageManager("bundled");
+ m_aBundledPackagesSeq = xBundledManager->getDeployedPackages
+ ( Reference< task::XAbortChannel >(), Reference< ucb::XCommandEnvironment >() );
+
+ m_bBundledPackagesLoaded = true;
+ }
+
+ if( m_iBundledPackage == m_aBundledPackagesSeq.getLength() )
+ {
+ m_eState = IteratorState::EndReached;
+ }
+ else
+ {
+ const Reference< deployment::XPackage >* pBundledPackages = m_aBundledPackagesSeq.getConstArray();
+ Reference< deployment::XPackage > xPackage = pBundledPackages[ m_iBundledPackage++ ];
+ OSL_ENSURE( xPackage.is(), "TreeFileIterator::implGetNextBundledHelpPackage(): Invalid package" );
+ xHelpPackage = implGetHelpPackageFromPackage( xPackage, o_xParentPackageBundle );
+ }
+
+ return xHelpPackage;
+}
+
+static bool isLetter( sal_Unicode c )
+{
+ return rtl::isAsciiAlpha(c);
+}
+
+void TreeFileIterator::implGetLanguageVectorFromPackage( ::std::vector< OUString > &rv,
+ const css::uno::Reference< css::deployment::XPackage >& xPackage )
+{
+ rv.clear();
+ OUString aExtensionPath = xPackage->getURL();
+ const Sequence< OUString > aEntrySeq = m_xSFA->getFolderContents( aExtensionPath, true );
+
+ for( const OUString& aEntry : aEntrySeq )
+ {
+ if( m_xSFA->isFolder( aEntry ) )
+ {
+ sal_Int32 nLastSlash = aEntry.lastIndexOf( '/' );
+ if( nLastSlash != -1 )
+ {
+ OUString aPureEntry = aEntry.copy( nLastSlash + 1 );
+
+ // Check language scheme
+ int nLen = aPureEntry.getLength();
+ const sal_Unicode* pc = aPureEntry.getStr();
+ bool bStartCanBeLanguage = ( nLen >= 2 && isLetter( pc[0] ) && isLetter( pc[1] ) );
+ bool bIsLanguage = bStartCanBeLanguage &&
+ ( nLen == 2 || (nLen == 5 && pc[2] == '-' && isLetter( pc[3] ) && isLetter( pc[4] )) );
+ if( bIsLanguage )
+ rv.push_back( aPureEntry );
+ }
+ }
+ }
+}
+
+
+OUString TreeFileIterator::nextTreeFile( sal_Int32& rnFileSize )
+{
+ OUString aRetFile;
+
+ while( aRetFile.isEmpty() && m_eState != IteratorState::EndReached )
+ {
+ switch( m_eState )
+ {
+ case IteratorState::UserExtensions:
+ {
+ Reference< deployment::XPackage > xParentPackageBundle;
+ Reference< deployment::XPackage > xHelpPackage = implGetNextUserHelpPackage( xParentPackageBundle );
+ if( !xHelpPackage.is() )
+ break;
+
+ aRetFile = implGetTreeFileFromPackage( rnFileSize, xHelpPackage );
+ break;
+ }
+
+ case IteratorState::SharedExtensions:
+ {
+ Reference< deployment::XPackage > xParentPackageBundle;
+ Reference< deployment::XPackage > xHelpPackage = implGetNextSharedHelpPackage( xParentPackageBundle );
+ if( !xHelpPackage.is() )
+ break;
+
+ aRetFile = implGetTreeFileFromPackage( rnFileSize, xHelpPackage );
+ break;
+ }
+ case IteratorState::BundledExtensions:
+ {
+ Reference< deployment::XPackage > xParentPackageBundle;
+ Reference< deployment::XPackage > xHelpPackage = implGetNextBundledHelpPackage( xParentPackageBundle );
+ if( !xHelpPackage.is() )
+ break;
+
+ aRetFile = implGetTreeFileFromPackage( rnFileSize, xHelpPackage );
+ break;
+ }
+
+ case IteratorState::EndReached:
+ OSL_FAIL( "DataBaseIterator::nextTreeFile(): Invalid case IteratorState::EndReached" );
+ break;
+ }
+ }
+
+ return aRetFile;
+}
+
+OUString TreeFileIterator::expandURL( const OUString& aURL )
+{
+ static Reference< util::XMacroExpander > xMacroExpander;
+ static Reference< uri::XUriReferenceFactory > xFac;
+
+ std::scoped_lock aGuard( m_aMutex );
+
+ if( !xMacroExpander.is() || !xFac.is() )
+ {
+ xFac = uri::UriReferenceFactory::create( m_xContext );
+
+ xMacroExpander = util::theMacroExpander::get(m_xContext);
+ }
+
+ OUString aRetURL = aURL;
+ Reference< uri::XUriReference > uriRef;
+ for (;;)
+ {
+ uriRef = xFac->parse( aRetURL );
+ if ( uriRef.is() )
+ {
+ Reference < uri::XVndSunStarExpandUrl > sxUri( uriRef, UNO_QUERY );
+ if( !sxUri.is() )
+ break;
+
+ aRetURL = sxUri->expand( xMacroExpander );
+ }
+ }
+ return aRetURL;
+}
+
+OUString TreeFileIterator::implGetTreeFileFromPackage
+ ( sal_Int32& rnFileSize, const Reference< deployment::XPackage >& xPackage )
+{
+ OUString aRetFile;
+ OUString aLanguage = m_aLanguage;
+ for( sal_Int32 iPass = 0 ; iPass < 2 ; ++iPass )
+ {
+ aRetFile = expandURL( xPackage->getURL() + "/" + aLanguage + "/help.tree" );
+ if( iPass == 0 )
+ {
+ if( m_xSFA->exists( aRetFile ) )
+ break;
+
+ ::std::vector< OUString > av;
+ implGetLanguageVectorFromPackage( av, xPackage );
+ ::std::vector< OUString >::const_iterator pFound = LanguageTag::getFallback( av, m_aLanguage );
+ if( pFound != av.end() )
+ aLanguage = *pFound;
+ }
+ }
+
+ rnFileSize = 0;
+ if( m_xSFA->exists( aRetFile ) )
+ rnFileSize = m_xSFA->getSize( aRetFile );
+ else
+ aRetFile.clear();
+
+ return aRetFile;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */