X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=blobdiff_plain;f=src2%2FcreaImageIOTreeHandlerImageAdder.cpp;h=290da65474741d59812ad591a705f3445e1601e6;hb=b0843014c5482f70050fab8036c6780172e3b6c9;hp=ebfd2c594412a353fbcd025292497e1fa1168b3f;hpb=f1caae70392f96f30dd90eb073be6be10fbf1caa;p=creaImageIO.git

diff --git a/src2/creaImageIOTreeHandlerImageAdder.cpp b/src2/creaImageIOTreeHandlerImageAdder.cpp
index ebfd2c5..290da65 100644
--- a/src2/creaImageIOTreeHandlerImageAdder.cpp
+++ b/src2/creaImageIOTreeHandlerImageAdder.cpp
@@ -1,7 +1,15 @@
 #include <creaImageIOTreeHandlerImageAdder.h>
-#include <creaWx.h>
-#include <wx/dir.h>
-#include <wx/filename.h>
+#include <creaImageIOSystem.h>
+#include "boost/filesystem.hpp"
+#include <boost/filesystem/operations.hpp>
+#include <boost/utility.hpp>
+
+
+namespace fs = boost::filesystem;
+using boost::filesystem::path;
+using boost::next;
+using boost::prior;
+
 
 using namespace crea;
 
@@ -29,7 +37,7 @@ namespace creaImageIO
   //=====================================================================
   bool TreeHandlerImageAdder::IsHandledFile( const std::string& filename)
   {
-    return (mReader.CanRead(filename,""));
+    return (mReader.CanRead(filename));
   }
   //=====================================================================
 
@@ -37,34 +45,29 @@ namespace creaImageIO
   void TreeHandlerImageAdder::AddFiles( const std::vector<std::string>& filenames)
   {
     mProgress.Reset();
-
+	
     unsigned int nbf = filenames.size(); 
     std::vector<std::string>::const_iterator i;
+	mSynchronizer->GetList();
     for (i=filenames.begin();i!=filenames.end();++i)
       {
+	
 	mProgress.IncNumberScannedFiles();
 	if (IsHandledFile(*i)) 
 	  {
 	    mProgress.IncNumberHandledFiles();
-	    AddFile(*i);
-
-
-	    /*
-	    if (progress)
-	      {
-		std::string mess("Adding ");
-		mess += *i;
-		if (!progress->Update( (int)(summary.added_images*999./nbf),
-				       std2wx(mess)))
-		  {
-		    // Some file was added hence we must return true !
-		    summary.cancelled_by_user = true;
-		    break;
-		  }
-	      }
-	    */
+		if(mSynchronizer->isIndexed(*i))
+		{
+			mSynchronizer->InsertAddOp((*i),"0","1",mCurrentDB);
+			std::string addKey=mSynchronizer->GetAttribute("ADD_KEY","ADD_OPS","PATH",(*i),mCurrentDB);
+			std::stringstream removedOn;
+			removedOn<<time(0);
+			mSynchronizer->InsertIgnoreFile(addKey,(*i),"0",removedOn.str(),mCurrentDB);
+			AddFile(*i);
+		}
 	  }
 	mProgressSignal(mProgress);
+	if (mProgress.GetStop()) break;
       }
   }
   //=====================================================================
@@ -74,17 +77,27 @@ namespace creaImageIO
 					    bool recurse)
   {
     mProgress.Reset();
-    AddDirectoryRecursor( directory, recurse );
+	std::stringstream files;
+	
+	std::stringstream rec;
+	rec<<recurse;
+	mSynchronizer->InsertAddOp(directory,rec.str(),"0",mCurrentDB);
+	std::string addKey=mSynchronizer->GetAttribute("ADD_KEY","ADD_OPS","PATH",directory,mCurrentDB);
+	mTreeHandler->BeginTransaction();
+	mSynchronizer->GetList();
+	AddDirectoryRecursor( directory, recurse, addKey );
+	
+	int nFiles=GetProgress().GetNumberAddedFiles();
+	files<<nFiles;
+	mSynchronizer->SetAttribute("FILES_ADDED","ADD_OPS",files.str(),"ADD_KEY",addKey,mCurrentDB);
+	mTreeHandler->EndTransaction();
+    GimmickDebugMessage(3,mProgress<<std::endl);
   }
