ucb/source/ucp/gio/gio_datasupplier.cxx

   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 <vector>
  21
  22 #include <ucbhelper/contentidentifier.hxx>
  23 #include <ucbhelper/providerhelper.hxx>
  24
  25 #include <com/sun/star/ucb/OpenMode.hpp>
  26
  27 #include "gio_datasupplier.hxx"
  28 #include "gio_content.hxx"
  29 #include "gio_provider.hxx"
  30
  31 using namespace com::sun::star;
  32
  33 using namespace gio;
  34
  35 namespace gio
  36 {
  37
  38 typedef std::vector< ResultListEntry* > ResultList;
  39
  40 DataSupplier::DataSupplier( const uno::Reference< lang::XMultiServiceFactory >& rxSMgr,
  41     const uno::Reference< ::gio::Content >& rContent, sal_Int32 nOpenMode )
  42     : mxContent(rContent), m_xSMgr(rxSMgr), mnOpenMode(nOpenMode), mbCountFinal(false)
  43 {
  44 }
  45
  46 bool DataSupplier::getData()
  47 {
  48     if (mbCountFinal)
  49         return true;
  50
  51     GFile *pFile = mxContent->getGFile();
  52
  53     GFileEnumerator* pEnumerator = g_file_enumerate_children(pFile, "*",
  54         G_FILE_QUERY_INFO_NONE, NULL, NULL);
  55
  56     if (!pEnumerator)
  57         return false;
  58
  59     GFileInfo *pInfo = NULL;
  60     while ((pInfo = g_file_enumerator_next_file (pEnumerator, NULL, NULL)))
  61     {
  62         switch ( mnOpenMode )
  63         {
  64             case ucb::OpenMode::FOLDERS:
  65                 if (g_file_info_get_file_type(pInfo) != G_FILE_TYPE_DIRECTORY)
  66                     continue;
  67                 break;
  68             case ucb::OpenMode::DOCUMENTS:
  69                 if (g_file_info_get_file_type(pInfo) != G_FILE_TYPE_REGULAR)
  70                     continue;
  71                 break;
  72             case ucb::OpenMode::ALL:
  73             default:
  74                 break;
  75         }
  76
  77         maResults.push_back( new ResultListEntry( pInfo ) );
  78         g_object_unref(pInfo);
  79     }
  80
  81     mbCountFinal = true;
  82
  83     g_file_enumerator_close(pEnumerator, NULL, NULL);
  84     return true;
  85 }
  86
  87 DataSupplier::~DataSupplier()
  88 {
  89     ResultList::const_iterator it  = maResults.begin();
  90     ResultList::const_iterator end = maResults.end();
  91
  92     while ( it != end )
  93     {
  94         delete (*it);
  95         ++it;
  96     }
  97 }
  98
  99 OUString DataSupplier::queryContentIdentifierString( sal_uInt32 nIndex )
 100 {
 101     if ( nIndex < maResults.size() )
 102     {
 103         OUString aId = maResults[ nIndex ]->aId;
 104         if ( aId.getLength() )
 105         {
 106             // Already cached.
 107             return aId;
 108         }
 109     }
 110
 111     if ( getResult( nIndex ) )
 112     {
 113         GFile *pFile = mxContent->getGFile();
 114         char* parent = g_file_get_uri(pFile);
 115         OUString aId = OUString::createFromAscii( parent );
 116         g_free(parent);
 117
 118         char *escaped_name =
 119             g_uri_escape_string( g_file_info_get_name(maResults[ nIndex ]->pInfo) , NULL, false);
 120
 121         if ( ( aId.lastIndexOf( '/' ) + 1 ) != aId.getLength() )
 122                 aId += "/";
 123
 124         aId += OUString::createFromAscii( escaped_name );
 125
 126         g_free( escaped_name );
 127
 128         maResults[ nIndex ]->aId = aId;
 129         return aId;
 130     }
 131
 132     return OUString();
 133 }
 134
 135 uno::Reference< ucb::XContentIdentifier > DataSupplier::queryContentIdentifier( sal_uInt32 nIndex )
 136 {
 137     if ( nIndex < maResults.size() )
 138     {
 139         uno::Reference< ucb::XContentIdentifier > xId = maResults[ nIndex ]->xId;
 140         if ( xId.is() )
 141         {
 142             // Already cached.
 143             return xId;
 144         }
 145     }
 146
 147     OUString aId = queryContentIdentifierString( nIndex );
 148     if ( aId.getLength() )
 149     {
 150         uno::Reference< ucb::XContentIdentifier > xId = new ucbhelper::ContentIdentifier( aId );
 151         maResults[ nIndex ]->xId = xId;
 152         return xId;
 153     }
 154
 155     return uno::Reference< ucb::XContentIdentifier >();
 156 }
 157
 158 uno::Reference< ucb::XContent > DataSupplier::queryContent( sal_uInt32 nIndex )
 159 {
 160     if ( nIndex < maResults.size() )
 161     {
 162         uno::Reference< ucb::XContent > xContent = maResults[ nIndex ]->xContent;
 163         if ( xContent.is() )
 164         {
 165             // Already cached.
 166             return xContent;
 167         }
 168     }
 169
 170     uno::Reference< ucb::XContentIdentifier > xId = queryContentIdentifier( nIndex );
 171     if ( xId.is() )
 172     {
 173         try
 174         {
 175             uno::Reference< ucb::XContent > xContent = mxContent->getProvider()->queryContent( xId );
 176             maResults[ nIndex ]->xContent = xContent;
 177             return xContent;
 178         }
 179         catch ( ucb::IllegalIdentifierException& )
 180         {
 181         }
 182     }
 183     return uno::Reference< ucb::XContent >();
 184 }
 185
 186 bool DataSupplier::getResult( sal_uInt32 nIndex )
 187 {
 188     if ( maResults.size() > nIndex ) // Result already present.
 189         return true;
 190
 191     if ( getData() && maResults.size() > nIndex )
 192         return true;
 193
 194     return false;
 195 }
 196
 197 sal_uInt32 DataSupplier::totalCount()
 198 {
 199     getData();
 200     return maResults.size();
 201 }
 202
 203 sal_uInt32 DataSupplier::currentCount()
 204 {
 205     return maResults.size();
 206 }
 207
 208 bool DataSupplier::isCountFinal()
 209 {
 210     return mbCountFinal;
 211 }
 212
 213 uno::Reference< sdbc::XRow > DataSupplier::queryPropertyValues( sal_uInt32 nIndex  )
 214 {
 215     if ( nIndex < maResults.size() )
 216     {
 217         uno::Reference< sdbc::XRow > xRow = maResults[ nIndex ]->xRow;
 218         if ( xRow.is() )
 219         {
 220             // Already cached.
 221             return xRow;
 222         }
 223     }
 224
 225     if ( getResult( nIndex ) )
 226     {
 227         uno::Reference< ucb::XContent > xContent( queryContent( nIndex ) );
 228         if ( xContent.is() )
 229         {
 230             try
 231             {
 232                 uno::Reference< ucb::XCommandProcessor > xCmdProc(
 233                     xContent, uno::UNO_QUERY_THROW );
 234                 sal_Int32 nCmdId( xCmdProc->createCommandIdentifier() );
 235                 ucb::Command aCmd;
 236                 aCmd.Name = "getPropertyValues";
 237                 aCmd.Handle = -1;
 238                 aCmd.Argument <<= getResultSet()->getProperties();
 239                 uno::Any aResult( xCmdProc->execute(
 240                     aCmd, nCmdId, getResultSet()->getEnvironment() ) );
 241                 uno::Reference< sdbc::XRow > xRow;
 242                 if ( aResult >>= xRow )
 243                 {
 244                     maResults[ nIndex ]->xRow = xRow;
 245                     return xRow;
 246                 }
 247             }
 248             catch ( uno::Exception const & )
 249             {
 250             }
 251         }
 252     }
 253     return uno::Reference< sdbc::XRow >();
 254 }
 255
 256 void DataSupplier::releasePropertyValues( sal_uInt32 nIndex )
 257 {
 258     if ( nIndex < maResults.size() )
 259         maResults[ nIndex ]->xRow = uno::Reference< sdbc::XRow >();
 260 }
 261
 262 void DataSupplier::close()
 263 {
 264 }
 265
 266 void DataSupplier::validate() throw( ucb::ResultSetException )
 267 {
 268 }
 269
 270 }
 271
 272 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */