#2086 Handle extended file name chars on Linux for eclipse cases and summary cases

ApplicationCode/FileInterface/CMakeLists_files.cmake

@@ -40,6 +40,7 @@ ${CEE_CURRENT_LIST_DIR}RifCsvUserData.h
 ${CEE_CURRENT_LIST_DIR}RifCsvUserDataParser.h
 ${CEE_CURRENT_LIST_DIR}RifWellPathFormationReader.h
 ${CEE_CURRENT_LIST_DIR}RifWellPathFormationsImporter.h
+${CEE_CURRENT_LIST_DIR}RifStringTools.h
 # HDF5 file reader is directly included in ResInsight main CmakeList.txt
 #${CEE_CURRENT_LIST_DIR}RifHdf5Reader.h
 )
@@ -84,6 +85,7 @@ ${CEE_CURRENT_LIST_DIR}RifCsvUserData.cpp
 ${CEE_CURRENT_LIST_DIR}RifCsvUserDataParser.cpp
 ${CEE_CURRENT_LIST_DIR}RifWellPathFormationReader.cpp
 ${CEE_CURRENT_LIST_DIR}RifWellPathFormationsImporter.cpp
+${CEE_CURRENT_LIST_DIR}RifStringTools.cpp
 
 # HDF5 file reader is directly included in ResInsight main CmakeList.txt
 #${CEE_CURRENT_LIST_DIR}RifHdf5Reader.cpp

ApplicationCode/FileInterface/RifEclipseOutputFileTools.cpp

@@ -22,6 +22,7 @@
 
 #include "RifEclipseRestartFilesetAccess.h"
 #include "RifEclipseUnifiedRestartFileAccess.h"
+#include "RifStringTools.h"
 #include "RiaQDateTimeTools.h"
 
 #include "ert/ecl/ecl_file.h"
