fpicker/source/win32/filepicker/FilterContainer.cxx

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