api_core.cpp

Go to the documentation of this file.

//                                                       //
//                         SAGA                          //
//                                                       //
//      System for Automated Geoscientific Analyses      //
//                                                       //
//           Application Programming Interface           //
//                                                       //
//                  Library: SAGA_API                    //
//                                                       //
//-------------------------------------------------------//
//                                                       //
//                     api_core.cpp                      //
//                                                       //
//          Copyright (C) 2005 by Olaf Conrad            //
//                                                       //
//-------------------------------------------------------//
//                                                       //
// This file is part of 'SAGA - System for Automated     //
// Geoscientific Analyses'.                              //
//                                                       //
// This library is free software; you can redistribute   //
// it and/or modify it under the terms of the GNU Lesser //
// General Public License as published by the Free       //
// Software Foundation, either version 2.1 of the        //
// License, or (at your option) any later version.       //
//                                                       //
// This library 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 Lesser General Public //
// License for more details.                             //
//                                                       //
// You should have received a copy of the GNU Lesser     //
// General Public License along with this program; if    //
// not, see <http://www.gnu.org/licenses/>.              //
//                                                       //
//-------------------------------------------------------//
//                                                       //
//    contact:    Olaf Conrad                            //
//                Institute of Geography                 //
//                University of Hamburg                  //
//                Germany                                //
//                                                       //
//    e-mail:     oconrad@saga-gis.org                   //
//                                                       //
 
//---------------------------------------------------------
#include <wx/utils.h>
#include <wx/app.h>
#include <wx/dir.h>
#include <wx/stdpaths.h>
#include <wx/html/winpars.h>
 
#include "api_core.h"
#include "tool_library.h"
 

//                                                       //
//                                                       //
//                                                       //
 
//---------------------------------------------------------
#ifdef _OPENMP
 
#include <omp.h>
 
//---------------------------------------------------------
int             g_SG_OMP_Max_Num_Threads        = omp_get_num_procs();
 
//---------------------------------------------------------
void    SG_OMP_Set_Max_Num_Threads    (int iCores)
{
        if( iCores < 1 )
        {
                iCores  = 1;
        }
        else if( iCores > omp_get_num_procs() )
        {
                iCores  = omp_get_num_procs();
        }
 
        omp_set_num_threads(g_SG_OMP_Max_Num_Threads = iCores);
}
 
//---------------------------------------------------------
int             SG_OMP_Get_Max_Num_Threads    (void)
{
        return( g_SG_OMP_Max_Num_Threads );
}
 
//---------------------------------------------------------
int             SG_OMP_Get_Max_Num_Procs        (void)
{
        return( omp_get_num_procs() );
}
 
//---------------------------------------------------------
int             SG_OMP_Get_Thread_Num              (void)
{
        return( omp_get_thread_num() );
}
 
//---------------------------------------------------------
#else
void    SG_OMP_Set_Max_Num_Threads    (int iCores)    {}
int             SG_OMP_Get_Max_Num_Threads    (void)  {       return( 1 );    }
int             SG_OMP_Get_Max_Num_Procs        (void)  {       return( 1 );    }
int             SG_OMP_Get_Thread_Num              (void)  {       return( 0 );    }
#endif
 

//                                                       //
//                                                       //
//                                                       //
 
//---------------------------------------------------------
CSG_String    SG_Data_Type_Get_Name      (TSG_Data_Type Type, bool bShort)
{
        switch( Type )
        {
        case SG_DATATYPE_Bit   : return(          _TL("bit"   ) );
        case SG_DATATYPE_Byte  : return( bShort ? _TL("uint8" ) : _TL("unsigned 1 byte integer"     ) );
        case SG_DATATYPE_Char  : return( bShort ? _TL("int8"  ) : _TL("signed 1 byte integer"       ) );
        case SG_DATATYPE_Word  : return( bShort ? _TL("uint16") : _TL("unsigned 2 byte integer"     ) );
        case SG_DATATYPE_Short : return( bShort ? _TL("int16" ) : _TL("signed 2 byte integer"       ) );
        case SG_DATATYPE_DWord : return( bShort ? _TL("uint32") : _TL("unsigned 4 byte integer"     ) );
        case SG_DATATYPE_Int   : return( bShort ? _TL("int32" ) : _TL("signed 4 byte integer"       ) );
        case SG_DATATYPE_ULong : return( bShort ? _TL("uint64") : _TL("unsigned 8 byte integer"     ) );
        case SG_DATATYPE_Long  : return( bShort ? _TL("int64" ) : _TL("signed 8 byte integer"       ) );
        case SG_DATATYPE_Float : return( bShort ? _TL("float" ) : _TL("4 byte floating point number") );
        case SG_DATATYPE_Double: return( bShort ? _TL("double") : _TL("8 byte floating point number") );
        case SG_DATATYPE_String: return(          _TL("string") );
        case SG_DATATYPE_Date  : return(          _TL("date"  ) );
        case SG_DATATYPE_Color : return(          _TL("color" ) );
        case SG_DATATYPE_Binary: return(          _TL("binary") );
        default                : return( bShort ? _TL("none"  ) : _TL("undefined"                   ) );
        }
};
 
//---------------------------------------------------------
CSG_String    SG_Data_Type_Get_Identifier  (TSG_Data_Type Type)
{
        return( gSG_Data_Type_Identifier[Type] );
}
 
//---------------------------------------------------------
TSG_Data_Type SG_Data_Type_Get_Type(const CSG_String &Identifier)
{
        if( !Identifier.Cmp(gSG_Data_Type_Identifier[SG_DATATYPE_Bit   ]) )   return( SG_DATATYPE_Bit    );
        if( !Identifier.Cmp(gSG_Data_Type_Identifier[SG_DATATYPE_Byte  ]) )  return( SG_DATATYPE_Byte   );
        if( !Identifier.Cmp(gSG_Data_Type_Identifier[SG_DATATYPE_Char  ]) )  return( SG_DATATYPE_Char   );
        if( !Identifier.Cmp(gSG_Data_Type_Identifier[SG_DATATYPE_Word  ]) )  return( SG_DATATYPE_Word   );
        if( !Identifier.Cmp(gSG_Data_Type_Identifier[SG_DATATYPE_Short ]) ) return( SG_DATATYPE_Short  );
        if( !Identifier.Cmp(gSG_Data_Type_Identifier[SG_DATATYPE_DWord ]) ) return( SG_DATATYPE_DWord  );
        if( !Identifier.Cmp(gSG_Data_Type_Identifier[SG_DATATYPE_Int   ]) )   return( SG_DATATYPE_Int    );
        if( !Identifier.Cmp(gSG_Data_Type_Identifier[SG_DATATYPE_ULong ]) ) return( SG_DATATYPE_ULong  );
        if( !Identifier.Cmp(gSG_Data_Type_Identifier[SG_DATATYPE_Long  ]) )  return( SG_DATATYPE_Long   );
        if( !Identifier.Cmp(gSG_Data_Type_Identifier[SG_DATATYPE_Float ]) ) return( SG_DATATYPE_Float  );
        if( !Identifier.Cmp(gSG_Data_Type_Identifier[SG_DATATYPE_Double]) )        return( SG_DATATYPE_Double );
        if( !Identifier.Cmp(gSG_Data_Type_Identifier[SG_DATATYPE_String]) )        return( SG_DATATYPE_String );
        if( !Identifier.Cmp(gSG_Data_Type_Identifier[SG_DATATYPE_Date  ]) )  return( SG_DATATYPE_Date   );
        if( !Identifier.Cmp(gSG_Data_Type_Identifier[SG_DATATYPE_Color ]) ) return( SG_DATATYPE_Color  );
 
        return( SG_DATATYPE_Undefined );
}
 
//---------------------------------------------------------
int     SG_Data_Type_Get_Flag(TSG_Data_Type Type)
{
        switch( Type )
        {
        case SG_DATATYPE_Bit   : return( SG_DATATYPES_Bit       );
        case SG_DATATYPE_Byte  : return( SG_DATATYPES_Byte      );
        case SG_DATATYPE_Char  : return( SG_DATATYPES_Char      );
        case SG_DATATYPE_Word  : return( SG_DATATYPES_Word      );
        case SG_DATATYPE_Short : return( SG_DATATYPES_Short     );
        case SG_DATATYPE_DWord : return( SG_DATATYPES_DWord     );
        case SG_DATATYPE_Int   : return( SG_DATATYPES_Int       );
        case SG_DATATYPE_ULong : return( SG_DATATYPES_ULong     );
        case SG_DATATYPE_Long  : return( SG_DATATYPES_Long      );
        case SG_DATATYPE_Float : return( SG_DATATYPES_Float     );
        case SG_DATATYPE_Double: return( SG_DATATYPES_Double    );
        case SG_DATATYPE_String: return( SG_DATATYPES_String    );
        case SG_DATATYPE_Date  : return( SG_DATATYPES_Date      );
        case SG_DATATYPE_Color : return( SG_DATATYPES_Color     );
        case SG_DATATYPE_Binary: return( SG_DATATYPES_Binary    );
        default                : return( SG_DATATYPES_Undefined );
        }
};
 
//---------------------------------------------------------
bool SG_Data_Type_is_Numeric(TSG_Data_Type Type)
{
        switch( Type )
        {
        case SG_DATATYPE_Bit   :
        case SG_DATATYPE_Byte  :
        case SG_DATATYPE_Char  :
        case SG_DATATYPE_Word  :
        case SG_DATATYPE_Short :
        case SG_DATATYPE_DWord :
        case SG_DATATYPE_Int   :
        case SG_DATATYPE_ULong :
        case SG_DATATYPE_Long  :
        case SG_DATATYPE_Float :
        case SG_DATATYPE_Double:
                return( true );
 
        case SG_DATATYPE_String:
        case SG_DATATYPE_Date  :
        case SG_DATATYPE_Color :
        case SG_DATATYPE_Binary: default:
                return( false );
        }
}
 
//---------------------------------------------------------
bool SG_Data_Type_Range_Check(TSG_Data_Type Type, double &Value)
{
        double  min, max;
 
        switch( Type )
        {
                default:
                case SG_DATATYPE_Double: Value = (double)Value; return( true );
                case SG_DATATYPE_Float : Value = (float )Value; return( true );
 
                case SG_DATATYPE_Bit   : min =           0.; max =          1.; break;
                case SG_DATATYPE_Byte  : min =           0.; max =        255.; break;
                case SG_DATATYPE_Char  : min =        -128.; max =        127.; break;
                case SG_DATATYPE_Word  : min =           0.; max =      65535.; break;
                case SG_DATATYPE_Short : min =      -32768.; max =      32767.; break;
                case SG_DATATYPE_DWord : min =           0.; max = 4294967295.; break;
                case SG_DATATYPE_Int   : min = -2147483648.; max = 2147483647.; break;
        }
 
        if( Value < min )
        {
                Value   = min;
        }
        else if( Value > max )
        {
                Value   = max;
        }
 
        return( true );
}
 

//                                                       //
//                     Environment                       //
//                                                       //
 
//---------------------------------------------------------
#if defined(_SAGA_MSW)
bool SG_Environment_Add_Dll_Paths(const CSG_String &Directory);
#endif
 
//---------------------------------------------------------
static struct SSG_Environment
{
        bool wxInitialized = false;
 
        wxApp *pApp = NULL;
 
        wxHtmlTagsModule *pHtmlTags = NULL;
 
        CSG_String App_FullPath, App_Path, App_Name, API_Path;
 
        CSG_MetaData Options;
}
theEnvironment;
 

//                                                       //
 
//---------------------------------------------------------
bool CSG_Environment::Initialize(bool bInitializeWX, bool bInitializeGUI, bool bProjections, bool bLibraries, const SG_Char *SAGA_Path)
{
        static bool bInitialized = false;
 
        if( bInitialized )
        {
                #ifdef _DEBUG
                SG_UI_Console_Print_StdOut("\n!!! WARNING - Environment has already been initialized (=> saga_api/api_core.cpp) !!!");
                #endif
 
                return( false );
        }
 
        bInitialized = true;
 
        //-----------------------------------------------------
        #ifdef _DEBUG
        SG_UI_Console_Print_StdOut("\n!!! Loading SAGA API => DEBUG !!!");
        #endif
 
        //-----------------------------------------------------
        if( bInitializeGUI )
        {
                theEnvironment.pApp      = new wxApp();
 
                theEnvironment.pHtmlTags = new wxHtmlTagsModule();
        }
 
        if( bInitializeWX && theEnvironment.wxInitialized == false )
        {
                theEnvironment.wxInitialized = wxInitialize();
 
                if( theEnvironment.wxInitialized == false )
                {
                        SG_UI_Console_Print_StdErr("\nFailed to run wxInitialize()!");
                }
        }
 
        //-----------------------------------------------------
        /* workaround: wxwidgets 2.9.3 is complaining about setlocale
        * mismatch between c setlocale and wxLocale. since saga has its own
        * translation system, we use english as default. this assures
        * using . as decimal separator in printf like formatting of
        * floating point values. wxXLocale is currently not fully
        * implemented (wxPrintf_l and similar still missing).
        */
 
        wxLocale Locale; Locale.Init(wxLANGUAGE_ENGLISH);
 
        setlocale(LC_NUMERIC, "C");
 
        //-----------------------------------------------------
        SG_UI_ProgressAndMsg_Lock(true);
 
        //-----------------------------------------------------
        #if defined(_SAGA_MSW)
        {
                SetDefaultDllDirectories(
                        LOAD_LIBRARY_SEARCH_APPLICATION_DIR |
                        LOAD_LIBRARY_SEARCH_USER_DIRS |
                        LOAD_LIBRARY_SEARCH_SYSTEM32
                );
 
                CSG_String API_Path;
 
                if( SAGA_Path && SG_Dir_Exists(SAGA_Path) )
                {
                        API_Path = SAGA_Path;
                }
                else
                {
                        API_Path = Get_Application_Path(true).c_str();
                }
 
                Set_API_Path(API_Path);
 
                if( !AddDllDirectory(API_Path.c_str()) )
                {
                        SG_UI_Console_Print_StdErr(CSG_String::Format("Failed to add application directory to path environment!\n> %s\n", API_Path.c_str()));
 
                        return( false );
                }
 
                SG_Environment_Add_Dll_Paths(SG_File_Make_Path(API_Path, "dll"));
        }
 
        //-----------------------------------------------------
        #elif defined(__WXMAC__)
        {
                CSG_String Path(CSG_Environment::Get_Share_Path());
 
                if( SG_Dir_Exists(Path + "/proj-data"   ) ) { Set_Option("PROJ_LIB"        , Path + "/proj-data"   ); } // AppBundle
                if( SG_Dir_Exists(Path + "/gdal-data"   ) ) { Set_Option("GDAL_DATA"       , Path + "/gdal-data"   ); } // AppBundle
                if( SG_Dir_Exists(Path + "/gdal-plugins") ) { Set_Option("GDAL_DRIVER_PATH", Path + "/gdal-plugins"); } // AppBundle
 
                if( SG_File_Exists(Path + "/curl-ca-bundle.crt") ) { Set_Variable("CURL_CA_BUNDLE", Path + "/curl-ca-bundle.crt"); } // AppBundle
        }
 
        //-----------------------------------------------------
        #else // #if defined(_SAGA_LINUX)
        {
                #if defined(__WXGTK__)
                        #if !defined(_DEBUG)
                                wxApp::GTKSuppressDiagnostics();
                        #endif
 
                        wxApp::GTKAllowDiagnosticsControl(); // allow wxWidgets to suppress some spurious GTK error messages
                #endif
        }
        #endif
 
        //-----------------------------------------------------
        SG_Get_Projections().Create(bProjections);
 
        if( bLibraries )
        {
                SG_Get_Tool_Library_Manager().Add_Default_Libraries();
        }
 
        //-----------------------------------------------------
        SG_UI_ProgressAndMsg_Lock(false);
 
        return( true );
}
 
//---------------------------------------------------------
bool CSG_Environment::Uninitialize(void)
{
        if( theEnvironment.wxInitialized )
        {
                wxUninitialize();
 
                theEnvironment.wxInitialized = false;
        }
 
        return( true );
}
 

//                                                       //
 
//---------------------------------------------------------
const CSG_String & CSG_Environment::Get_Application_Path(bool bPathOnly)
{
        if( theEnvironment.App_FullPath.is_Empty() )
        {
                theEnvironment.App_FullPath = wxStandardPaths::Get().GetExecutablePath().wx_str();
 
                SG_File_Get_Path_Absolute(theEnvironment.App_FullPath);
 
                theEnvironment.App_Path = SG_File_Get_Path(theEnvironment.App_FullPath);
        }
 
        return( bPathOnly ? theEnvironment.App_Path : theEnvironment.App_FullPath );
}
 
//---------------------------------------------------------
const CSG_String & CSG_Environment::Get_Application_Name(void)
{
        if( theEnvironment.App_Name.is_Empty() )
        {
                theEnvironment.App_Name = SG_File_Get_Name(Get_Application_Path(false), false);
        }
 
        return( theEnvironment.App_Name );
}
 
//---------------------------------------------------------
bool CSG_Environment::Set_Application_Name(const CSG_String &Name)
{
        theEnvironment.App_Name = Name;
 
        return( true );
}
 
//---------------------------------------------------------
bool CSG_Environment::Set_API_Path(const CSG_String &Path)
{
        if( SG_Dir_Exists(Path) )
        {
                theEnvironment.API_Path = Path;
 
                return( true );
        }
 
        return( false );
}
 
