fpicker/source/aqua/FilterHelper.mm

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