fpicker/source/win32/filepicker/FilterContainer.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2000, 2010 Oracle and/or its affiliates.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * This file is part of OpenOffice.org.
  10  *
  11  * OpenOffice.org is free software: you can redistribute it and/or modify
  12  * it under the terms of the GNU Lesser General Public License version 3
  13  * only, as published by the Free Software Foundation.
  14  *
  15  * OpenOffice.org is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU Lesser General Public License version 3 for more details
  19  * (a copy is included in the LICENSE file that accompanied this code).
  20  *
  21  * You should have received a copy of the GNU Lesser General Public License
  22  * version 3 along with OpenOffice.org.  If not, see
  23  * <http://www.openoffice.org/license.html>
  24  * for a copy of the LGPLv3 License.
  25  *
  26  ************************************************************************/
  27
  28 // MARKER(update_precomp.py): autogen include statement, do not remove
  29 #include "precompiled_fpicker.hxx"
  30
  31
  32 #include <stdexcept>
  33 #include <osl/diagnose.h>
  34 #include "FilterContainer.hxx"
  35
  36 #include <utility>
  37
  38 #if defined _MSC_VER
  39 #pragma warning(push, 1)
  40 #endif
  41 #include <windows.h>
  42 #if defined _MSC_VER
  43 #pragma warning(pop)
  44 #endif
  45
  46 //-------------------------------------------------------------------
  47 // namespace directives
  48 //-------------------------------------------------------------------
  49
  50 using ::rtl::OUString;
  51
  52 //-------------------------------------------------------------------------------------
  53 // ctor
  54 //-------------------------------------------------------------------------------------
  55
  56 CFilterContainer::CFilterContainer( sal_Int32 initSize ) :
  57     m_vFilters( initSize ),
  58     m_bIterInitialized( sal_False )
  59 {
  60 }
  61
  62 //-----------------------------------------------------------------------------------------
  63 // add a name/filter pair
  64 //-----------------------------------------------------------------------------------------
  65
  66 sal_Bool SAL_CALL CFilterContainer::addFilter(
  67     const OUString& aName, const OUString& aFilter, sal_Bool bAllowDuplicates )
  68 {
  69     // check if the filter is already in the container
  70     sal_Int32 pos = -1;
  71
  72     if ( !bAllowDuplicates )
  73     {
  74         pos = getFilterTagPos( aName );
  75         if ( pos < 0 ) // if not there, append
  76         {
  77             m_vFilters.push_back( std::make_pair( aName, aFilter ) );
  78             m_bIterInitialized = sal_False;
  79         }
  80     }
  81     else
  82     {
  83         m_vFilters.push_back( std::make_pair( aName, aFilter ) );
  84         m_bIterInitialized = sal_False;
  85     }
  86
  87     return ( pos < 0 ) ? sal_True : sal_False;
  88 }
  89
  90 //-----------------------------------------------------------------------------------------
  91 // delete a filter
  92 // Precondition: the container is not empty
  93 //               there is a filter identified by the given name
  94 //-----------------------------------------------------------------------------------------
  95
  96 sal_Bool SAL_CALL CFilterContainer::delFilter( const OUString& aName )
  97 {
  98     OSL_ASSERT( m_vFilters.size() > 0 );
  99
 100     sal_Int32 pos = getFilterTagPos( aName );
 101     if ( pos > -1 )
 102     {
 103         m_vFilters.erase( ( m_vFilters.begin() + pos ) );
 104         m_bIterInitialized = sal_False;
 105     }
 106
 107     return ( pos > -1 ) ? sal_True : sal_False;
 108 }
 109
 110 //-----------------------------------------------------------------------------------------
 111 // return the number of filters currently in the container
 112 //-----------------------------------------------------------------------------------------
 113
 114 sal_Int32 SAL_CALL CFilterContainer::numFilter( )
 115 {
 116     return m_vFilters.size( );
 117 }
 118
 119 //-----------------------------------------------------------------------------------------
 120 // clear all entries
 121 //-----------------------------------------------------------------------------------------
 122
 123 void SAL_CALL CFilterContainer::empty()
 124 {
 125     m_vFilters.clear( );
 126 }
 127
 128 //-----------------------------------------------------------------------------------------
 129 // get a filter by name
 130 // Precondition: the container is not empty
 131 //               there is a filter identified by the name
 132 //-----------------------------------------------------------------------------------------
 133
 134 sal_Bool SAL_CALL CFilterContainer::getFilter( const OUString& aName, OUString& theFilter ) const
 135 {
 136     OSL_PRECOND( m_vFilters.size() > 0, "Empty filter container" );
 137
 138     sal_Int32 pos = getFilterTagPos( aName );
 139
 140     try
 141     {
 142         if ( pos > -1 )
 143             theFilter = m_vFilters.at( pos ).second;
 144     }
 145     catch( std::out_of_range& )
 146     {
 147         OSL_ENSURE( sal_False, "Filter not in filter container" );
 148         pos = -1;
 149     }
 150
 151     return (pos > -1 ) ? sal_True : sal_False;
 152 }
 153
 154 //-----------------------------------------------------------------------------------------
 155 //
 156 //-----------------------------------------------------------------------------------------
 157
 158 sal_Bool SAL_CALL CFilterContainer::getFilter( sal_Int32 aIndex, OUString& theFilter ) const
 159 {
 160     sal_Bool bRet = sal_True;
 161
 162     try
 163     {
 164         theFilter = m_vFilters.at( aIndex ).first;
 165     }
 166     catch( std::out_of_range& )
 167     {
 168         OSL_ENSURE( sal_False, "Filter index out of range" );
 169         bRet = sal_False;
 170     }
 171
 172     return bRet;
 173 }
 174
 175 //-----------------------------------------------------------------------------------------
 176 //
 177 //-----------------------------------------------------------------------------------------
 178
 179 sal_Int32 SAL_CALL CFilterContainer::getFilterPos( const OUString& aName ) const
 180 {
 181     return getFilterTagPos( aName );
 182 }
 183
 184 //-----------------------------------------------------------------------------------------
 185 // returns the index of the filter identified by name
 186 //-----------------------------------------------------------------------------------------
 187
 188 sal_Int32 SAL_CALL CFilterContainer::getFilterTagPos( const OUString& aName ) const
 189 {
 190     if ( m_vFilters.size( ) > 0 )
 191     {
 192         sal_Int32 i = 0;
 193         FILTER_VECTOR_T::const_iterator iter;
 194         FILTER_VECTOR_T::const_iterator iter_end = m_vFilters.end( );
 195
 196         for ( iter = m_vFilters.begin( ); iter != iter_end; ++iter, ++i )
 197             if ( ( *iter ).first.equalsIgnoreAsciiCase( aName ) )
 198                 return i;
 199     }
 200
 201     return -1;
 202 }
 203
 204 //-----------------------------------------------------------------------------------------
 205 // starts enumerating the filter in the container
 206 //-----------------------------------------------------------------------------------------
 207
 208 void SAL_CALL CFilterContainer::beginEnumFilter( )
 209 {
 210     m_iter = m_vFilters.begin( );
 211     m_bIterInitialized = sal_True;
 212 }
 213
 214 //-----------------------------------------------------------------------------------------
 215 // returns true if another filter has been retrieved
 216 //-----------------------------------------------------------------------------------------
 217
 218 sal_Bool SAL_CALL CFilterContainer::getNextFilter( FILTER_ENTRY_T& nextFilterEntry )
 219 {
 220     OSL_ASSERT( m_bIterInitialized );
 221
 222     sal_Bool bRet = ( m_iter != m_vFilters.end( ) );
 223
 224     if ( bRet )
 225         nextFilterEntry = *m_iter++;
 226     else
 227         m_bIterInitialized = sal_False;
 228
 229     return bRet;
 230 }
 231
 232 //-----------------------------------------------------------------------------------------
 233 void SAL_CALL CFilterContainer::setCurrentFilter( const ::rtl::OUString& aName )
 234 {
 235     m_sCurrentFilter = aName;
 236 }
 237
 238 //-----------------------------------------------------------------------------------------
 239 ::rtl::OUString SAL_CALL CFilterContainer::getCurrentFilter() const
 240 {
 241     return m_sCurrentFilter;
 242 }
 243
 244 //###################################################################
 245
 246
 247 //-------------------------------------------------------------------
 248 // calculates the length of a '\0' separated filter, that means
 249 // length of the name + '\0' + length of the filter string +
 250 // a trailing '\0'
 251 //-------------------------------------------------------------------
 252
 253 static sal_uInt32 _getLengthFilter( CFilterContainer::FILTER_ENTRY_T aFilterEntry )
 254 {
 255     return (
 256         aFilterEntry.first.getLength( )  + 1 +
 257         aFilterEntry.second.getLength( ) + 1 );
 258 }
 259
 260 //-------------------------------------------------------------------
 261 // calculates the length of all filters currently in the container
 262 //-------------------------------------------------------------------
 263
 264 static sal_uInt32 _getTotalFilterLength( CFilterContainer& aFilterContainer )
 265 {
 266     CFilterContainer::FILTER_ENTRY_T nextFilter;
 267
 268     aFilterContainer.beginEnumFilter( );
 269
 270     sal_uInt32 totalLength = 0;
 271     while( aFilterContainer.getNextFilter( nextFilter ) )
 272         totalLength += _getLengthFilter( nextFilter );
 273
 274     return ( totalLength > 0 ) ? totalLength + 1 : totalLength;
 275 }
 276
 277 //-------------------------------------------------------------------
 278 //
 279 //-------------------------------------------------------------------
 280
 281 inline
 282 void _wcsmemcpy( sal_Unicode* pDest, const sal_Unicode* pSrc, sal_uInt32 nLength )
 283 {
 284     memcpy( pDest, pSrc, nLength * sizeof( sal_Unicode ) );
 285 }
 286
 287 //-------------------------------------------------------------------
 288 // a helper trivial helper function to create a filter buffer in the
 289 // format the Win32 API requires,
 290 // e.g. "Text\0*.txt\0Doc\0*.doc;*xls\0\0"
 291 //-------------------------------------------------------------------
 292
 293 rtl::OUString SAL_CALL makeWinFilterBuffer( CFilterContainer& aFilterContainer )
 294 {
 295     // calculate the required buffer size
 296     sal_uInt32 reqBuffSize = _getTotalFilterLength( aFilterContainer );
 297
 298     // return if there are no filters
 299     if ( !reqBuffSize )
 300         return OUString( );
 301
 302     sal_Unicode* pBuff = new sal_Unicode[reqBuffSize];
 303
 304     // initialize the buffer with 0
 305     ZeroMemory( pBuff, sizeof( sal_Unicode ) * reqBuffSize );
 306
 307     OUString winFilterBuff;
 308     CFilterContainer::FILTER_ENTRY_T nextFilter;
 309     sal_uInt32 memPos = 0;
 310
 311     aFilterContainer.beginEnumFilter( );
 312
 313     while( aFilterContainer.getNextFilter( nextFilter ) )
 314     {
 315         _wcsmemcpy(
 316             pBuff + memPos,
 317             nextFilter.first.getStr( ),
 318             nextFilter.first.getLength( ) );
 319
 320         memPos += nextFilter.first.getLength( ) + 1;
 321
 322         _wcsmemcpy(
 323             pBuff + memPos,
 324             nextFilter.second.getStr( ),
 325             nextFilter.second.getLength( ) );
 326
 327         memPos += nextFilter.second.getLength( ) + 1 ;
 328     }
 329
 330     winFilterBuff = OUString( pBuff, reqBuffSize );
 331
 332     // remove the allocated buffer
 333     delete [] pBuff;
 334
 335     return winFilterBuff;
 336 }
 337