//---------------------------------------------------------
const CSG_String & CSG_Environment::Get_API_Path(void)
{
        if( theEnvironment.API_Path.is_Empty() && theEnvironment.App_Name.Find("saga") == 0 )
        {
                theEnvironment.API_Path = Get_Application_Path(true);
        }
 
        return( theEnvironment.API_Path );
}
 
//---------------------------------------------------------
CSG_String CSG_Environment::Get_Share_Path(const CSG_String &AddPath)
{
        CSG_String Path;
 
        #if defined(_SAGA_MSW)
        {
                Path = Get_Application_Path(true);
        }
        #elif defined(__WXMAC__)
        {
                Path = Get_Application_Path(true);
 
                if( Path.Find("SAGA.app/Contents/MacOS") > 0 ) // AppBundle
                {
                        Path = Path.Left(Path.Find("SAGA.app/Contents/MacOS")) + "SAGA.app/Contents/Share";
                }
                else
                {
                        Path.Clear();
 
                        #ifdef SHARE_PATH
                                Path = SHARE_PATH;
                        #endif
                }
        }
        #else // defined(_SAGA_LINUX)
        {
                #ifdef SHARE_PATH
                        Path = SHARE_PATH;
                #endif
        }
        #endif
 
        return( SG_File_Make_Path(Path, AddPath) );
}
 
//---------------------------------------------------------
CSG_String CSG_Environment::Get_Ressources_Path(const CSG_String &AddPath)
{
        CSG_String Path(Get_Share_Path());
 
        #if defined(_SAGA_MSW)
        {
                Path = SG_File_Make_Path(Path, "resources");
        }
        #endif
 
        return( SG_File_Make_Path(Path, AddPath) );
}
 
//---------------------------------------------------------
CSG_Strings CSG_Environment::Get_Tool_Paths(void)
{
        CSG_Strings Paths;
 
        #if defined(_SAGA_MSW)
        {
                Paths += SG_File_Make_Path(CSG_Environment::Get_API_Path(), "tools");
        }
        #elif defined(__WXMAC__)
        {
                CSG_String Path = Get_Application_Path(true);
 
                if( Path.Find("SAGA.app/Contents/MacOS") > 0 ) // AppBundle
                {
                        Path = Path.Left(Path.Find("SAGA.app/Contents/MacOS")) + "SAGA.app/Contents";
 
                        Paths += Path + "/Tools";
                        Paths += Path + "/Share/toolchains";
                }
                else
                {
                        #ifdef TOOLS_PATH
                                Paths += TOOLS_PATH;
                        #endif
 
                        #ifdef SHARE_PATH
                                Paths += SG_File_Make_Path(SHARE_PATH, "toolchains");
                        #endif
                }
        }
        #else // #if defined(_SAGA_LINUX)
        {
                #ifdef TOOLS_PATH
                        Paths += TOOLS_PATH;
                #endif
 
                #ifdef SHARE_PATH
                        Paths += SG_File_Make_Path(SHARE_PATH, "toolchains");
                #endif
        }
        #endif
 
        //-----------------------------------------------------
        CSG_String Additional;
 
        if( CSG_Environment::Get_Variable("SAGA_TLB", Additional) )
        {
                #if defined(_SAGA_MSW)
                        CSG_Strings Additionals = SG_String_Tokenize(Additional, ";" ); // colon (':') would split drive from paths!
                #else
                        CSG_Strings Additionals = SG_String_Tokenize(Additional, ";:"); // colon (':') is more native to non-windows os than semi-colon (';'), we support both...
                #endif
 
                for(int i=0; i<Additionals.Get_Count(); i++)
                {
                        Paths += Additionals[i];
                }
        }
 
        return( Paths );
}
 

//                                                       //
 
//---------------------------------------------------------
bool CSG_Environment::is_GUI    (void) { return( Get_Application_Name().is_Same_As("saga_gui") ); }
bool CSG_Environment::is_CMD    (void) { return( Get_Application_Name().is_Same_As("saga_cmd") ); }
bool CSG_Environment::is_Python (void) { return( Get_Application_Name().is_Same_As("python"  ) ); }
 

//                                                       //
 
//---------------------------------------------------------
CSG_String CSG_Environment::Get_Option(const CSG_String &Variable, bool bGetVariable)
{
        CSG_String Value; Get_Option(Variable, Value, bGetVariable); return( Value );
}
 
