fpicker/source/aqua/FilterHelper.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: FilterHelper.cxx,v $
  10  * $Revision: 1.5 $
  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 #include <functional>
  32 #include <algorithm>
  33 #include <vos/mutex.hxx>
  34 #include <vcl/svapp.hxx>
  35
  36 // #ifndef _OSL_DIAGNOSE_H_
  37 // #include <osl/diagnose.h>
  38 // #endif
  39 #include "CFStringUtilities.hxx"
  40 #include "NSString_OOoAdditions.hxx"
  41
  42 #include "FilterHelper.hxx"
  43
  44 #pragma mark DEFINES
  45 #define CLASS_NAME "FilterEntry"
  46
  47 #pragma mark FilterEntry
  48 //---------------------------------------------------------------------
  49 FilterEntry::FilterEntry( const rtl::OUString& _rTitle, const UnoFilterList& _rSubFilters )
  50 :m_sTitle( _rTitle )
  51 ,m_aSubFilters( _rSubFilters )
  52 {
  53     DBG_PRINT_ENTRY(CLASS_NAME, __func__, "title", _rTitle);
  54     DBG_PRINT_EXIT(CLASS_NAME, __func__);
  55 }
  56
  57 //---------------------------------------------------------------------
  58 sal_Bool FilterEntry::hasSubFilters() const
  59 {
  60 //    OSL_TRACE(">>> FilterEntry::%s", __func__);
  61     sal_Bool bReturn = ( 0 < m_aSubFilters.getLength() );
  62 //    OSL_TRACE("<<< FilterEntry::%s retVal: %d", __func__, bReturn);
  63     return bReturn;
  64 }
  65
  66 //---------------------------------------------------------------------
  67 sal_Int32 FilterEntry::getSubFilters( UnoFilterList& _rSubFilterList )
  68 {
  69     DBG_PRINT_ENTRY(CLASS_NAME, __func__);
  70
  71     _rSubFilterList = m_aSubFilters;
  72     sal_Int32 nReturn = m_aSubFilters.getLength();
  73
  74     DBG_PRINT_EXIT(CLASS_NAME, __func__, nReturn);
  75
  76     return nReturn;
  77 }
  78
  79 #pragma mark statics
  80 static bool
  81 isFilterString( const rtl::OUString& rFilterString, const char *pMatch )
  82 {
  83     sal_Int32 nIndex = 0;
  84     rtl::OUString aToken;
  85     bool bIsFilter = true;
  86
  87     rtl::OUString aMatch(rtl::OUString::createFromAscii(pMatch));
  88
  89     do
  90     {
  91         aToken = rFilterString.getToken( 0, ';', nIndex );
  92         if( !aToken.match( aMatch ) )
  93         {
  94             bIsFilter = false;
  95             break;
  96         }
  97     }
  98     while( nIndex >= 0 );
  99
 100     return bIsFilter;
 101 }
 102
 103 //=====================================================================
 104
 105 static rtl::OUString
 106 shrinkFilterName( const rtl::OUString aFilterName, bool bAllowNoStar = false )
 107 {
 108     // DBG_PRINT_ENTRY(CLASS_NAME, "shrinkFilterName", "filterName", aFilterName);
 109
 110     int i;
 111     int nBracketLen = -1;
 112     int nBracketEnd = -1;
 113     rtl::OUString rFilterName = aFilterName;
 114     const sal_Unicode *pStr = rFilterName;
 115     rtl::OUString aRealName = rFilterName;
 116
 117     for( i = aRealName.getLength() - 1; i > 0; i-- )
 118     {
 119         if( pStr[i] == ')' )
 120             nBracketEnd = i;
 121         else if( pStr[i] == '(' )
 122         {
 123             nBracketLen = nBracketEnd - i;
 124             if( nBracketEnd <= 0 )
 125                 continue;
 126             if( isFilterString( rFilterName.copy( i + 1, nBracketLen - 1 ), "*." ) )
 127                 aRealName = aRealName.replaceAt( i, nBracketLen + 1, rtl::OUString() );
 128             else if (bAllowNoStar)
 129             {
 130                 if( isFilterString( rFilterName.copy( i + 1, nBracketLen - 1 ), ".") )
 131                     aRealName = aRealName.replaceAt( i, nBracketLen + 1, rtl::OUString() );
 132             }
 133         }
 134     }
 135
 136     return aRealName;
 137 }
 138
 139 //------------------------------------------------------------------------------------
 140 namespace {
 141     //................................................................................
 142     struct FilterTitleMatch : public ::std::unary_function< FilterEntry, bool >
 143     {
 144 protected:
 145         const rtl::OUString rTitle;
 146
 147 public:
 148         FilterTitleMatch( const rtl::OUString _rTitle ) : rTitle( _rTitle ) { }
 149
 150         //............................................................................
 151         bool operator () ( const FilterEntry& _rEntry )
 152         {
 153             sal_Bool bMatch;
 154             if( !_rEntry.hasSubFilters() ) {
 155                 //first try the complete filter name
 156                 rtl::OUString title = _rEntry.getTitle();
 157                 bMatch = ( title.equals(rTitle) );
 158                 if (!bMatch) {
 159                     //we didn't find a match using the full name, let's give it another
 160                     //try using the shrunk version
 161                     rtl::OUString aShrunkName = shrinkFilterName( _rEntry.getTitle() ).trim();
 162                     bMatch = ( aShrunkName.equals(rTitle) );
 163                 }
 164             }
 165             else
 166                 // a filter group -> search the sub filters
 167                 bMatch =
 168                     _rEntry.endSubFilters() != ::std::find_if(
 169                                                               _rEntry.beginSubFilters(),
 170                                                               _rEntry.endSubFilters(),
 171                                                               *this
 172                                                               );
 173
 174             return bMatch ? true : false;
 175         }
 176
 177         bool operator () ( const UnoFilterEntry& _rEntry )
 178         {
 179             rtl::OUString aShrunkName = shrinkFilterName( _rEntry.First );
 180             bool retVal = aShrunkName.equals(rTitle);
 181             return retVal;
 182         }
 183     };
 184 }
 185
 186 #undef CLASS_NAME
 187 #define CLASS_NAME "FilterHelper"
 188
 189 FilterHelper::FilterHelper()
 190 : m_pFilterList(NULL)
 191 , m_pFilterNames(NULL)
 192 {
 193     DBG_PRINT_ENTRY(CLASS_NAME, __func__);
 194     DBG_PRINT_EXIT(CLASS_NAME, __func__);
 195 }
 196
 197 FilterHelper::~FilterHelper()
 198 {
 199     DBG_PRINT_ENTRY(CLASS_NAME, __func__);
 200
 201     NSAutoreleasePool *pool = [NSAutoreleasePool new];
 202
 203     if (NULL != m_pFilterList) {
 204         delete m_pFilterList;
 205     }
 206
 207     if (NULL != m_pFilterNames) {
 208         //we called retain when we added the strings to the list, so we should release them now
 209         for (NSStringList::iterator iter = m_pFilterNames->begin(); iter != m_pFilterNames->end(); iter++) {
 210             [*iter release];
 211         }
 212         delete m_pFilterNames;
 213     }
 214
 215     [pool release];
 216
 217     DBG_PRINT_EXIT(CLASS_NAME, __func__);
 218 }
 219
 220 //------------------------------------------------------------------------------------
 221 sal_Bool FilterHelper::FilterNameExists( const rtl::OUString rTitle )
 222 {
 223     sal_Bool bRet = sal_False;
 224
 225     if( m_pFilterList )
 226         bRet =
 227             m_pFilterList->end() != ::std::find_if(
 228                                                    m_pFilterList->begin(),
 229                                                    m_pFilterList->end(),
 230                                                    FilterTitleMatch( rTitle )
 231                                                    );
 232
 233     return bRet;
 234 }
 235
 236 //------------------------------------------------------------------------------------
 237 sal_Bool FilterHelper::FilterNameExists( const UnoFilterList& _rGroupedFilters )
 238 {
 239     sal_Bool bRet = sal_False;
 240
 241     if( m_pFilterList )
 242     {
 243         const UnoFilterEntry* pStart = _rGroupedFilters.getConstArray();
 244         const UnoFilterEntry* pEnd = pStart + _rGroupedFilters.getLength();
 245         for( ; pStart != pEnd; ++pStart )
 246             if( m_pFilterList->end() != ::std::find_if(
 247                                                         m_pFilterList->begin(),
 248                                                         m_pFilterList->end(),
 249                                                         FilterTitleMatch( pStart->First ) ) )
 250                 break;
 251
 252         bRet = (pStart != pEnd);
 253     }
 254
 255     return bRet;
 256 }
 257
 258 //------------------------------------------------------------------------------------
 259 void FilterHelper::ensureFilterList( const ::rtl::OUString& _rInitialCurrentFilter )
 260 {
 261     //OSL_TRACE(">>> FilterHelper::%s", __func__);
 262     if( NULL == m_pFilterList )
 263     {
 264         m_pFilterList = new FilterList;
 265
 266         // set the first filter to the current filter
 267         m_aCurrentFilter = _rInitialCurrentFilter;
 268         OSL_TRACE("ensureFilterList filter:%s", OUStringToOString(m_aCurrentFilter, RTL_TEXTENCODING_UTF8).getStr());
 269     }
 270     //OSL_TRACE("<<< FilterHelper::%s", __func__);
 271 }
 272
 273 void FilterHelper::SetCurFilter( const rtl::OUString& rFilter )
 274 {
 275     DBG_PRINT_ENTRY(CLASS_NAME, __func__, "filter", rFilter);
 276
 277     ::vos::OGuard aGuard( Application::GetSolarMutex() );
 278
 279     if(m_aCurrentFilter.equals(rFilter) == false)
 280     {
 281         m_aCurrentFilter = rFilter;
 282     }
 283
 284     //only for output purposes
 285 #if OSL_DEBUG_LEVEL > 1
 286     FilterList::iterator aFilter = ::std::find_if(m_pFilterList->begin(), m_pFilterList->end(), FilterTitleMatch(m_aCurrentFilter));
 287     if (aFilter != m_pFilterList->end()) {
 288         OUStringList suffixes = aFilter->getFilterSuffixList();
 289         if (!suffixes.empty()) {
 290             OSL_TRACE("Current active suffixes: ");
 291             OUStringList::iterator suffIter = suffixes.begin();
 292             while(suffIter != suffixes.end()) {
 293                 OSL_TRACE("%s", OUStringToOString((*suffIter), RTL_TEXTENCODING_UTF8).getStr());
 294                 suffIter++;
 295             }
 296         }
 297     } else {
 298         OSL_TRACE("No filter entry was found for that name!");
 299     }
 300 #endif
 301
 302     DBG_PRINT_EXIT(CLASS_NAME, __func__);
 303 }
 304
 305 void FilterHelper::SetFilters()
 306 {
 307     DBG_PRINT_ENTRY(CLASS_NAME, __func__);
 308
 309     // set the default filter
 310     if( m_aCurrentFilter.getLength() > 0 )
 311     {
 312         OSL_TRACE( "Setting current filter to %s", OUStringToOString(m_aCurrentFilter, RTL_TEXTENCODING_UTF8).getStr());
 313
 314         SetCurFilter( m_aCurrentFilter );
 315     }
 316
 317     DBG_PRINT_EXIT(CLASS_NAME, __func__);
 318 }
 319
 320 void FilterHelper::appendFilter(const ::rtl::OUString& aTitle, const ::rtl::OUString& aFilterString)
 321 throw( ::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException ) {
 322     DBG_PRINT_ENTRY(CLASS_NAME, __func__, "title", aTitle, "filter", aFilterString);
 323
 324     ::vos::OGuard aGuard( Application::GetSolarMutex() );
 325
 326     if( FilterNameExists( aTitle ) ) {
 327         throw com::sun::star::lang::IllegalArgumentException();
 328     }
 329
 330     // ensure that we have a filter list
 331     ensureFilterList( aTitle );
 332
 333     // append the filter
 334     OUStringList suffixList;
 335     fillSuffixList(suffixList, aFilterString);
 336     m_pFilterList->push_back(FilterEntry( aTitle, suffixList ) );
 337
 338     DBG_PRINT_EXIT(CLASS_NAME, __func__);
 339 }
 340
 341 void FilterHelper::setCurrentFilter( const ::rtl::OUString& aTitle )
 342 throw( ::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException ) {
 343     DBG_PRINT_ENTRY(CLASS_NAME, __func__, "aTitle", OUStringToOString(aTitle, RTL_TEXTENCODING_UTF8).getStr());
 344
 345     SetCurFilter(aTitle);
 346
 347     DBG_PRINT_EXIT(CLASS_NAME, __func__);
 348 }
 349
 350 ::rtl::OUString SAL_CALL FilterHelper::getCurrentFilter(  )
 351 throw( ::com::sun::star::uno::RuntimeException ) {
 352     DBG_PRINT_ENTRY(CLASS_NAME, __func__);
 353
 354     ::rtl::OUString sReturn = (m_aCurrentFilter);
 355
 356     DBG_PRINT_EXIT(CLASS_NAME, __func__, OUStringToOString(sReturn, RTL_TEXTENCODING_UTF8).getStr());
 357
 358     return sReturn;
 359 }
 360
 361 void SAL_CALL FilterHelper::appendFilterGroup( const ::rtl::OUString& sGroupTitle, const ::com::sun::star::uno::Sequence< ::com::sun::star::beans::StringPair >& aFilters )
 362 throw (::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException) {
 363
 364     DBG_PRINT_ENTRY(CLASS_NAME, __func__, "title", OUStringToOString(sGroupTitle, RTL_TEXTENCODING_UTF8).getStr());
 365
 366     ::vos::OGuard aGuard( Application::GetSolarMutex() );
 367
 368     //add a separator if this is not the first group to be added
 369     sal_Bool bPrependSeparator = m_pFilterList != NULL;
 370
 371     // ensure that we have a filter list
 372     ::rtl::OUString sInitialCurrentFilter;
 373     if( aFilters.getLength() > 0)
 374         sInitialCurrentFilter = aFilters[0].First;
 375     ensureFilterList( sInitialCurrentFilter );
 376
 377     // append the filter
 378     if (bPrependSeparator) {
 379         rtl::OUString dash = rtl::OUString::createFromAscii("-");
 380         OUStringList emptyList;
 381         m_pFilterList->push_back(FilterEntry(dash, emptyList));
 382     }
 383
 384     const com::sun::star::beans::StringPair* pSubFilters   = aFilters.getConstArray();
 385     const com::sun::star::beans::StringPair* pSubFiltersEnd = pSubFilters + aFilters.getLength();
 386     for( ; pSubFilters != pSubFiltersEnd; ++pSubFilters ) {
 387         appendFilter(pSubFilters->First, pSubFilters->Second);
 388     }
 389
 390     DBG_PRINT_EXIT(CLASS_NAME, __func__);
 391 }
 392
 393 sal_Bool FilterHelper::filenameMatchesFilter(NSString* sFilename)
 394 {
 395     DBG_PRINT_ENTRY(CLASS_NAME, __func__);
 396
 397 //    OSL_TRACE("filter event handler called");
 398
 399     if (m_aCurrentFilter == NULL) {
 400         OSL_TRACE("filter name is null");
 401         return sal_True;
 402     }
 403
 404     NSFileManager *manager = [NSFileManager defaultManager];
 405     MacOSBOOL bDir = NO;
 406     if ([manager fileExistsAtPath:sFilename isDirectory:&bDir] && bDir == YES) {
 407 //        OSL_TRACE(" folder");
 408         return sal_True;
 409     }
 410
 411     NSFileWrapper *wrapper = [[NSFileWrapper alloc] initWithPath:sFilename];
 412     MacOSBOOL bIsLink = [wrapper isSymbolicLink];
 413     [wrapper release];
 414     if (bIsLink) {
 415 //        OSL_TRACE(" symboliclink");
 416         return sal_True;
 417     }
 418
 419 //    OSL_TRACE(" file");
 420
 421     FilterList::iterator filter = ::std::find_if(m_pFilterList->begin(), m_pFilterList->end(), FilterTitleMatch(m_aCurrentFilter));
 422     if (filter == m_pFilterList->end()) {
 423         OSL_TRACE("filter not found in list");
 424         return sal_True;
 425     }
 426
 427     OUStringList suffixList = filter->getFilterSuffixList();
 428
 429     {
 430 //        OSL_TRACE(" starting to work");
 431         rtl::OUString aName = [sFilename OUString];
 432         rtl::OUString allMatcher = rtl::OUString::createFromAscii(".*");
 433         for(OUStringList::iterator iter = suffixList.begin(); iter != suffixList.end(); iter++) {
 434             if (aName.matchIgnoreAsciiCase(*iter, aName.getLength() - (*iter).getLength()) || ((*iter).equals(allMatcher))) {
 435                 return sal_True;
 436             }
 437         }
 438     }
 439
 440     DBG_PRINT_EXIT(CLASS_NAME, __func__);
 441
 442     return sal_False;
 443 }
 444
 445 FilterList* FilterHelper::getFilterList() {
 446     DBG_PRINT_ENTRY(CLASS_NAME, __func__);
 447     DBG_PRINT_EXIT(CLASS_NAME, __func__);
 448
 449     return m_pFilterList;
 450 }
 451
 452 NSStringList* FilterHelper::getFilterNames() {
 453     DBG_PRINT_ENTRY(CLASS_NAME, __func__);
 454
 455     if (NULL == m_pFilterList)
 456         return NULL;
 457     if (NULL == m_pFilterNames) {
 458         //build filter names list
 459         m_pFilterNames = new NSStringList;
 460         for (FilterList::iterator iter = m_pFilterList->begin(); iter != m_pFilterList->end(); iter++) {
 461             m_pFilterNames->push_back([[NSString stringWithOUString:iter->getTitle()] retain]);
 462         }
 463     }
 464
 465     DBG_PRINT_EXIT(CLASS_NAME, __func__);
 466
 467     return m_pFilterNames;
 468 }
 469
 470 void FilterHelper::SetFilterAtIndex(unsigned index) {
 471     DBG_PRINT_ENTRY(CLASS_NAME, __func__, "index", index);
 472
 473     if (m_pFilterList->size() <= index) {
 474         index = 0;
 475     }
 476     FilterEntry entry = m_pFilterList->at(index);
 477     SetCurFilter(entry.getTitle());
 478
 479     DBG_PRINT_EXIT(CLASS_NAME, __func__);
 480 }
 481
 482 void FilterHelper::fillSuffixList(OUStringList& aSuffixList, const ::rtl::OUString& suffixString) {
 483     DBG_PRINT_ENTRY(CLASS_NAME, __func__, "aSuffixList", suffixString);
 484
 485     sal_Int32 nIndex = 0;
 486     do {
 487         rtl::OUString aToken = suffixString.getToken( 0, ';', nIndex );
 488         aSuffixList.push_back(aToken.copy(1));
 489     } while ( nIndex >= 0 );
 490
 491     DBG_PRINT_EXIT(CLASS_NAME, __func__);
 492 }
 493
 494 int FilterHelper::getCurrentFilterIndex() {
 495     DBG_PRINT_ENTRY(CLASS_NAME, __func__);
 496
 497     int result = 0;//default to first filter
 498     if (m_aCurrentFilter.getLength() > 0) {
 499         int i = 0;
 500         for (FilterList::iterator iter = m_pFilterList->begin(); iter != m_pFilterList->end(); iter++, i++) {
 501             rtl::OUString aTitle = iter->getTitle();
 502             if (m_aCurrentFilter.equals(aTitle)) {
 503                 result = i;
 504                 break;
 505             } else {
 506                 aTitle = shrinkFilterName(aTitle).trim();
 507                 if (m_aCurrentFilter.equals(aTitle)) {
 508                     result = i;
 509                     break;
 510                 }
 511             }
 512         }
 513     }
 514
 515     DBG_PRINT_EXIT(CLASS_NAME, __func__, result);
 516
 517     return result;
 518 }
 519
 520 OUStringList FilterHelper::getCurrentFilterSuffixList() {
 521     DBG_PRINT_ENTRY(CLASS_NAME, __func__);
 522
 523     OUStringList retVal;
 524     if (m_aCurrentFilter.getLength() > 0) {
 525         for (FilterList::iterator iter = m_pFilterList->begin(); iter != m_pFilterList->end(); iter++) {
 526             rtl::OUString aTitle = iter->getTitle();
 527             if (m_aCurrentFilter.equals(aTitle)) {
 528                 retVal = iter->getFilterSuffixList();
 529                 break;
 530             } else {
 531                 aTitle = shrinkFilterName(aTitle).trim();
 532                 if (m_aCurrentFilter.equals(aTitle)) {
 533                     retVal = iter->getFilterSuffixList();
 534                     break;
 535                 }
 536             }
 537         }
 538     }
 539
 540     DBG_PRINT_EXIT(CLASS_NAME, __func__);
 541
 542     return retVal;
 543 }