-  //=====================================================================
-
-
-
 
   //=====================================================================
   void TreeHandlerImageAdder::AddFile( const std::string& filename )
   {
-    
+    GimmickDebugMessage(4,"Adding '"<<filename<<"'"<<std::endl);
     std::map< std::string, std::string>  attr;
     mTreeHandler->GetTree().GetDescriptor().BuildAttributeMap(attr);
 
@@ -98,75 +111,494 @@ namespace creaImageIO
   }
   //=====================================================================
 
+  void TreeHandlerImageAdder::RemoveFile( tree::Node* node)
+  {
+		int n=node->GetNumberOfChildren();
+		if(n>0)
+		{
+			RemoveFiles(node->GetChildrenList());
+		}
+		else
+		{
+		  std::string path=node->GetAttribute("FullFileName");
+		  //Gets the add key
+		  std::string addKey=mSynchronizer->GetAttribute("ADD_KEY","IGNORED_FILES","PATH",path,mCurrentDB);
+		  //Gets the number of files added
+		  int files=atoi((mSynchronizer->GetAttribute("FILES_ADDED","ADD_OPS","ADD_KEY",addKey,mCurrentDB)).c_str());
+		  files=files-1;
+		  std::stringstream out;
+		  out<<files;
+		  //Sets the new number of files
+		  mSynchronizer->SetAttribute("FILES_ADDED","ADD_OPS",out.str(),"ADD_KEY",addKey,mCurrentDB);
+		  //Sets the file as removed
+		  mSynchronizer->SetAttribute("REMOVE","IGNORED_FILES","1","PATH = '"+path+"' AND ADD_KEY",addKey,mCurrentDB);
+		}
+  }
+
+  //=====================================================================
+
+  void TreeHandlerImageAdder::RemoveFiles(const std::vector<tree::Node*>& nodes)
+  {
+	  std::vector<tree::Node*>::const_iterator it;
+	  for(it=nodes.begin();it!=nodes.end();++it)
+	  {
+		int n=(*it)->GetNumberOfChildren();
+		if(n>0)
+		{
+			RemoveFiles((*it)->GetChildrenList());
+		}
+		else
+		{
+		   std::string path=(*it)->GetAttribute("FullFileName");
+		  //Gets the add key
+		  std::string addKey=mSynchronizer->GetAttribute("ADD_KEY","IGNORED_FILES","PATH",path,mCurrentDB);
+		  //Gets the number of files added
+		  int files=atoi((mSynchronizer->GetAttribute("FILES_ADDED","ADD_OPS","ADD_KEY",addKey,mCurrentDB)).c_str());
+		  files=files-1;
+		  std::stringstream out;
+		  out<<files;
+		  //Sets the new number of files
+		  mSynchronizer->SetAttribute("FILES_ADDED","ADD_OPS",out.str(),"ADD_KEY",addKey,mCurrentDB);
+		  //Sets the file as removed
+		  mSynchronizer->SetAttribute("REMOVE","IGNORED_FILES","1","PATH = '"+path+"' AND ADD_KEY",addKey,mCurrentDB);
+		}
+	
+	  }
+  }
+
+ 
   //=====================================================================
   void TreeHandlerImageAdder::AddDirectoryRecursor(const std::string &dirpath, 
-						   bool recursive)
+						   bool recursive,
+						   const std::string &addKey)
   {
-    //    std::cout << "dir : "<<dirpath << std::endl;
-   mProgress.IncNumberScannedDirs();
-    /*
-    if (progress) 
-      {
-	std::string mess("Parsing ");
-	mess += dirpath;
-	progress->Pulse(std2wx(mess));
-      }
-    */    
-    std::string fileName;
-    std::string dirName = dirpath;
+    GimmickDebugMessage(4,"Scanning '"<<dirpath<<"'"<<std::endl);
+    mProgress.IncNumberScannedDirs();
 
-    wxDir dir( std2wx(dirpath) );
+    if ( !fs::exists( dirpath ) ) return;
+	time_t lastModif=fs::last_write_time(dirpath);
 
-    if ( !dir.IsOpened() )
-      {
-        // deal with the error here - wxDir would already log an error message
-        // explaining the exact reason of the failure
-        return;
+	
+    fs::directory_iterator end_itr; // default construction yields past-the-end
+    for ( fs::directory_iterator itr( dirpath );
+	  itr != end_itr;
+	  ++itr )
+	{
+	// If is directory & recurse : do recurse
+	if ( fs::is_directory(itr->status()) )
+	  {
+	    if (recursive) 
+		{
+			AddDirectoryRecursor( itr->string(), recursive, addKey);
+		}
+	  }
+	else 
+	  {
+		std::string parent_id;
+		// tTest if directory (and only it) exists or not.
+		bool valid = mSynchronizer->isIndexed(itr->string());//true;//=mTimestampHandler->AddDirectory(dirpath, itr->string(), lastModif, time(0),mCurrentDB);
+		if(valid)
+		{
+			mProgress.IncNumberScannedFiles();
+			if (IsHandledFile(itr->string()))
+			{
+			mProgress.IncNumberHandledFiles();
+			AddFile( itr->string() );
+			mTreeHandler->GetTopLevelNodeId("FullFileName",itr->string(),parent_id);
+			std::stringstream removedOn;
+			removedOn<<time(0);
+			mSynchronizer->InsertIgnoreFile(addKey, itr->string(),"0",removedOn.str(),mCurrentDB);
+			}
+			
+			mProgressSignal(mProgress);
+			if (mProgress.GetStop()) 
+			{
+			//itr = end_itr;
+			break;
+			}
+			
+		}
+	  }
       }
+	
+  }
+  //=======================================================================
+  
+  //=======================================================================
 
-    wxString filename;
+  void TreeHandlerImageAdder::CheckSyncDirectory(const std::string &dirpath, 
+												bool recursive, 
+												bool repair,
+												bool checkAttributes,
+												std::vector<std::string> &i_ignorefiles,
+												std::vector<std::string> & attsModified,
+												std::vector<std::string> & newfiles)
+  {
+    if ( !fs::exists( dirpath ) ) return;
+    fs::directory_iterator end_itr; // default construction yields past-the-end
+			  
+    for ( fs::directory_iterator itr( dirpath ); itr != end_itr; ++itr ) 
+	{
+        // If is directory & recurse : do recurse
+        if ( fs::is_directory(itr->status()) )
+        {
+            if (recursive)
+			{
+                CheckSyncDirectory( itr->string(), recursive, repair, checkAttributes, i_ignorefiles, attsModified, newfiles);
+			}
+        }
+        else
+        {
+            if (IsHandledFile(itr->string()))
+            {
+                bool bfound = false;
+                for(std::vector<std::string>::iterator it_new = i_ignorefiles.begin(); it_new < i_ignorefiles.end(); ++it_new)
+                {
+					if((*it_new) == itr->string())
+                    {
+                        bfound = true;
+						//Additional checking of attributes
+						if(checkAttributes)
+						{
+							CheckAttributes(repair,(*it_new),attsModified);
+						}
+                        i_ignorefiles.erase(it_new);
+                        break;
+                    }
+				}
+				if(!bfound && i_ignorefiles.size()>0 )
+                {
+                    newfiles.push_back( itr->string() );
+                }
+			}
+		}
+	 }
+  } 
 
-    bool cont = dir.GetFirst(&filename, wxEmptyString, 
-			     wxDIR_FILES | wxDIR_HIDDEN );
-    while ( cont )
-      {
-	mProgress.IncNumberScannedFiles();
+  //=======================================================================
+  
+  //=======================================================================
+
+  std::string TreeHandlerImageAdder::Synchronize(bool repair, bool checkAttributes)
+  {
+	  std::vector<AddList> fileList;
+	  std::vector<std::string> ignoreList;
+	  std::vector<std::string> newFiles;
+	  std::vector<std::string> attsModified;
+	  std::stringstream mess;
+	  std::vector<AddList>::iterator iter;
+
+	  //Gets the list of added files
+	  mSynchronizer->GetFileList(fileList,mCurrentDB);
 
-	wxFileName wxffn(dir.GetName(),filename);
-	std::string ffn = wx2std(wxffn.GetFullPath());
-	//	std::cout << "file : "<<ffn << std::endl;
-	if (IsHandledFile(ffn)) 
+	  std::vector<std::string>::iterator i;
+	  //Actions to take if the user doesn't want to repair
+	  if(!repair)
 	  {
-	    mProgress.IncNumberHandledFiles();
-	    //	    std::cout << "handled : "<<ffn << std::endl;
-	    AddFile( ffn );
+		//Iterates to see if they are in sync
+		for(iter=fileList.begin();iter!=fileList.end();++iter)
+		{
+			mSynchronizer->GetIgnoredFiles((*iter).key,ignoreList);
+			bool rec=true;
+			if((*iter).recursive=="0"){rec=false;}
+			CheckSyncDirectory((*iter).path,rec,repair,checkAttributes,ignoreList,attsModified,newFiles);
+		}
+
+		//Add to message the result of new found files
+		mess<<"New Files Found: "<<newFiles.size()<<std::endl;
+		if(newFiles.size()>0)
+		{
+			mess<<"Filenames: "<<std::endl;
+			for(i=newFiles.begin();i!=newFiles.end();++i)
+			{
+				mess<<*i<<std::endl;
+			}
+		}
+
+		//Add to message the result of missing files
+		mess<<"Missing Files: "<<ignoreList.size()<<std::endl;
+		if(ignoreList.size()>0)
+		{
+			mess<<"Filenames: "<<std::endl;
+			for(i=ignoreList.begin();i!=ignoreList.end();++i)
+			{
+				mess<<*i<<std::endl;
+			}
+		}
+
+		//In the case that the user wants to check the attributes...
+		if(checkAttributes)
+		{
+			//... add to message the result of files that have been changed.
+			mess<<"Files with different attributes: "<<attsModified.size()<<std::endl;
+			if(attsModified.size()>0)
+			{
+				mess<<"Filenames: "<<std::endl;
+				for(i=attsModified.begin();i!=attsModified.end();++i)
+				{
+					mess<<*i<<std::endl;
+				}
+			}
+		}
+		
 	  }
-	//	std::cout << "signal " << std::endl;
-	mProgressSignal(mProgress);
-	//	std::cout << "cont " << std::endl;
-	cont = ( dir.GetNext(&filename) && (!mProgress.GetStop()) );
-	//	std::cout << "next" << std::endl;
-      }
-    
-    // Recurse into subdirs
-    if ( recursive )
-      {
-	//	std::cout << "recurse " << std::endl;
-	cont = dir.GetFirst(&filename, wxEmptyString, 
-			    wxDIR_DIRS | wxDIR_HIDDEN );
-	while ( cont )
+
+	  //Actions to take if the user wants to repair
+	  else
 	  {
-	    wxFileName wxffn(dir.GetName(),filename);
-	    std::string ffn = wx2std(wxffn.GetFullPath());
-	    //	    std::cout << "goto "<<ffn << std::endl;
-	    AddDirectoryRecursor( ffn, recursive);
-	    cont = dir.GetNext(&filename);
+		  int nf=0;
+		//Iterates to see if they are in sync
+		for(iter=fileList.begin();iter!=fileList.end();++iter)
+		{
+			mSynchronizer->GetIgnoredFiles((*iter).key,ignoreList);
+			bool rec=true;
+			if((*iter).recursive=="0"){rec=false;}
+			CheckSyncDirectory((*iter).path,rec,repair,checkAttributes,ignoreList,attsModified,newFiles);
+
+			//For the new files, add them
+			for (i=newFiles.begin();i!=newFiles.end();++i)
+			{
+			if (IsHandledFile(*i)) 
+			{
+				std::stringstream removedOn;
+				removedOn<<time(0);
+				mSynchronizer->InsertIgnoreFile((*iter).key,(*i),"0",removedOn.str(),mCurrentDB);
+				//Gets the number of files added
+				int files=atoi((mSynchronizer->GetAttribute("FILES_ADDED","ADD_OPS","ADD_KEY",(*iter).key,mCurrentDB)).c_str());
+				files=files+1;
+				std::stringstream out;
+				out<<files;
+				//Sets the new number of files
+				mSynchronizer->SetAttribute("FILES_ADDED","ADD_OPS",out.str(),"ADD_KEY",(*iter).key,mCurrentDB);
+				AddFile(*i);
+			}
+			}
+			nf+=newFiles.size();
+			newFiles.clear();
+
+		}
+		//Reports number of added files
+		mess<<"Files Added: "<<nf<<std::endl;
+		
+		//Removes the necessary files and reports the results
+		if(ignoreList.size()>0)
+		{
+			tree::Node* node;
+			mTreeHandler->LoadChildren(NULL,4);
+			for(i=ignoreList.begin();i!=ignoreList.end();++i)
+			{
+				FindNode(mTreeHandler->GetTree().GetChildrenList()[0],3,"FullFileName",*i,node);
+				RemoveFile(node);
+				mTreeHandler->Remove(node);
+			}
+		}
+		mess<<"Files Removed: "<<ignoreList.size()<<std::endl;
+		//In the case that the user wants to check the attributes...
+		if(checkAttributes)
+		{
+			//... add to message the result of files that were modified.
+			mess<<"Files Modified: "<<attsModified.size()<<std::endl;
+		}
 	  }
-      }
-    
+	  return mess.str();
+
   }
   //=======================================================================
 
+  void TreeHandlerImageAdder::CheckAttributes(bool repair, std::string& file, std::vector<std::string>& attsModified)
+  {
+	  std::map< std::string, std::string>  attr;
+	  mTreeHandler->GetTree().GetDescriptor().BuildAttributeMap(attr);
+      mReader.ReadAttributes(file,attr);
+	  tree::LevelDescriptor::AttributeDescriptorListType adl= mTreeHandler->GetTree().GetAttributeDescriptorList(mTreeHandler->GetTree().GetNumberOfLevels()-1);	
+	  tree::LevelDescriptor::AttributeDescriptorListType::const_iterator a;
+	  for (a = adl.begin();a!=adl.end();++a)
+	  {
+	   std::string databaseVal;
+	   mTreeHandler->GetAttribute("Image","FullFileName",file,a->GetKey(),databaseVal);
+	   std::string fileVal=attr.find(a->GetKey())->second;
+	   if ( a->GetFlags()==0 && databaseVal == fileVal) 
+	    {
+			if(repair)
+			{
+				mTreeHandler->SetAttribute("Image",a->GetKey(),fileVal,"FullFileName", file);	
+			}
+			attsModified.push_back(file);
+	    }
+		
+	  }
+	  
+  }
+
+  //=======================================================================
+
+
+  void TreeHandlerImageAdder::FindNode(tree::Node* parent, int level, const std::string& searchParam, const std::string& searchVal, tree::Node*& node)
+  {
+	  if(level>1)
+	  {
+		  std::vector<tree::Node*>::iterator iter;
+		  for(iter=parent->GetChildrenList().begin();iter!=parent->GetChildrenList().end();++iter)
+		  {
+			  FindNode(*iter,level-1,searchParam,searchVal,node);
+		  }
+	  }
+	  else
+	  {
+		  if(parent->GetAttribute(searchParam).compare(searchVal)==0)
+		  {
+			  node=parent;
+		  }
+
+	  }
+  }
+  
+  void TreeHandlerImageAdder::SaveAs(const std::vector<std::string>& filenames, std::vector<vtkImageData *> i_images)
+  {
+	  std::vector<std::string>::const_iterator it_file = filenames.begin();
+	  std::vector<vtkImageData *>::iterator it_image = i_images.begin();
+	/*  mWriter.CanWrite(".jpeg");
+	  for(; it_file != filenames.end(); ++it_file, ++it_image)
+		  mWriter.WriteImage(it_file->c_str(), (vtkImageData &)it_image);*/
+  }
+
+  //=======================================================================
+  void TreeHandlerImageAdder::FindNodePartial(tree::Node* parent, int level, const std::string& searchParam, const std::string& searchVal, tree::Node*& node)
+  {
+	  if(level>1)
+	  {
+		  std::vector<tree::Node*>::iterator iter;
+		  for(iter=parent->GetChildrenList().begin();iter!=parent->GetChildrenList().end() && node==0 ;++iter)
+		  {
+			  FindNodePartial(*iter,level-1,searchParam,searchVal,node);
+		  }
+	  }
+	  else
+	  {
+		  if(parent->GetAttribute(searchParam).find(searchVal)<9000)
+		  {
+			  node=parent;
+			  return;
+		  }
+
+	  }
+  }
+  
+  //=======================================================================
+
+  void TreeHandlerImageAdder::CopyFiles(const std::vector<std::string>& filenames, const std::string directory  )
+  {
+	  std::vector<std::string>::const_iterator i;
+	  if(!boost::filesystem::exists(directory))
+	  {
+	  boost::filesystem::create_directory(boost::filesystem::path(directory));
+	  mSynchronizer->InsertAddOp(directory,"0","0",mCurrentDB);
+	  }
+	  std::string addKey=mSynchronizer->GetAttribute("ADD_KEY","ADD_OPS","PATH",directory,mCurrentDB);
+	  size_t last;
+	  std::vector<std::string> newNames;
+	  for(i=filenames.begin();i!=filenames.end();++i)
+	  {
+		  std::string dir=directory.c_str();
+		  if(boost::filesystem::exists(*i) && (*i).find(dir)==std::string::npos)
+		  {
+		  std::string path=*i;
+		  last=(*i).find_last_of('/');
+		  std::string f="\\"+(*i).substr(last+1);
+	
+		  int p=1;
+		  std::stringstream out;
+		  out<<directory<<f;
+		  while(boost::filesystem::exists(out.str()))
+		  {
+			  out.str("");
+			  out<<directory<<f.substr(0,f.size()-4)<<"("<<p<<")"<<f.substr(f.size()-4);
+			  p++;
+		  }
+		  std::string result=out.str();
+		  boost::filesystem::copy_file((*i),result);
+
+		  //To update image database
+		  mTreeHandler->SetAttribute("Image","FullFileName",result,"FullFileName", (*i));
+		  
+		  //To update maintenance database
+		  //1.Add the new path and increase number of children on new operation.
+		  std::stringstream removedOn;
+		  removedOn<<time(0);
+		  //Inserts the file
+		  mSynchronizer->InsertIgnoreFile(addKey, result,"0",removedOn.str(),mCurrentDB);
+		  //Gets the number of files added
+		  int files=atoi((mSynchronizer->GetAttribute("FILES_ADDED","ADD_OPS","ADD_KEY",addKey,mCurrentDB)).c_str());
+		  files=files+1;
+		  std::stringstream fil;
+		  fil<<files;
+		  //Sets the new number of files
+		  mSynchronizer->SetAttribute("FILES_ADDED","ADD_OPS",fil.str(),"ADD_KEY",addKey,mCurrentDB);
+		  fil.str("");
+
+		  //2.Set the old path as removed and decrease number of children on old operation.
+		  //Gets the old add key
+		  std::string oldAddKey=mSynchronizer->GetAttribute("ADD_KEY","IGNORED_FILES","PATH",path,mCurrentDB);
+		  //Sets the file as removed
+		  mSynchronizer->SetAttribute("REMOVE","IGNORED_FILES","1","PATH = '"+path+"' AND ADD_KEY",oldAddKey,mCurrentDB);
+		  //Gets the number of files added
+		  files=atoi((mSynchronizer->GetAttribute("FILES_ADDED","ADD_OPS","ADD_KEY",oldAddKey,mCurrentDB)).c_str());
+		  files=files-1;
+		  fil<<files;
+		  //Sets the new number of files
+		  mSynchronizer->SetAttribute("FILES_ADDED","ADD_OPS",fil.str(),"ADD_KEY",oldAddKey,mCurrentDB);
+		  
+		  }
+
+	  }
+  }
+
+  //=======================================================================
+
+  void TreeHandlerImageAdder::DeleteDriveFromMainDB(const std::string& drive)
+  {
+	  //Delete from local database and others
+	  tree::Node* node=0;
+	  mTreeHandler->LoadChildren(NULL,4);
+	  FindNodePartial(mTreeHandler->GetTree().GetChildrenList()[0],3,"FullFileName",drive,node);
+	  while(node!=0)
+	  {
+	  mTreeHandler->Remove(node);
+	  node=0;
+	  mTreeHandler->LoadChildren(NULL,4);
+	  FindNodePartial(mTreeHandler->GetTree().GetChildrenList()[0],3,"FullFileName",drive,node); 
+	  }
+  }
+
+   //=======================================================================
+
+  void TreeHandlerImageAdder::DeleteDriveFromOtherDB(const std::string& drive)
+  {
+	  //Delete from maintenance
+	  mSynchronizer->RemoveEntries("ADD_OPS", "PATH", "LIKE", drive+"%");
+	  mSynchronizer->RemoveEntries("IGNORED_FILES", "PATH", "LIKE", drive+"%");
+  }
+
+  //=======================================================================
+  void TreeHandlerImageAdder::EditField(tree::Node* node, const std::string& name, const std::string& key, const std::string& val)
+  {
+	  node->SetAttribute(key,val);
+	  mTreeHandler->SetAttribute(node,key,val);
+  }
+
+  //=======================================================================
+  void TreeHandlerImageAdder::GetAttributes(const std::vector<std::string>& params, 
+	  const std::string& filename, 
+	  std::vector<std::string>& results)
+  {
+	  std::vector<std::string>::const_iterator i;
+	  std::string result;
+	  for(i=params.begin();i!=params.end();i++)
+	  {
+		  mTreeHandler->GetAttribute("Image","FullFileName",filename,*i,result);
+		  results.push_back(result);
+	  }
+  }
 
  
 }