//---------------------------------------------------------
bool CSG_Environment::Get_Option(const CSG_String &Variable, CSG_String &Value, bool bGetVariable)
{
        if( theEnvironment.Options(Variable) )
        {
                Value = theEnvironment.Options[Variable].Get_Content();
 
                return( true );
        }
 
        return( bGetVariable ? Get_Variable(Variable, Value) : false );
}
 
//---------------------------------------------------------
bool CSG_Environment::Set_Option(const CSG_String &Variable, const CSG_String &Value, bool bSetVariable)
{
        if( bSetVariable )
        {
                Set_Variable(Variable, Value);
        }
 
        if( theEnvironment.Options(Variable) )
        {
                theEnvironment.Options[Variable].Set_Content(Value);
 
                return( true );
        }
 
        return( theEnvironment.Options.Add_Child(Variable, Value) != NULL );
}
 

//                                                       //
 
//---------------------------------------------------------
bool CSG_Environment::Get_Variable(const CSG_String &Variable)
{
        return( wxGetEnv(Variable.wx_str(), NULL) );
}
 
bool CSG_Environment::Get_Variable(const CSG_String &Variable, CSG_String &Value)
{
        wxString s;
 
        if( wxGetEnv(Variable.wx_str(), &s) )
        {
                Value = s.wx_str();
 
                return( true );
        }
 
        return( false );
}
 
//---------------------------------------------------------
bool CSG_Environment::Set_Variable(const CSG_String &Variable, const CSG_String &Value)
{
        return( wxSetEnv(Variable.wx_str(), Value.wx_str()) );
}
 
//---------------------------------------------------------
bool SG_Get_Environment(const CSG_String &Variable,       CSG_String *Value) { return( Value ? CSG_Environment::Get_Variable(Variable, *Value) : CSG_Environment::Get_Variable(Variable) ); }
bool SG_Set_Environment(const CSG_String &Variable, const CSG_String &Value) { return( CSG_Environment::Set_Variable(Variable, Value) ); }
 

//                                                       //
 
//---------------------------------------------------------
#if defined(_SAGA_MSW)
bool SG_Environment_Add_Dll_Paths(const CSG_String &Directory)
{
        wxDir Dir(Directory.wx_str()); bool bNoWarnings = true;
 
        if( Dir.IsOpened() )
        {
                wxString Path;
 
                if( Dir.GetFirst(&Path, "*.dll", wxDIR_HIDDEN|wxDIR_FILES) )
                {
                        CSG_String Path; CSG_Environment::Get_Variable("PATH", Path); if( Path.Find(Directory) < 0 ) { CSG_Environment::Set_Variable("PATH", Directory + ";" + Path); }
 
                        if( !AddDllDirectory(Directory.c_str()) )
                        {
                                SG_UI_Console_Print_StdErr(CSG_String::Format("Failed to add DLL directory to path environment!\n> %s\n", Directory.c_str()));
 
                                bNoWarnings = false;
                        }
                }
 
                if( Dir.GetFirst(&Path, "gdal_*.dll", wxDIR_HIDDEN|wxDIR_FILES) && CSG_Environment::Get_Option("GDAL_DRIVER_PATH").is_Empty() )
                {
                        CSG_Environment::Set_Option("GDAL_DRIVER_PATH", Directory);
                }
 
                if( Dir.GetFirst(&Path, "pdalcpp.dll", wxDIR_HIDDEN|wxDIR_FILES) )
                {
                        CSG_Environment::Set_Option("PDAL_DRIVER_PATH", Directory);
                }
 
                if( Dir.GetFirst(&Path, wxEmptyString, wxDIR_HIDDEN|wxDIR_DIRS) )
                {
                        do
                        {
                                CSG_String SubDir(Directory + "\\" + Path.wx_str());
 
                                if( !Path.CmpNoCase("gdal-plugins") ) { CSG_Environment::Set_Option("GDAL_DRIVER_PATH", SubDir); } else
                                if( !Path.CmpNoCase("gdal-data"   ) ) { CSG_Environment::Set_Option("GDAL_DATA"       , SubDir); } else
                                if( !Path.CmpNoCase("proj-data"   ) ) { CSG_Environment::Set_Option("PROJ_LIB"        , SubDir); }
 
                                if( !SG_Environment_Add_Dll_Paths(SubDir) )
                                {
                                        bNoWarnings = false;
                                }
                        }
                        while( Dir.GetNext(&Path) );
                }
        }
 
        return( bNoWarnings );
}
#endif // #if defined(_SAGA_MSW)
 

//                                                       //
//                                                       //
//                                                       //