@@ -183,7 +184,7 @@ void RifEclipseOutputFileTools::timeSteps(ecl_file_type* ecl_file, std::vector<Q
 //--------------------------------------------------------------------------------------------------
 bool RifEclipseOutputFileTools::keywordData(ecl_file_type* ecl_file, const QString& keyword, size_t fileKeywordOccurrence, std::vector<double>* values)
 {
-    ecl_kw_type* kwData = ecl_file_iget_named_kw(ecl_file, keyword.toAscii().data(), static_cast<int>(fileKeywordOccurrence));
+    ecl_kw_type* kwData = ecl_file_iget_named_kw(ecl_file, RifStringTools::toNativeEncoded(keyword).data(), static_cast<int>(fileKeywordOccurrence));
     if (kwData)
     {
         size_t numValues = ecl_kw_get_size(kwData);
@@ -205,7 +206,7 @@ bool RifEclipseOutputFileTools::keywordData(ecl_file_type* ecl_file, const QStri
 //--------------------------------------------------------------------------------------------------
 bool RifEclipseOutputFileTools::keywordData(ecl_file_type* ecl_file, const QString& keyword, size_t fileKeywordOccurrence, std::vector<int>* values)
 {
-    ecl_kw_type* kwData = ecl_file_iget_named_kw(ecl_file, keyword.toAscii().data(), static_cast<int>(fileKeywordOccurrence));
+    ecl_kw_type* kwData = ecl_file_iget_named_kw(ecl_file, RifStringTools::toNativeEncoded(keyword).data(), static_cast<int>(fileKeywordOccurrence));
     if (kwData)
     {
         size_t numValues = ecl_kw_get_size(kwData);
@@ -232,7 +233,7 @@ QString RifEclipseOutputFileTools::firstFileNameOfType(const QStringList& fileSe
     {
         bool formatted = false;
         int reportNumber = -1;
-        if (ecl_util_get_file_type(fileSet.at(i).toAscii().data(), &formatted, &reportNumber) == fileType)
+        if (ecl_util_get_file_type(RifStringTools::toNativeEncoded(fileSet.at(i)).data(), &formatted, &reportNumber) == fileType)
         {
             return fileSet.at(i);
         }
@@ -253,7 +254,7 @@ QStringList RifEclipseOutputFileTools::filterFileNamesOfType(const QStringList&
     {
         bool formatted = false;
         int reportNumber = -1;
-        if (ecl_util_get_file_type(fileSet.at(i).toAscii().data(), &formatted, &reportNumber) == fileType)
+        if (ecl_util_get_file_type(RifStringTools::toNativeEncoded(fileSet.at(i)).data(), &formatted, &reportNumber) == fileType)
         {
             fileNames.append(fileSet.at(i));
         }
@@ -276,12 +277,12 @@ bool RifEclipseOutputFileTools::findSiblingFilesWithSameBaseName(const QString&
     QString fileNameBase = QFileInfo(fullPathFileName).baseName();
 
     stringlist_type* eclipseFiles = stringlist_alloc_new();
-    ecl_util_select_filelist(filePath.toAscii().data(), fileNameBase.toAscii().data(), ECL_OTHER_FILE, false, eclipseFiles);
+    ecl_util_select_filelist(RifStringTools::toNativeEncoded(filePath).data(), RifStringTools::toNativeEncoded(fileNameBase).data(), ECL_OTHER_FILE, false, eclipseFiles);
 
     int i;
     for (i = 0; i < stringlist_get_size(eclipseFiles); i++)
     {
-        baseNameFiles->append(stringlist_safe_iget(eclipseFiles, i));
+        baseNameFiles->append(RifStringTools::fromNativeEncoded(stringlist_safe_iget(eclipseFiles, i)));
     }
 
     stringlist_free(eclipseFiles);
@@ -294,7 +295,7 @@ bool RifEclipseOutputFileTools::findSiblingFilesWithSameBaseName(const QString&
 //--------------------------------------------------------------------------------------------------
 void RifEclipseOutputFileTools::readGridDimensions(const QString& gridFileName, std::vector< std::vector<int> >& gridDimensions)
 {
-    ecl_grid_type * grid         = ecl_grid_alloc(gridFileName.toAscii().data());                               // bootstrap ecl_grid instance
+    ecl_grid_type * grid         = ecl_grid_alloc(RifStringTools::toNativeEncoded(gridFileName).data());                               // bootstrap ecl_grid instance
     stringlist_type * lgr_names  = ecl_grid_alloc_lgr_name_list( grid );                                   // get a list of all the lgr names.
 
     //printf("grid:%s has %d a total of %d lgr's \n", grid_filename , stringlist_get_size( lgr_names ));

ApplicationCode/FileInterface/RifEclipseRestartFilesetAccess.cpp

@@ -20,6 +20,8 @@
 
 #include "RifEclipseRestartFilesetAccess.h"
 #include "RifEclipseOutputFileTools.h"
+#include "RifStringTools.h"
+
 #include "cafProgressInfo.h"
 
 #include "ert/ecl/ecl_file.h"
@@ -270,7 +272,7 @@ void RifEclipseRestartFilesetAccess::openTimeStep(size_t timeStep)
     if (m_ecl_files[timeStep] == NULL)
     {
         int index = static_cast<int>(timeStep);
-        ecl_file_type* ecl_file = ecl_file_open(m_fileNames[index].toAscii().data(), ECL_FILE_CLOSE_STREAM);
+        ecl_file_type* ecl_file = ecl_file_open(RifStringTools::toNativeEncoded(m_fileNames[index]).data(), ECL_FILE_CLOSE_STREAM);
 
         m_ecl_files[timeStep] = ecl_file;
 
@@ -295,7 +297,7 @@ int RifEclipseRestartFilesetAccess::reportNumber(const ecl_file_type* ecl_file)
     fileNameUpper = fileNameUpper.toUpper();
 
     // Convert to upper case, as ecl_util_filename_report_nr does not handle lower case file extensions
-    int reportNumber = ecl_util_filename_report_nr(fileNameUpper.toAscii().data());
+    int reportNumber = ecl_util_filename_report_nr(RifStringTools::toNativeEncoded(fileNameUpper).data());
 
     return reportNumber;
 }

ApplicationCode/FileInterface/RifEclipseSummaryTools.cpp

@@ -20,17 +20,21 @@
 
 #include "RiaSummaryCurveAnalyzer.h"
 #include "RifReaderEclipseSummary.h"
+#include "RifStringTools.h"
 
 #include "cafAppEnum.h"
 
 #include "ert/ecl/ecl_util.h"
 
+#include <QString>
+#include <QStringList>
+
 #include <iostream>
 
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RifEclipseSummaryTools::findSummaryHeaderFile(const std::string& inputFile, std::string* headerFile, bool* isFormatted)
+void RifEclipseSummaryTools::findSummaryHeaderFile(const QString& inputFile, QString* headerFile, bool* isFormatted)
 {
     findSummaryHeaderFileInfo(inputFile, headerFile, NULL, NULL, isFormatted);
 }
@@ -38,9 +42,9 @@ void RifEclipseSummaryTools::findSummaryHeaderFile(const std::string& inputFile,
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RifEclipseSummaryTools::findSummaryFiles(const std::string& inputFile, 
+void RifEclipseSummaryTools::findSummaryFiles(const QString& inputFile, 
-                                                   std::string* headerFile, 
+                                                   QString* headerFile, 
-                                                   std::vector<std::string>* dataFiles)
+                                                   QStringList* dataFiles)
 {
     dataFiles->clear();
     headerFile->clear();
@@ -49,21 +53,21 @@ void RifEclipseSummaryTools::findSummaryFiles(const std::string& inputFile,
     char* myBase = NULL;
     char* myExtention = NULL;
 
-    util_alloc_file_components(inputFile.data(), &myPath, &myBase, &myExtention);
+    util_alloc_file_components(RifStringTools::toNativeEncoded(inputFile).data(), &myPath, &myBase, &myExtention);
 
-    std::string path; if(myPath) path = myPath;
+    QString path; if(myPath) path = RifStringTools::fromNativeEncoded(myPath);
-    std::string base; if(myBase) base = myBase;
+    QString base; if(myBase) base = RifStringTools::fromNativeEncoded(myBase);
     std::string extention; if(myExtention) extention = myExtention;
 
-    if(path.empty() || base.empty()) return ;
+    if(path.isEmpty() || base.isEmpty()) return ;
 
     char* myHeaderFile = NULL;
     stringlist_type* summary_file_list = stringlist_alloc_new();
 
-    ecl_util_alloc_summary_files(path.data(), base.data(), extention.data(), &myHeaderFile, summary_file_list);
+    ecl_util_alloc_summary_files(RifStringTools::toNativeEncoded(path).data(), RifStringTools::toNativeEncoded(base).data(), extention.data(), &myHeaderFile, summary_file_list);
     if(myHeaderFile)
     {
-        (*headerFile) = myHeaderFile;
+        (*headerFile) = RifStringTools::fromNativeEncoded(myHeaderFile);
         util_safe_free(myHeaderFile);
     }
 
@@ -71,7 +75,7 @@ void RifEclipseSummaryTools::findSummaryFiles(const std::string& inputFile,
     {
         for(int i = 0; i < stringlist_get_size(summary_file_list); i++)
         {
-            dataFiles->push_back(stringlist_iget(summary_file_list,i));
+            dataFiles->push_back(RifStringTools::fromNativeEncoded(stringlist_iget(summary_file_list,i)));
         }
     }
     stringlist_free(summary_file_list);
@@ -83,12 +87,12 @@ void RifEclipseSummaryTools::findSummaryFiles(const std::string& inputFile,
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-bool RifEclipseSummaryTools::hasSummaryFiles(const std::string& gridFileName)
+bool RifEclipseSummaryTools::hasSummaryFiles(const QString& gridFileName)
 {
-    std::string headerFileName;
+    QString headerFileName;
-    std::vector<std::string> dataFileNames;
+    QStringList dataFileNames;
     RifEclipseSummaryTools::findSummaryFiles(gridFileName, &headerFileName, &dataFileNames);
-    if (!headerFileName.empty() && dataFileNames.size()) return true;
+    if (!headerFileName.isEmpty() && dataFileNames.size()) return true;
 
     return false;
 }
@@ -96,25 +100,25 @@ bool RifEclipseSummaryTools::hasSummaryFiles(const std::string& gridFileName)
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-std::vector<std::string> RifEclipseSummaryTools::findSummaryDataFiles(const std::string& caseFile)
+QStringList RifEclipseSummaryTools::findSummaryDataFiles(const QString& caseFile)
 {
-    std::vector<std::string> fileNames;
+    QStringList fileNames;
 
-    std::string path;
+    QString path;
-    std::string base;
+    QString base;
 
     findSummaryHeaderFileInfo(caseFile, NULL, &path, &base, NULL);
-    if (path.empty() || base.empty()) return fileNames;
+    if (path.isEmpty() || base.isEmpty()) return fileNames;
 
     char* header_file = NULL;
     stringlist_type* summary_file_list = stringlist_alloc_new();
 
-    ecl_util_alloc_summary_files(path.data(), base.data(), NULL, &header_file, summary_file_list);
+    ecl_util_alloc_summary_files(RifStringTools::toNativeEncoded(path).data(), RifStringTools::toNativeEncoded(base).data(), NULL, &header_file, summary_file_list);
     if (stringlist_get_size( summary_file_list ) > 0)
     {
         for (int i = 0; i < stringlist_get_size(summary_file_list); i++)
         {
-            fileNames.push_back(stringlist_iget(summary_file_list, i));
+            fileNames.push_back(RifStringTools::fromNativeEncoded(stringlist_iget(summary_file_list, i)));
         }
     }
 
@@ -163,13 +167,13 @@ void RifEclipseSummaryTools::dumpMetaData(RifSummaryReaderInterface* readerEclip
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RifEclipseSummaryTools::findSummaryHeaderFileInfo(const std::string& inputFile, std::string* headerFile, std::string* path, std::string* base, bool* isFormatted)
+void RifEclipseSummaryTools::findSummaryHeaderFileInfo(const QString& inputFile, QString* headerFile, QString* path, QString* base, bool* isFormatted)
 {
     char* myPath = NULL;
     char* myBase = NULL;
     bool formattedFile = true;
 
-    util_alloc_file_components(inputFile.data(), &myPath, &myBase, NULL);
+    util_alloc_file_components(RifStringTools::toNativeEncoded(inputFile).data(), &myPath, &myBase, NULL);
 
     char* myHeaderFile = ecl_util_alloc_exfilename(myPath, myBase, ECL_SUMMARY_HEADER_FILE, true, -1);
     if (!myHeaderFile)

ApplicationCode/FileInterface/RifEclipseSummaryTools.h

@@ -24,6 +24,8 @@
 #include <vector>
 
 class RifSummaryReaderInterface;
+class QStringList;
+class QString;
 
 //==================================================================================================
 //
@@ -33,13 +35,13 @@ class RifSummaryReaderInterface;
 class RifEclipseSummaryTools
 {
 public:
-    static void                     findSummaryHeaderFile(const std::string& inputFile, std::string* headerFile, bool* isFormatted);
+    static void                     findSummaryHeaderFile(const QString& inputFile, QString* headerFile, bool* isFormatted);
-    static std::vector<std::string> findSummaryDataFiles(const std::string& caseFile);
+    static QStringList              findSummaryDataFiles(const QString& caseFile);
 
-    static void                     findSummaryFiles(const std::string& inputFile, std::string* headerFile, std::vector<std::string>* dataFiles);
+    static void                     findSummaryFiles(const QString& inputFile, QString* headerFile, QStringList* dataFiles);
-    static bool                     hasSummaryFiles(const std::string& gridFileName);
+    static bool                     hasSummaryFiles(const QString& gridFileName);
     static void                     dumpMetaData(RifSummaryReaderInterface* readerEclipseSummary);
 
 private:
-    static void                     findSummaryHeaderFileInfo(const std::string& inputFile, std::string* headerFile, std::string* path, std::string* base, bool* isFormatted);
+    static void                     findSummaryHeaderFileInfo(const QString& inputFile, QString* headerFile, QString* path, QString* base, bool* isFormatted);
 };

ApplicationCode/FileInterface/RifEclipseUnifiedRestartFileAccess.cpp

@@ -26,6 +26,7 @@
 
 #include "RifEclipseOutputFileTools.h"
 #include "RifReaderSettings.h"
+#include "RifStringTools.h"
 
 #include "ert/ecl/ecl_file.h"
 #include "ert/ecl/ecl_kw_magic.h"
@@ -83,7 +84,7 @@ bool RifEclipseUnifiedRestartFileAccess::openFile()
 
                 if (resultFileInfo.lastModified() < indexFileInfo.lastModified())
                 {
-                    m_ecl_file = ecl_file_fast_open(m_filename.toAscii().data(), indexFileName.toAscii().data(), ECL_FILE_CLOSE_STREAM);
+                    m_ecl_file = ecl_file_fast_open(RifStringTools::toNativeEncoded(m_filename).data(), RifStringTools::toNativeEncoded(indexFileName).data(), ECL_FILE_CLOSE_STREAM);
                     if (!m_ecl_file)
                     {
                         RiaLogging::error(QString("Failed to open file %1 using index file.").arg(m_filename));
@@ -99,7 +100,7 @@ bool RifEclipseUnifiedRestartFileAccess::openFile()
 
         if (!m_ecl_file)
         {
-            m_ecl_file = ecl_file_open(m_filename.toAscii().data(), ECL_FILE_CLOSE_STREAM);
+            m_ecl_file = ecl_file_open(RifStringTools::toNativeEncoded(m_filename).data(), ECL_FILE_CLOSE_STREAM);
             if (!m_ecl_file)
             {
                 RiaLogging::error(QString("Failed to open file %1").arg(m_filename));
@@ -112,7 +113,7 @@ bool RifEclipseUnifiedRestartFileAccess::openFile()
                     QString resultPath = fi.absolutePath();
                     if (caf::Utils::isFolderWritable(resultPath))
                     {
-                        bool success = ecl_file_write_index(m_ecl_file, indexFileName.toAscii().data());
+                        bool success = ecl_file_write_index(m_ecl_file, RifStringTools::toNativeEncoded(indexFileName).data());
 
                         if (success)
                         {

ApplicationCode/FileInterface/RifReaderEclipseOutput.cpp

@@ -28,6 +28,7 @@
 #include "RifEclipseOutputFileTools.h"
 #include "RifHdf5ReaderInterface.h"
 #include "RifReaderSettings.h"
+#include "RifStringTools.h"
 
 #ifdef USE_HDF5
 #include "RifHdf5Reader.h"
@@ -374,7 +375,7 @@ bool RifReaderEclipseOutput::open(const QString& fileName, RigEclipseCaseData* e
 
     // Read geometry
     // Todo: Needs to check existence of file before calling ert, else it will abort
-    ecl_grid_type * mainEclGrid = ecl_grid_alloc( fileName.toAscii().data() );
+    ecl_grid_type * mainEclGrid = ecl_grid_alloc( RifStringTools::toNativeEncoded(fileName).data() );
 
     progInfo.incrementProgress();
 
@@ -722,7 +723,7 @@ bool RifReaderEclipseOutput::readActiveCellInfo()
     QString egridFileName = RifEclipseOutputFileTools::firstFileNameOfType(m_filesWithSameBaseName, ECL_EGRID_FILE);
     if (egridFileName.size() > 0)
     {
-        ecl_file_type* ecl_file = ecl_file_open(egridFileName.toAscii().data(), ECL_FILE_CLOSE_STREAM);
+        ecl_file_type* ecl_file = ecl_file_open(RifStringTools::toNativeEncoded(egridFileName).data(), ECL_FILE_CLOSE_STREAM);
         if (!ecl_file) return false;
 
         int actnumKeywordCount = ecl_file_get_num_named_kw(ecl_file, ACTNUM_KW);
@@ -2213,7 +2214,7 @@ void RifReaderEclipseOutput::openInitFile()
     QString initFileName = RifEclipseOutputFileTools::firstFileNameOfType(m_filesWithSameBaseName, ECL_INIT_FILE);
     if (initFileName.size() > 0)
     {
-        m_ecl_init_file = ecl_file_open(initFileName.toAscii().data(), ECL_FILE_CLOSE_STREAM);
+        m_ecl_init_file = ecl_file_open(RifStringTools::toNativeEncoded(initFileName).data(), ECL_FILE_CLOSE_STREAM);
     }
 }
 

ApplicationCode/FileInterface/RifReaderEclipseRft.cpp

@@ -21,6 +21,8 @@
 #include "RiaLogging.h"
 #include "RiaQDateTimeTools.h"
 
+#include "RifStringTools.h"
+
 #include "cafVecIjk.h"
 
 #include "ert/ecl/ecl_rft_file.h"
@@ -28,7 +30,7 @@
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-RifReaderEclipseRft::RifReaderEclipseRft(const std::string& fileName):
+RifReaderEclipseRft::RifReaderEclipseRft(const QString& fileName):
     m_fileName(fileName), m_ecl_rft_file(nullptr)
 {
 }
@@ -45,15 +47,15 @@ RifReaderEclipseRft::~RifReaderEclipseRft()
 //--------------------------------------------------------------------------------------------------
 void RifReaderEclipseRft::open()
 {
-    if (m_fileName.empty()) return;
+    if (m_fileName.isEmpty()) return;
 
-    RiaLogging::info(QString("Opening file '%1'").arg(m_fileName.c_str()));
+    RiaLogging::info(QString("Opening file '%1'").arg( m_fileName));
 
-    m_ecl_rft_file = ecl_rft_file_alloc_case(m_fileName.data());
+    m_ecl_rft_file = ecl_rft_file_alloc_case(RifStringTools::toNativeEncoded(m_fileName).data());
 
     if (m_ecl_rft_file == NULL)
     {
-        RiaLogging::warning(QString("Libecl could not find/open file '%'").arg(m_fileName.c_str()));
+        RiaLogging::warning(QString("Libecl could not find/open file '%'").arg( m_fileName));
         return;
     }
 

ApplicationCode/FileInterface/RifReaderEclipseRft.h

@@ -41,7 +41,7 @@ namespace caf
 class RifReaderEclipseRft : public cvf::Object
 {
 public:
-    RifReaderEclipseRft(const std::string& fileName);
+    RifReaderEclipseRft(const QString& fileName);
     ~RifReaderEclipseRft();
 
     const std::vector<RifEclipseRftAddress>&                    eclipseRftAddresses();
@@ -63,7 +63,7 @@ private:
     // Taken from ecl_rft_file.h and ecl_rft_node.h
     typedef struct ecl_rft_file_struct ecl_rft_file_type;
 
-    std::string                         m_fileName;
+    QString                             m_fileName;
     ecl_rft_file_type*                  m_ecl_rft_file;
     std::vector<RifEclipseRftAddress>   m_eclipseRftAddresses;
     std::set<QString>                   m_wellNames;

ApplicationCode/FileInterface/RifReaderEclipseSummary.cpp

@@ -17,6 +17,7 @@
 /////////////////////////////////////////////////////////////////////////////////
 
 #include "RifReaderEclipseSummary.h"
+#include "RifStringTools.h"
 
 #include "ert/ecl/ecl_sum.h"
 
@@ -24,6 +25,8 @@
 #include <assert.h>
 
 #include <QDateTime>
+#include <QString>
+#include <QStringList>
 #include "ert/ecl/smspec_node.h"
 
 //--------------------------------------------------------------------------------------------------
@@ -51,23 +54,23 @@ RifReaderEclipseSummary::~RifReaderEclipseSummary()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-bool RifReaderEclipseSummary::open(const std::string& headerFileName, const std::vector<std::string>& dataFileNames)
+bool RifReaderEclipseSummary::open(const QString& headerFileName, const QStringList& dataFileNames)
 {
     assert(m_ecl_sum == NULL); 
     
-    if (headerFileName.empty() || dataFileNames.size() == 0) return false;
+    if (headerFileName.isEmpty() || dataFileNames.size() == 0) return false;
 
-    assert(!headerFileName.empty());
+    assert(!headerFileName.isEmpty());
     assert(dataFileNames.size() > 0);
 
     stringlist_type* dataFiles = stringlist_alloc_new();
-    for (size_t i = 0; i < dataFileNames.size(); i++)
+    for (int i = 0; i < dataFileNames.size(); i++)
     {
-        stringlist_append_copy(dataFiles, dataFileNames[i].data());
+        stringlist_append_copy(dataFiles, RifStringTools::toNativeEncoded(dataFileNames[i]).data());
     }
 
     std::string itemSeparatorInVariableNames = ":";
-    m_ecl_sum = ecl_sum_fread_alloc(headerFileName.data(), dataFiles, itemSeparatorInVariableNames.data(), false);
+    m_ecl_sum = ecl_sum_fread_alloc(RifStringTools::toNativeEncoded(headerFileName).data(), dataFiles, itemSeparatorInVariableNames.data(), false);
 
     stringlist_free(dataFiles);
 

ApplicationCode/FileInterface/RifReaderEclipseSummary.h

@@ -25,6 +25,8 @@
 #include <vector>
 #include <map>
 
+class QString;
+class QStringList;
 
 //==================================================================================================
 //
@@ -36,7 +38,7 @@ public:
     RifReaderEclipseSummary();
     ~RifReaderEclipseSummary();
 
-    bool                                open(const std::string& headerFileName, const std::vector<std::string>& dataFileNames);
+    bool                                open(const QString& headerFileName, const QStringList& dataFileNames);
 
     virtual const std::vector<time_t>&  timeSteps(const RifEclipseSummaryAddress& resultAddress) const override;
 

ApplicationCode/FileInterface/RifStringTools.cpp

@@ -0,0 +1,43 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2011-     Statoil ASA
+//  Copyright (C) 2013-     Ceetron Solutions AS
+//  Copyright (C) 2011-2012 Ceetron AS
+// 
+//  ResInsight is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+// 
+//  ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
+//  WARRANTY; without even the implied warranty of MERCHANTABILITY or
+//  FITNESS FOR A PARTICULAR PURPOSE.
+// 
+//  See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html> 
+//  for more details.
+//
+/////////////////////////////////////////////////////////////////////////////////
+
+#include "RifStringTools.h"
+
+
+const std::string RifStringTools::toNativeEncoded(const QString& qstring)
+{
+#ifdef WIN32
+    return std::string(qstring.toLatin1().data());
+#else
+    return std::string(qstring.toUtf8().data());
+#endif
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+const QString RifStringTools::fromNativeEncoded(const char* native)
+{
+#ifdef WIN32
+    return QString::fromLatin1(native);
+#else
+    return QString::fromUtf8(native);
+#endif
+}

ApplicationCode/FileInterface/RifStringTools.h

@@ -0,0 +1,38 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2011-     Statoil ASA
+//  Copyright (C) 2013-     Ceetron Solutions AS
+//  Copyright (C) 2011-2012 Ceetron AS
+// 
+//  ResInsight is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+// 
+//  ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
+//  WARRANTY; without even the implied warranty of MERCHANTABILITY or
+//  FITNESS FOR A PARTICULAR PURPOSE.
+// 
+//  See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html> 
+//  for more details.
+//
+/////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include <QString>
+#include <QByteArray>
+#include <string>
+
+//==================================================================================================
+//
+// 
+//
+//==================================================================================================
+class RifStringTools
+{
+public:
+    static const std::string    toNativeEncoded(const QString& qstring);
+
+    static const QString        fromNativeEncoded(const char* native);
+};

ApplicationCode/ProjectDataModel/RimEclipseResultCase.cpp

@@ -208,7 +208,7 @@ bool RimEclipseResultCase::importGridAndResultMetaData(bool showTimeStepFilter)
     if (rftFileInfo.exists())
     {
         RiaLogging::info(QString("RFT file found"));
-        m_readerEclipseRft = new RifReaderEclipseRft(rftFileInfo.filePath().toStdString());
+        m_readerEclipseRft = new RifReaderEclipseRft(rftFileInfo.filePath());
     }
 
 

ApplicationCode/ProjectDataModel/Summary/RimFileSummaryCase.cpp

@@ -91,9 +91,9 @@ void RimFileSummaryCase::createSummaryReaderInterface()
 //--------------------------------------------------------------------------------------------------
 RifReaderEclipseSummary* RimFileSummaryCase::findRelatedFilesAndCreateReader(const QString& headerFileName)
 {
-    std::string headerFileNameStd;
+    QString headerFileNameStd;
-    std::vector<std::string> dataFileNames;
+    QStringList dataFileNames;
-    std::string nativeSumHeadFileName = QDir::toNativeSeparators(headerFileName).toStdString();
+    QString nativeSumHeadFileName = QDir::toNativeSeparators(headerFileName);
     RifEclipseSummaryTools::findSummaryFiles(nativeSumHeadFileName, &headerFileNameStd, &dataFileNames);
 
     RifReaderEclipseSummary* summaryFileReader = new RifReaderEclipseSummary;

ApplicationCode/ProjectDataModel/Summary/RimSummaryCaseMainCollection.cpp

@@ -267,7 +267,7 @@ void RimSummaryCaseMainCollection::loadAllSummaryCaseData()
 RimSummaryCase* RimSummaryCaseMainCollection::createAndAddSummaryCaseFromEclipseResultCase(RimEclipseResultCase* eclResCase)
 {
     QString gridFileName = eclResCase->gridFileName();
-    if(RifEclipseSummaryTools::hasSummaryFiles(QDir::toNativeSeparators(gridFileName).toStdString()))
+    if(RifEclipseSummaryTools::hasSummaryFiles(QDir::toNativeSeparators(gridFileName)))
     {
         RimGridSummaryCase* newSumCase = new RimGridSummaryCase();
         this->m_cases.push_back(newSumCase);