    /* -*- 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 <config_features.h>

    #if defined(MACOSX) && HAVE_FEATURE_READONLY_INSTALLSET
    #define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
    #include <premac.h>
    #include <Foundation/Foundation.h>
    #include <postmac.h>
    #endif

    #include <sal/config.h>

    #include <comphelper/processfactory.hxx>
    #include <osl/thread.h>
    #include <tools/vcompat.hxx>
    #include <vcl/lstbox.hxx>
    #include <ucbhelper/content.hxx>
    #include <com/sun/star/ucb/ContentCreationException.hpp>
    #include <unotools/configmgr.hxx>
    #include <unotools/ucbstreamhelper.hxx>
    #include <unotools/pathoptions.hxx>
    #include <sfx2/docfile.hxx>
    #include <svx/dialmgr.hxx>
    #include <svx/gallery.hxx>
    #include <svx/strings.hrc>
    #include <strings.hxx>
    #include <svx/galmisc.hxx>
    #include <svx/galtheme.hxx>
    #include <svx/gallery1.hxx>
    #include <com/sun/star/sdbc/XResultSet.hpp>
    #include <com/sun/star/ucb/XContentAccess.hpp>
    #include <memory>

    using namespace ::com::sun::star;

    static bool FileExists( const INetURLObject &rURL, const rtl::OUString &rExt )
    {
        INetURLObject aURL( rURL );
        aURL.setExtension( rExt );
        return FileExists( aURL );
    }

    const std::pair<sal_uInt16, const char*> aUnlocalized[] =
    {
        { GALLERY_THEME_HOMEPAGE, RID_GALLERYSTR_THEME_HTMLBUTTONS },
        { GALLERY_THEME_POWERPOINT, RID_GALLERYSTR_THEME_POWERPOINT },
        { GALLERY_THEME_USERSOUNDS, RID_GALLERYSTR_THEME_USERSOUNDS },
        { GALLERY_THEME_DUMMY5, RID_GALLERYSTR_THEME_DUMMY5 },
        { GALLERY_THEME_RULERS, RID_GALLERYSTR_THEME_RULERS },
        { GALLERY_THEME_FONTWORK, RID_GALLERYSTR_THEME_FONTWORK },
        { GALLERY_THEME_FONTWORK_VERTICAL, RID_GALLERYSTR_THEME_FONTWORK_VERTICAL }
    };

    const std::pair<sal_uInt16, const char*> aLocalized[] =
    {
        { RID_GALLERY_THEME_3D, RID_GALLERYSTR_THEME_3D },
        { RID_GALLERY_THEME_ANIMATIONS, RID_GALLERYSTR_THEME_ANIMATIONS },
        { RID_GALLERY_THEME_BULLETS, RID_GALLERYSTR_THEME_BULLETS },
        { RID_GALLERY_THEME_OFFICE, RID_GALLERYSTR_THEME_OFFICE },
        { RID_GALLERY_THEME_FLAGS, RID_GALLERYSTR_THEME_FLAGS },
        { RID_GALLERY_THEME_FLOWCHARTS, RID_GALLERYSTR_THEME_FLOWCHARTS },
        { RID_GALLERY_THEME_EMOTICONS, RID_GALLERYSTR_THEME_EMOTICONS },
        { RID_GALLERY_THEME_PHOTOS, RID_GALLERYSTR_THEME_PHOTOS },
        { RID_GALLERY_THEME_BACKGROUNDS, RID_GALLERYSTR_THEME_BACKGROUNDS },
        { RID_GALLERY_THEME_HOMEPAGE, RID_GALLERYSTR_THEME_HOMEPAGE },
        { RID_GALLERY_THEME_INTERACTION, RID_GALLERYSTR_THEME_INTERACTION },
        { RID_GALLERY_THEME_MAPS, RID_GALLERYSTR_THEME_MAPS },
        { RID_GALLERY_THEME_PEOPLE, RID_GALLERYSTR_THEME_PEOPLE },
        { RID_GALLERY_THEME_SURFACES, RID_GALLERYSTR_THEME_SURFACES },
        { RID_GALLERY_THEME_SOUNDS, RID_GALLERYSTR_THEME_SOUNDS },
        { RID_GALLERY_THEME_SYMBOLS, RID_GALLERYSTR_THEME_SYMBOLS },
        { RID_GALLERY_THEME_MYTHEME, RID_GALLERYSTR_THEME_MYTHEME },

        { RID_GALLERY_THEME_ARROWS, RID_GALLERYSTR_THEME_ARROWS },
        { RID_GALLERY_THEME_BALLOONS, RID_GALLERYSTR_THEME_BALLOONS },
        { RID_GALLERY_THEME_KEYBOARD, RID_GALLERYSTR_THEME_KEYBOARD },
        { RID_GALLERY_THEME_TIME, RID_GALLERYSTR_THEME_TIME },
        { RID_GALLERY_THEME_PRESENTATION, RID_GALLERYSTR_THEME_PRESENTATION },
        { RID_GALLERY_THEME_CALENDAR, RID_GALLERYSTR_THEME_CALENDAR },
        { RID_GALLERY_THEME_NAVIGATION, RID_GALLERYSTR_THEME_NAVIGATION },
        { RID_GALLERY_THEME_COMMUNICATION, RID_GALLERYSTR_THEME_COMMUNICATION },
        { RID_GALLERY_THEME_FINANCES, RID_GALLERYSTR_THEME_FINANCES },
        { RID_GALLERY_THEME_COMPUTER, RID_GALLERYSTR_THEME_COMPUTER },

        { RID_GALLERY_THEME_CLIMA, RID_GALLERYSTR_THEME_CLIMA },
        { RID_GALLERY_THEME_EDUCATION, RID_GALLERYSTR_THEME_EDUCATION },
        { RID_GALLERY_THEME_TROUBLE, RID_GALLERYSTR_THEME_TROUBLE },
        { RID_GALLERY_THEME_SCREENBEANS, RID_GALLERYSTR_THEME_SCREENBEANS },

        { RID_GALLERY_THEME_COMPUTERS, RID_GALLERYSTR_THEME_COMPUTERS },
        { RID_GALLERY_THEME_DIAGRAMS, RID_GALLERYSTR_THEME_DIAGRAMS },
        { RID_GALLERY_THEME_ENVIRONMENT, RID_GALLERYSTR_THEME_ENVIRONMENT },
        { RID_GALLERY_THEME_FINANCE, RID_GALLERYSTR_THEME_FINANCE },
        { RID_GALLERY_THEME_TRANSPORT, RID_GALLERYSTR_THEME_TRANSPORT },
        { RID_GALLERY_THEME_TXTSHAPES, RID_GALLERYSTR_THEME_TXTSHAPES }
    };

    GalleryThemeEntry::GalleryThemeEntry( bool bCreateUniqueURL,
                                          const INetURLObject& rBaseURL, const OUString& rName,
                                          bool _bReadOnly, bool _bNewFile,
                                          sal_uInt32 _nId, bool _bThemeNameFromResource ) :
            nId                     ( _nId ),
            bReadOnly               ( _bReadOnly ),
            bThemeNameFromResource  ( _bThemeNameFromResource )
    {
        INetURLObject aURL( rBaseURL );
        DBG_ASSERT( aURL.GetProtocol() != INetProtocol::NotValid, "invalid URL" );

        if (bCreateUniqueURL)
        {
            INetURLObject aBaseNoCase( ImplGetURLIgnoreCase( rBaseURL ) );
            aURL = aBaseNoCase;
            static sal_Int32 nIdx = 0;
            while( FileExists( aURL, "thm" ) )
            { // create new URLs
                nIdx++;
                aURL = aBaseNoCase;
                aURL.setName( aURL.getName() + OUString::number(nIdx));
            }
        }

        aURL.setExtension( "thm" );
        aThmURL = ImplGetURLIgnoreCase( aURL );

        aURL.setExtension( "sdg" );
        aSdgURL = ImplGetURLIgnoreCase( aURL );

        aURL.setExtension( "sdv" );
        aSdvURL = ImplGetURLIgnoreCase( aURL );

        aURL.setExtension( "str" );
        aStrURL = ImplGetURLIgnoreCase( aURL );

        SetModified( _bNewFile );

        aName = ReadStrFromIni( "name" );

        // This is awful - we shouldn't use these resources if we
        // possibly can avoid them
        if( aName.isEmpty() && nId && bThemeNameFromResource )
        {
            //some of these are supposed to *not* be localized
            //so catch them before looking up the resource
            for (size_t i = 0; i < SAL_N_ELEMENTS(aUnlocalized); ++i)
            {
                if (aUnlocalized[i].first == nId)
                {
                    aName = OUString::createFromAscii(aUnlocalized[i].second);
                    break;
                }
            }
            //look up the rest of the ids in string resources
            if (aName.isEmpty())
            {
                for (size_t i = 0; i < SAL_N_ELEMENTS(aLocalized); ++i)
                {
                    if (aLocalized[i].first == nId)
                    {
                        aName = SvxResId(aLocalized[i].second);
                        break;
                    }
                }
            }
        }

        if( aName.isEmpty() )
            aName = rName;
    }

    void GalleryTheme::InsertAllThemes(weld::ComboBoxText& rListBox)
    {
        for (size_t i = 0; i < SAL_N_ELEMENTS(aUnlocalized); ++i)
            rListBox.append_text(OUString::createFromAscii(aUnlocalized[i].second));

        for (size_t i = 0; i < SAL_N_ELEMENTS(aLocalized); ++i)
            rListBox.append_text(SvxResId(aLocalized[i].second));
    }

    INetURLObject GalleryThemeEntry::ImplGetURLIgnoreCase( const INetURLObject& rURL )
    {
        INetURLObject   aURL( rURL );

        // check original file name
        if( !FileExists( aURL ) )
        {
            // check upper case file name
            aURL.setName( aURL.getName().toAsciiUpperCase() );

            if(!FileExists( aURL ) )
            {
                // check lower case file name
                aURL.setName( aURL.getName().toAsciiLowerCase() );
            }
        }

        return aURL;
    }

    void GalleryThemeEntry::SetName( const OUString& rNewName )
    {
        if( aName != rNewName )
        {
            aName = rNewName;
            SetModified( true );
            bThemeNameFromResource = false;
        }
    }

    void GalleryThemeEntry::SetId( sal_uInt32 nNewId, bool bResetThemeName )
    {
        nId = nNewId;
        SetModified( true );
        bThemeNameFromResource = ( nId && bResetThemeName );
    }

    class GalleryThemeCacheEntry
    {
    private:

        const GalleryThemeEntry*        mpThemeEntry;
        std::unique_ptr<GalleryTheme>   mpTheme;

    public:

                                    GalleryThemeCacheEntry( const GalleryThemeEntry* pThemeEntry, std::unique_ptr<GalleryTheme> pTheme ) :
                                        mpThemeEntry( pThemeEntry ), mpTheme( std::move(pTheme) ) {}

        const GalleryThemeEntry*    GetThemeEntry() const { return mpThemeEntry; }
        GalleryTheme*               GetTheme() const { return mpTheme.get(); }
    };

    Gallery::Gallery( const OUString& rMultiPath )
    :       bMultiPath          ( false )
    {
        ImplLoad( rMultiPath );
    }

    Gallery::~Gallery()
    {
    }

    Gallery* Gallery::GetGalleryInstance()
    {
        // note: this would deadlock if it used osl::Mutex::getGlobalMutex()
        static Gallery *const s_pGallery(
            utl::ConfigManager::IsFuzzing() ? nullptr :
                new Gallery(SvtPathOptions().GetGalleryPath()));

        return s_pGallery;
    }

    void Gallery::ImplLoad( const OUString& rMultiPath )
    {
        bool bIsReadOnlyDir {false};

        bMultiPath = !rMultiPath.isEmpty();

        INetURLObject aCurURL(SvtPathOptions().GetConfigPath());
        ImplLoadSubDirs( aCurURL, bIsReadOnlyDir );

        if( !bIsReadOnlyDir )
            aUserURL = aCurURL;

        if( bMultiPath )
        {
            bool bIsRelURL {true};
            sal_Int32 nIdx {0};
            do
            {
                aCurURL = INetURLObject(rMultiPath.getToken(0, ';', nIdx));
                if (bIsRelURL)
                {
                    aRelURL = aCurURL;
                    bIsRelURL = false;
                }

                ImplLoadSubDirs( aCurURL, bIsReadOnlyDir );

                if( !bIsReadOnlyDir )
                    aUserURL = aCurURL;
            }
            while (nIdx>0);
        }
        else
            aRelURL = INetURLObject( rMultiPath );

        DBG_ASSERT( aUserURL.GetProtocol() != INetProtocol::NotValid, "no writable Gallery user directory available" );
        DBG_ASSERT( aRelURL.GetProtocol() != INetProtocol::NotValid, "invalid URL" );
    }

    void Gallery::ImplLoadSubDirs( const INetURLObject& rBaseURL, bool& rbDirIsReadOnly )
    {
        rbDirIsReadOnly = false;

        try
        {
            uno::Reference< ucb::XCommandEnvironment > xEnv;
            ::ucbhelper::Content                       aCnt( rBaseURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ), xEnv, comphelper::getProcessComponentContext() );

            uno::Sequence<OUString> aProps { "Url" };

            uno::Reference< sdbc::XResultSet > xResultSet( aCnt.createCursor( aProps, ::ucbhelper::INCLUDE_DOCUMENTS_ONLY ) );

    #if defined(MACOSX) && HAVE_FEATURE_READONLY_INSTALLSET
            if( rBaseURL.GetProtocol() == INetProtocol::File )
            {
                const char *appBundle = [[[NSBundle mainBundle] bundlePath] UTF8String];
                OUString path = rBaseURL.GetURLPath();
                if( path.startsWith( OUString( appBundle, strlen( appBundle ), RTL_TEXTENCODING_UTF8 ) + "/" ) )
                    rbDirIsReadOnly = true;
            }
    #else
            try
            {
                // check readonlyness the very hard way
                INetURLObject   aTestURL( rBaseURL );

                aTestURL.Append( "cdefghij.klm" );
                std::unique_ptr<SvStream> pTestStm(::utl::UcbStreamHelper::CreateStream( aTestURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ), StreamMode::WRITE ));

                if( pTestStm )
                {
                    pTestStm->WriteInt32( sal_Int32(1) );

                    if( pTestStm->GetError() )
                        rbDirIsReadOnly = true;

                    pTestStm.reset();
                    KillFile( aTestURL );
                }
                else
                    rbDirIsReadOnly = true;
            }
            catch( const ucb::ContentCreationException& )
            {
            }
            catch( const uno::RuntimeException& )
            {
            }
            catch( const uno::Exception& )
            {
            }
    #endif
            if( xResultSet.is() )
            {
                uno::Reference< ucb::XContentAccess > xContentAccess( xResultSet, uno::UNO_QUERY );

                if( xContentAccess.is() )
                {
                    static const char s_sTitle[] = "Title";
                    static const char s_sIsReadOnly[] = "IsReadOnly";

                    while( xResultSet->next() )
                    {
                        INetURLObject aThmURL( xContentAccess->queryContentIdentifierString() );

                        if(aThmURL.GetExtension().equalsIgnoreAsciiCase("thm"))
                        {
                            INetURLObject   aSdgURL( aThmURL); aSdgURL.SetExtension( "sdg" );
                            INetURLObject   aSdvURL( aThmURL ); aSdvURL.SetExtension( "sdv" );
                            OUString        aTitle;

                            try
                            {
                                ::ucbhelper::Content aThmCnt( aThmURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ), xEnv, comphelper::getProcessComponentContext() );
                                ::ucbhelper::Content aSdgCnt( aSdgURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ), xEnv, comphelper::getProcessComponentContext() );
                                ::ucbhelper::Content aSdvCnt( aSdvURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ), xEnv, comphelper::getProcessComponentContext() );

                                try
                                {
                                    aThmCnt.getPropertyValue( s_sTitle ) >>= aTitle;
                                }
                                catch( const uno::RuntimeException& )
                                {
                                }
                                catch( const uno::Exception& )
                                {
                                }

                                if( !aTitle.isEmpty() )
                                {
                                    bool bReadOnly = false;

                                    try
                                    {
                                        aThmCnt.getPropertyValue( s_sIsReadOnly ) >>= bReadOnly;
                                    }
                                    catch( const uno::RuntimeException& )
                                    {
                                    }
                                    catch( const uno::Exception& )
                                    {
                                    }

                                    if( !bReadOnly )
                                    {
                                        try
                                        {
                                            aSdgCnt.getPropertyValue( s_sTitle ) >>= aTitle;
                                        }
                                        catch( const css::uno::RuntimeException& )
                                        {
                                        }
                                        catch( const css::uno::Exception& )
                                        {
                                        }

                                        if( !aTitle.isEmpty() )
                                        {
                                            try
                                            {
                                                aSdgCnt.getPropertyValue( s_sIsReadOnly ) >>= bReadOnly;
                                            }
                                            catch( const uno::RuntimeException& )
                                            {
                                            }
                                            catch( const uno::Exception& )
                                            {
                                            }
                                        }
                                    }

                                    if( !bReadOnly )
                                    {
                                        try
                                        {
                                            aSdvCnt.getPropertyValue( s_sTitle ) >>= aTitle;
                                        }
                                        catch( const css::uno::RuntimeException& )
                                        {
                                        }
                                        catch( const css::uno::Exception& )
                                        {
                                        }

                                        if( !aTitle.isEmpty() )
                                        {
                                            try
                                            {
                                                aSdvCnt.getPropertyValue( s_sIsReadOnly ) >>= bReadOnly;
                                            }
                                            catch( const uno::RuntimeException& )
                                            {
                                            }
                                            catch( const uno::Exception& )
                                            {
                                            }
                                        }
                                    }

                                    GalleryThemeEntry* pEntry = GalleryTheme::CreateThemeEntry( aThmURL, rbDirIsReadOnly || bReadOnly );

                                    if( pEntry )
                                        aThemeList.emplace_back( pEntry );
                                }
                            }
                            catch( const ucb::ContentCreationException& )
                            {
                            }
                            catch( const uno::RuntimeException& )
                            {
                            }
                            catch( const uno::Exception& )
                            {
                            }
                        }
                    }
                }
            }
        }
        catch( const ucb::ContentCreationException& )
        {
        }
        catch( const uno::RuntimeException& )
        {
        }
        catch( const uno::Exception& )
        {
        }
    }

    GalleryThemeEntry* Gallery::ImplGetThemeEntry( const OUString& rThemeName )
    {
        if( !rThemeName.isEmpty() )
        {
            for ( size_t i = 0, n = aThemeList.size(); i < n; ++i )
                if( rThemeName == aThemeList[ i ]->GetThemeName() )
                    return aThemeList[ i ].get();
        }

        return nullptr;
    }

    OUString Gallery::GetThemeName( sal_uInt32 nThemeId ) const
    {
        GalleryThemeEntry* pFound = nullptr;

        for ( size_t i = 0, n = aThemeList.size(); i < n && !pFound; ++i )
        {
            GalleryThemeEntry* pEntry = aThemeList[ i ].get();
            if( nThemeId == pEntry->GetId() )
                pFound = pEntry;
        }

        // try fallback, if no entry was found
        if( !pFound )
        {
            OUString aFallback;

            switch( nThemeId )
            {
                case GALLERY_THEME_3D:
                    aFallback = SvxResId(RID_GALLERYSTR_THEME_3D);
                    break;
                case GALLERY_THEME_BULLETS:
                    aFallback = SvxResId(RID_GALLERYSTR_THEME_BULLETS);
                    break;
                case GALLERY_THEME_HOMEPAGE:
                    aFallback = SvxResId(RID_GALLERYSTR_THEME_HOMEPAGE);
                    break;
                case GALLERY_THEME_POWERPOINT:
                    aFallback = RID_GALLERYSTR_THEME_POWERPOINT;
                    break;
                case GALLERY_THEME_FONTWORK:
                    aFallback = RID_GALLERYSTR_THEME_FONTWORK;
                    break;
                case GALLERY_THEME_FONTWORK_VERTICAL:
                    aFallback = RID_GALLERYSTR_THEME_FONTWORK_VERTICAL;
                    break;
                case GALLERY_THEME_SOUNDS:
                    aFallback = SvxResId(RID_GALLERYSTR_THEME_SOUNDS);
                    break;
                case RID_GALLERY_THEME_ARROWS:
                    aFallback = SvxResId(RID_GALLERYSTR_THEME_ARROWS);
                    break;
                case RID_GALLERY_THEME_COMPUTERS:
                    aFallback = SvxResId(RID_GALLERYSTR_THEME_COMPUTERS);
                    break;
                case RID_GALLERY_THEME_DIAGRAMS:
                    aFallback = SvxResId(RID_GALLERYSTR_THEME_DIAGRAMS);
                    break;
                case RID_GALLERY_THEME_EDUCATION:
                    aFallback = SvxResId(RID_GALLERYSTR_THEME_EDUCATION);
                    break;
                case RID_GALLERY_THEME_ENVIRONMENT:
                    aFallback = SvxResId(RID_GALLERYSTR_THEME_ENVIRONMENT);
                    break;
                case RID_GALLERY_THEME_FINANCE:
                    aFallback = SvxResId(RID_GALLERYSTR_THEME_FINANCE);
                    break;
                case RID_GALLERY_THEME_PEOPLE:
                    aFallback = SvxResId(RID_GALLERYSTR_THEME_PEOPLE);
                    break;
                case RID_GALLERY_THEME_SYMBOLS:
                    aFallback = SvxResId(RID_GALLERYSTR_THEME_SYMBOLS);
                    break;
                case RID_GALLERY_THEME_TRANSPORT:
                    aFallback = SvxResId(RID_GALLERYSTR_THEME_TRANSPORT);
                    break;
                case RID_GALLERY_THEME_TXTSHAPES:
                    aFallback = SvxResId(RID_GALLERYSTR_THEME_TXTSHAPES);
                    break;
                default:
                    break;
            }

            pFound = const_cast<Gallery*>(this)->ImplGetThemeEntry(aFallback);
        }

        return( pFound ? pFound->GetThemeName() : OUString() );
    }

    bool Gallery::HasTheme( const OUString& rThemeName )
    {
        return( ImplGetThemeEntry( rThemeName ) != nullptr );
    }

    bool Gallery::CreateTheme( const OUString& rThemeName )
    {
        bool bRet = false;

        if( !HasTheme( rThemeName ) && ( GetUserURL().GetProtocol() != INetProtocol::NotValid ) )
        {
            INetURLObject aURL( GetUserURL() );
            aURL.Append( rThemeName );
            GalleryThemeEntry* pNewEntry = new GalleryThemeEntry(
                    true, aURL, rThemeName,
                    false, true, 0, false );

            aThemeList.emplace_back( pNewEntry );
            delete new GalleryTheme( this, pNewEntry );
            Broadcast( GalleryHint( GalleryHintType::THEME_CREATED, rThemeName ) );
            bRet = true;
        }

        return bRet;
    }

    void Gallery::RenameTheme( const OUString& rOldName, const OUString& rNewName )
    {
        GalleryThemeEntry*      pThemeEntry = ImplGetThemeEntry( rOldName );

        // check if the new theme name is already present
        if( pThemeEntry && !HasTheme( rNewName ) && !pThemeEntry->IsReadOnly() )
        {
            SfxListener   aListener;
            GalleryTheme* pThm = AcquireTheme( rOldName, aListener );

            if( pThm )
            {
                pThemeEntry->SetName( rNewName );
                pThm->ImplWrite();

                Broadcast( GalleryHint( GalleryHintType::THEME_RENAMED, rOldName, pThm->GetName() ) );
                ReleaseTheme( pThm, aListener );
            }
        }
    }

    bool Gallery::RemoveTheme( const OUString& rThemeName )
    {
        GalleryThemeEntry*  pThemeEntry = ImplGetThemeEntry( rThemeName );
        bool                bRet = false;

        if( pThemeEntry && !pThemeEntry->IsReadOnly() )
        {
            Broadcast( GalleryHint( GalleryHintType::CLOSE_THEME, rThemeName ) );

            SfxListener     aListener;
            GalleryTheme*   pThm = AcquireTheme( rThemeName, aListener );

            if( pThm )
            {
                INetURLObject   aThmURL( pThm->GetThmURL() );
                INetURLObject   aSdgURL( pThm->GetSdgURL() );
                INetURLObject   aSdvURL( pThm->GetSdvURL() );
                INetURLObject   aStrURL( pThm->GetSdvURL() );

                ReleaseTheme( pThm, aListener );

                KillFile( aThmURL );
                KillFile( aSdgURL );
                KillFile( aSdvURL );
                KillFile( aStrURL );
            }

            auto aEnd = aThemeList.end();
            for ( auto it = aThemeList.begin(); it != aEnd; ++it )
            {
                if ( pThemeEntry == it->get() ) {
                    aThemeList.erase( it );
                    break;
                }
            }

            Broadcast( GalleryHint( GalleryHintType::THEME_REMOVED, rThemeName ) );

            bRet = true;
        }

        return bRet;
    }

    GalleryTheme* Gallery::ImplGetCachedTheme(const GalleryThemeEntry* pThemeEntry)
    {
        GalleryTheme* pTheme = nullptr;

        if( pThemeEntry )
        {
            for (GalleryCacheThemeList::const_iterator it = aThemeCache.begin(); it != aThemeCache.end(); ++it)
            {
                if (pThemeEntry == (*it)->GetThemeEntry())
                {
                    pTheme = (*it)->GetTheme();
                    break;
                }
            }

            if( !pTheme )
            {
                INetURLObject aURL = pThemeEntry->GetThmURL();

                DBG_ASSERT( aURL.GetProtocol() != INetProtocol::NotValid, "invalid URL" );

                std::unique_ptr<GalleryTheme> pNewTheme;
                if( FileExists( aURL ) )
                {
                    std::unique_ptr<SvStream> pIStm(::utl::UcbStreamHelper::CreateStream( aURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ), StreamMode::READ ));

                    if( pIStm )
                    {
                        try
                        {
                            pNewTheme.reset( new GalleryTheme( this, const_cast<GalleryThemeEntry*>(pThemeEntry) ) );
                            ReadGalleryTheme( *pIStm, *pNewTheme );

                            if( pIStm->GetError() )
                                pNewTheme.reset();
                        }
                        catch (const css::ucb::ContentCreationException&)
                        {
                        }
                    }
                }

                pTheme = pNewTheme.get();
                if( pTheme )
                    aThemeCache.push_back( new GalleryThemeCacheEntry( pThemeEntry, std::move(pNewTheme) ));
            }
        }

        return pTheme;
    }

    void Gallery::ImplDeleteCachedTheme( GalleryTheme const * pTheme )
    {
        GalleryCacheThemeList::const_iterator aEnd = aThemeCache.end();
        for (GalleryCacheThemeList::iterator it = aThemeCache.begin(); it != aEnd; ++it)
        {
            if (pTheme == (*it)->GetTheme())
            {
                delete *it;
                aThemeCache.erase(it);
                break;
            }
        }
    }

    GalleryTheme* Gallery::AcquireTheme( const OUString& rThemeName, SfxListener& rListener )
    {
        GalleryTheme*           pTheme = nullptr;
        GalleryThemeEntry*      pThemeEntry = ImplGetThemeEntry( rThemeName );

        if( pThemeEntry && ( ( pTheme = ImplGetCachedTheme( pThemeEntry ) ) != nullptr ) )
            rListener.StartListening(*pTheme, DuplicateHandling::Prevent);

        return pTheme;
    }

    void Gallery::ReleaseTheme( GalleryTheme* pTheme, SfxListener& rListener )
    {
        if( pTheme )
        {
            rListener.EndListening( *pTheme );

            if( !pTheme->HasListeners() )
                ImplDeleteCachedTheme( pTheme );
        }
    }

    bool GalleryThemeEntry::IsDefault() const
    {
        return nId > 0 && nId != GALLERY_THEME_MYTHEME;
    }

    /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

↑ V656 Variables 'aSdvURL', 'aStrURL' are initialized through the call to the same function. It's probably an error or un-optimized code. Consider inspecting the 'pThm->GetSdvURL()' expression. Check lines: 658, 659.

↑ V581 The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 417, 445.