diff options
Diffstat (limited to 'plugins/Themes/Oxygen2/TransferModel.cpp')
| -rwxr-xr-x | plugins/Themes/Oxygen2/TransferModel.cpp | 755 |
1 files changed, 755 insertions, 0 deletions
diff --git a/plugins/Themes/Oxygen2/TransferModel.cpp b/plugins/Themes/Oxygen2/TransferModel.cpp new file mode 100755 index 0000000..5a97aab --- /dev/null +++ b/plugins/Themes/Oxygen2/TransferModel.cpp @@ -0,0 +1,755 @@ +#include "TransferModel.h" +#include "../../../cpp11addition.h" +#include <iostream> + +#define COLUMN_COUNT 3 + +// Model + +QIcon *TransferModel::start=NULL; +QIcon *TransferModel::stop=NULL; + +TransferModel::TransferModel() +{ + /// \warning to prevent Must construct a QGuiApplication before QPixmap IN STATIC WINDOWS VERSION ONLY + if(TransferModel::start==NULL) + TransferModel::start=new QIcon(QStringLiteral(":/resources/player_play.png")); + if(TransferModel::stop==NULL) + TransferModel::stop=new QIcon(QStringLiteral(":/resources/player_pause.png")); + currentIndexSearch=0; + haveSearchItem=false; + loop_size=0,index_for_loop=0; + sub_loop_size=0,sub_index_for_loop=0; + row=0,column=0; + facilityEngine=NULL; + currentIndexSearch=0; + haveSearchItem=false; + searchId=0; + + tree=NULL; +} + +int TransferModel::columnCount( const QModelIndex& parent ) const +{ + return parent == QModelIndex() ? COLUMN_COUNT : 0; +} + +QVariant TransferModel::data( const QModelIndex& index, int role ) const +{ + int row,column; + row=index.row(); + column=index.column(); + if(index.parent()!=QModelIndex() || row < 0 || (unsigned int)row >= transfertItemList.size() || column < 0 || column >= COLUMN_COUNT) + return QVariant(); + + const TransfertItem& item = transfertItemList.at(row); + if(role==Qt::UserRole) + return (quint64)item.id; + else if(role==Qt::DisplayRole) + { + switch(column) + { + case 0: + return QString::fromStdString(item.source); + break; + case 1: + return QString::fromStdString(item.size); + break; + case 2: + return QString::fromStdString(item.destination); + break; + default: + return QVariant(); + } + } + else if(role==Qt::DecorationRole) + { + switch(column) + { + case 0: + if(stopId.find(item.id)!=stopId.cend()) + return *stop; + else if(startId.find(item.id)!=startId.cend()) + return *start; + else + return QVariant(); + break; + default: + return QVariant(); + } + } + else if(role==Qt::BackgroundRole) + { + if(!search_text.empty() && (item.source.find(search_text)!=std::string::npos || + item.destination.find(search_text)!=std::string::npos)) + { + if(haveSearchItem && searchId==item.id) + return QColor(255,150,150,100); + else + return QColor(255,255,0,100); + } + else + return QVariant(); + } + return QVariant(); +} + +int TransferModel::rowCount( const QModelIndex& parent ) const +{ + return parent == QModelIndex() ? transfertItemList.size() : 0; +} + +uint64_t TransferModel::firstId() const +{ + if(transfertItemList.size()>0) + return transfertItemList.front().id; + else + return 0; +} + +QVariant TransferModel::headerData( int section, Qt::Orientation orientation, int role ) const +{ + if(facilityEngine==NULL) + abort(); + if ( role == Qt::DisplayRole && orientation == Qt::Horizontal && section >= 0 && section < COLUMN_COUNT ) { + switch ( section ) { + case 0: + return QString::fromStdString(facilityEngine->translateText("Source")); + case 1: + return QString::fromStdString(facilityEngine->translateText("Size")); + case 2: + return QString::fromStdString(facilityEngine->translateText("Destination")); + } + } + + return QAbstractTableModel::headerData( section, orientation, role ); +} + +bool TransferModel::setData( const QModelIndex& index, const QVariant& value, int role ) +{ + row=index.row(); + column=index.column(); + if(index.parent()!=QModelIndex() || row < 0 || (unsigned int)row >= transfertItemList.size() || column < 0 || column >= COLUMN_COUNT) + return false; + + TransfertItem& item = transfertItemList[row]; + if(role==Qt::UserRole) + { + item.id=value.toULongLong(); + return true; + } + else if(role==Qt::DisplayRole) + { + switch(column) + { + case 0: + item.source=value.toString().toStdString(); + emit dataChanged(index,index); + return true; + break; + case 1: + item.size=value.toString().toStdString(); + emit dataChanged(index,index); + return true; + break; + case 2: + item.destination=value.toString().toStdString(); + emit dataChanged(index,index); + return true; + break; + default: + return false; + } + } + return false; +} + +Folder * TransferModel::appendToTreeR(Folder * const tree, const std::string &subPath,Folder * const oldTree) +{ + const std::string::size_type n=subPath.find('/'); + + //isolate the name + std::string name; + if(n == std::string::npos) + name=subPath; + else + name=subPath.substr(0,n); + //search + auto search = tree->folders.find(name); + Folder * folder=nullptr; + if(search == tree->folders.end()) + { + //append or remplace the existing + if(oldTree!=NULL && (n+1)==subPath.size()) + { + oldTree->setName(subPath.substr(0,n).c_str()); + folder=oldTree; + } + else + folder=new Folder(name); + if(!folder->isFolder()) + { + if(oldTree!=NULL) + abort(); + return nullptr; + } + tree->append(folder); + } + else + { + //create a new leaf + File * file=search->second; + if(!file->isFolder()) + return nullptr; + folder=static_cast<Folder *>(file); + } + if(n == std::string::npos || n+1==subPath.size()) + return folder; + else + return appendToTreeR(folder,subPath.substr(n+1),oldTree); +} + +void TransferModel::appendToTree(const std::string &path,const uint64_t &size) +{ + if(size==0) + return; + const std::string::size_type n=path.rfind('/'); + if(n == std::string::npos) + return; + if(treePath.empty()) + { + treePath=path.substr(0,n+1); + tree->append(path.c_str()+n+1,size); + } + else + { + const std::string &newPath=path.substr(0,n+1); + unsigned int index=0; + while(index<newPath.size() && index<treePath.size()) + { + if(treePath.at(index)!=newPath.at(index)) + break; + index++; + } + //append to current path + if(index==treePath.size()) + { + //get the next path, found or create + Folder * finalTree=tree; + if((n+1)>index) + { + const std::string &subPath=path.substr(index,(n+1)-index); + finalTree=appendToTreeR(tree,subPath); + } + finalTree->append(path.c_str()+n+1,size); + } + else //new root is to be created + { + //save the old values + const std::string oldTreePath=treePath; + Folder * const oldTree=tree; + tree=new Folder(""); + treePath=path.substr(0,index); + + //path switch to rebase the root + if(oldTreePath.size()>index) + appendToTreeR(tree,oldTreePath.substr(index),oldTree); + + Folder * finalTree=tree; + //make the new sub path if have + if((n+1)>index) + finalTree=appendToTreeR(tree,path.substr(index)); + + //do the file + finalTree->append(path.c_str()+n+1,size); + } + } + #ifdef ULTRACOPIER_PLUGIN_DEBUG + //check the integrity of tree + /*now it's mostly stable checkIntegrityChildren(tree); + checkIntegritySize(tree);*/ + #endif +} + +#ifdef ULTRACOPIER_PLUGIN_DEBUG +//check the integrity of tree size +uint64_t TransferModel::checkIntegritySize(const Folder * const tree) +{ + uint64_t size=0; + unsigned int index=0; + while(index<tree->onlyFiles.size()) + { + File * file=tree->onlyFiles.at(index); + if(file->parent()!=tree) + { + std::cerr << "tree parrent corrupted" << std::endl; + abort(); + } + size+=file->size(); + index++; + } + for(const auto& n : tree->folders) + { + Folder * folder=n.second; + if(folder->parent()!=tree) + { + std::cerr << "tree parrent corrupted" << std::endl; + abort(); + } + size+=checkIntegritySize(folder); + } + if(size!=tree->size()) + { + std::cerr << "tree corrupted" << std::endl; + abort(); + } + return tree->size(); +} + +//check the integrity of tree children +uint64_t TransferModel::checkIntegrityChildren(const Folder * const tree) +{ + uint64_t childrens=0; + childrens+=tree->onlyFiles.size(); + for(const auto& n : tree->folders) + { + Folder * folder=n.second; + if(folder->parent()!=tree) + { + std::cerr << "tree parrent corrupted" << std::endl; + abort(); + } + childrens+=checkIntegrityChildren(folder); + } + if(childrens!=tree->children()) + { + std::cerr << "tree corrupted" << std::endl; + abort(); + } + return tree->children(); +} +#endif + +/* + Return[0]: totalFile + Return[1]: totalSize + Return[2]: currentFile + */ +std::vector<uint64_t> TransferModel::synchronizeItems(const std::vector<Ultracopier::ReturnActionOnCopyList>& returnActions) +{ + const QModelIndexList oldIndexes = persistentIndexList(); + QModelIndexList newIndexes=oldIndexes; + QMap<int, quint64> oldMapping; // model index row in model before update, item id + QMap<quint64, int> newMapping; // item id, model index row in model after update + for ( int i = 0; i < oldIndexes.count(); i++ ) { + const QModelIndex& index = oldIndexes.at(i); + oldMapping[index.row()] = index.data( Qt::UserRole ).value<quint64>(); + } + + loop_size=returnActions.size(); + index_for_loop=0; + quint64 totalFile=0,totalSize=0,currentFile=0; + emit layoutAboutToBeChanged(); + while(index_for_loop<loop_size) + { + const Ultracopier::ReturnActionOnCopyList& action=returnActions.at(index_for_loop); + switch(action.type) + { + case Ultracopier::AddingItem: + { + TransfertItem newItem; + newItem.id=action.addAction.id; + newItem.source=action.addAction.sourceFullPath; + newItem.size=facilityEngine->sizeToString(action.addAction.size); + newItem.destination=action.addAction.destinationFullPath; + transfertItemList.push_back(newItem); + totalFile++; + totalSize+=action.addAction.size; + + appendToTree(action.addAction.sourceFullPath,action.addAction.size); + } + break; + case Ultracopier::MoveItem: + { + //bool current_entry= + if(action.userAction.position<0) + { + ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Warning,QStringLiteral("id: %1, position is wrong: %2").arg(action.addAction.id).arg(action.userAction.position).toStdString()); + break; + } + if((unsigned int)action.userAction.position>(transfertItemList.size()-1)) + { + ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Warning,QStringLiteral("id: %1, position is wrong: %2").arg(action.addAction.id).arg(action.userAction.position).toStdString()); + break; + } + if(action.userAction.moveAt<0) + { + ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Warning,QStringLiteral("id: %1, position is wrong: %2").arg(action.addAction.id).arg(action.userAction.position).toStdString()); + break; + } + if((unsigned int)action.userAction.moveAt>(transfertItemList.size()-1)) + { + ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Warning,QStringLiteral("id: %1, position is wrong: %2").arg(action.addAction.id).arg(action.userAction.position).toStdString()); + break; + } + if(action.userAction.position==action.userAction.moveAt) + { + ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Warning,QStringLiteral("id: %1, move at same position: %2").arg(action.addAction.id).arg(action.userAction.position).toStdString()); + break; + } + const TransfertItem transfertItem=transfertItemList.at(action.userAction.position); + transfertItemList.erase(transfertItemList.cbegin()+action.userAction.position); + transfertItemList.insert(transfertItemList.cbegin()+action.userAction.moveAt,transfertItem); + //newIndexes.move(action.userAction.position,action.userAction.moveAt); + } + break; + case Ultracopier::RemoveItem: + { + if(currentIndexSearch>0 && action.userAction.position<=currentIndexSearch) + currentIndexSearch--; + if(action.userAction.position<0) + { + ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Notice,QStringLiteral("id: %1, position is wrong: %3").arg(action.addAction.id).arg(action.userAction.position).toStdString()); + break; + } + if((unsigned int)action.userAction.position>(transfertItemList.size()-1)) + { + ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Notice,QStringLiteral("id: %1, position is wrong: %3").arg(action.addAction.id).arg(action.userAction.position).toStdString()); + break; + } + transfertItemList.erase(transfertItemList.cbegin()+action.userAction.position); + currentFile++; + startId.erase(action.addAction.id); + stopId.erase(action.addAction.id); + internalRunningOperation.erase(action.addAction.id); + //newIndexes.remove(action.userAction.moveAt); + } + break; + case Ultracopier::PreOperation: + { + ItemOfCopyListWithMoreInformations tempItem; + tempItem.currentReadProgression=0; + tempItem.currentWriteProgression=0; + tempItem.generalData=action.addAction; + tempItem.actionType=action.type; + internalRunningOperation[action.addAction.id]=tempItem; + } + break; + case Ultracopier::Transfer: + { + if(startId.find(action.addAction.id)==startId.cend()) + startId.insert(action.addAction.id); + stopId.erase(action.addAction.id); + if(internalRunningOperation.find(action.addAction.id)!=internalRunningOperation.cend()) + internalRunningOperation[action.addAction.id].actionType=action.type; + else + ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Warning,QStringLiteral("unable to found entry for file %1: actionType: Transfer").arg(action.addAction.id).toStdString()); + } + break; + case Ultracopier::PostOperation: + { + if(stopId.find(action.addAction.id)==stopId.cend()) + stopId.insert(action.addAction.id); + startId.erase(action.addAction.id); + } + break; + case Ultracopier::CustomOperation: + { + bool custom_with_progression=(action.addAction.size==1); + //without progression + if(custom_with_progression) + { + if(startId.find(action.addAction.id)!=startId.cend()) + { + startId.erase(action.addAction.id); + if(stopId.find(action.addAction.id)==stopId.cend()) + stopId.insert(action.addAction.id); + } + } + //with progression + else + { + stopId.erase(action.addAction.id); + if(startId.find(action.addAction.id)==startId.cend()) + startId.insert(action.addAction.id); + } + if(internalRunningOperation.find(action.addAction.id)!=internalRunningOperation.cend()) + { + ItemOfCopyListWithMoreInformations &item=internalRunningOperation[action.addAction.id]; + item.actionType=action.type; + item.custom_with_progression=custom_with_progression; + item.currentReadProgression=0; + item.currentWriteProgression=0; + } + } + break; + default: + //unknow code, ignore it + break; + } + index_for_loop++; + } + + if(!oldIndexes.isEmpty()) + { + const QSet<quint64> ids = oldMapping.values().toSet(); + + for ( unsigned int i = 0; i < transfertItemList.size(); i++ ) { + const TransferModel::TransfertItem& item = transfertItemList.at(i); + + if ( ids.contains( item.id ) ) { + newMapping[ item.id ] = i; + } + } + + for ( int i = 0; i < oldIndexes.count(); i++ ) { + const QModelIndex& index = oldIndexes.at(i); + const int newRow = newMapping.value( oldMapping.value(index.row()), -1 ); + newIndexes[ i ] = newRow == -1 ? QModelIndex() : QAbstractTableModel::index( newRow, index.column(), index.parent() ); + } + } + + changePersistentIndexList( oldIndexes, newIndexes ); + emit layoutChanged(); + { + std::vector<uint64_t> newList; + newList.resize(3); + newList[0]=totalFile; + newList[1]=totalSize; + newList[2]=currentFile; + return newList; + } +} + +void TransferModel::setFacilityEngine(FacilityInterface * facilityEngine) +{ + this->facilityEngine=facilityEngine; +} + +int TransferModel::search(const std::string &text, bool searchNext) +{ + emit layoutAboutToBeChanged(); + search_text=text; + emit layoutChanged(); + if(transfertItemList.size()==0) + return -1; + if(text.empty()) + return -1; + if(searchNext) + { + currentIndexSearch++; + if(currentIndexSearch>=loop_size) + currentIndexSearch=0; + } + index_for_loop=0; + loop_size=transfertItemList.size(); + while(index_for_loop<loop_size) + { + const TransfertItem &transfertItem=transfertItemList.at(currentIndexSearch); + if(transfertItem.source.find(search_text)!=std::string::npos || + transfertItem.destination.find(search_text)!=std::string::npos) + { + haveSearchItem=true; + searchId=transfertItemList.at(currentIndexSearch).id; + return currentIndexSearch; + } + currentIndexSearch++; + if(currentIndexSearch>=loop_size) + currentIndexSearch=0; + index_for_loop++; + } + haveSearchItem=false; + return -1; +} + +int TransferModel::searchPrev(const std::string &text) +{ + emit layoutAboutToBeChanged(); + search_text=text; + emit layoutChanged(); + if(transfertItemList.size()==0) + return -1; + if(text.empty()) + return -1; + if(currentIndexSearch==0) + currentIndexSearch=loop_size-1; + else + currentIndexSearch--; + index_for_loop=0; + loop_size=transfertItemList.size(); + while(index_for_loop<loop_size) + { + const TransfertItem &transfertItem=transfertItemList.at(currentIndexSearch); + if(transfertItem.source.find(search_text)!=std::string::npos || + transfertItem.destination.find(search_text)!=std::string::npos) + { + haveSearchItem=true; + searchId=transfertItemList.at(currentIndexSearch).id; + return currentIndexSearch; + } + if(currentIndexSearch==0) + currentIndexSearch=loop_size-1; + else + currentIndexSearch--; + index_for_loop++; + } + haveSearchItem=false; + return -1; +} + +void TransferModel::setFileProgression(std::vector<Ultracopier::ProgressionItem> &progressionList) +{ + loop_size=progressionList.size(); + index_for_loop=0; + while(index_for_loop<loop_size) + { + if(internalRunningOperation.find(progressionList.at(index_for_loop).id)!=internalRunningOperation.cend()) + { + internalRunningOperation[progressionList.at(index_for_loop).id].generalData.size=progressionList.at(index_for_loop).total; + internalRunningOperation[progressionList.at(index_for_loop).id].currentReadProgression=progressionList.at(index_for_loop).currentRead; + internalRunningOperation[progressionList.at(index_for_loop).id].currentWriteProgression=progressionList.at(index_for_loop).currentWrite; + #ifdef ULTRACOPIER_PLUGIN_DEBUG + progressionList.erase(progressionList.cbegin()+index_for_loop); + index_for_loop--; + loop_size--; + #endif + } + index_for_loop++; + } +} + +TransferModel::currentTransfertItem TransferModel::getCurrentTransfertItem() const +{ + currentTransfertItem returnItem; + returnItem.progressBar_read=-1; + returnItem.progressBar_write=0; + returnItem.haveItem=startId.size()>0; + if(returnItem.haveItem) + { + if(internalRunningOperation.find(*startId.cbegin())==internalRunningOperation.cend()) + { + returnItem.haveItem=false; + return returnItem; + } + const ItemOfCopyListWithMoreInformations &itemTransfer=internalRunningOperation.at(*startId.cbegin()); + returnItem.from=itemTransfer.generalData.sourceFullPath; + returnItem.to=itemTransfer.generalData.destinationFullPath; + returnItem.current_file=itemTransfer.generalData.destinationFileName+", "+facilityEngine->sizeToString(itemTransfer.generalData.size); + returnItem.id=itemTransfer.generalData.id; + switch(itemTransfer.actionType) + { + case Ultracopier::CustomOperation: + if(!itemTransfer.custom_with_progression) + returnItem.progressBar_read=-1; + else + { + if(itemTransfer.generalData.size>0) + { + returnItem.progressBar_read=((double)itemTransfer.currentReadProgression/itemTransfer.generalData.size)*65535; + returnItem.progressBar_write=((double)itemTransfer.currentWriteProgression/itemTransfer.generalData.size)*65535; + } + else + returnItem.progressBar_read=-1; + } + break; + case Ultracopier::Transfer: + if(itemTransfer.generalData.size>0) + { + returnItem.progressBar_read=((double)itemTransfer.currentReadProgression/itemTransfer.generalData.size)*65535; + returnItem.progressBar_write=((double)itemTransfer.currentWriteProgression/itemTransfer.generalData.size)*65535; + } + else + { + returnItem.progressBar_read=0; + returnItem.progressBar_write=0; + } + break; + //should never pass here + case Ultracopier::PostOperation: + ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Warning,QStringLiteral("wrong action type for file %1: actionType: %2").arg(itemTransfer.generalData.id).arg(itemTransfer.actionType).toStdString()); + returnItem.progressBar_read=65535; + returnItem.progressBar_write=65535; + break; + //should pass here if in wait of new name for renaming + case Ultracopier::PreOperation: + //ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Warning,QStringLiteral("wrong action type for file %1: actionType: %2").arg(itemTransfer.generalData.id).arg(itemTransfer.actionType).toStdString()); + returnItem.progressBar_read=0; + returnItem.progressBar_write=0; + break; + default: + returnItem.progressBar_read=0; + returnItem.progressBar_write=0; + ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Warning,QStringLiteral("unknow action type for file %1: actionType: %2").arg(itemTransfer.generalData.id).arg(itemTransfer.actionType).toStdString()); + break; + } + } + else + { + returnItem.haveItem=stopId.size()>0; + if(returnItem.haveItem) + { + if(internalRunningOperation.find(*stopId.cbegin())==internalRunningOperation.cend()) + { + returnItem.haveItem=false; + return returnItem; + } + const ItemOfCopyListWithMoreInformations &itemTransfer=internalRunningOperation.at(*stopId.cbegin()); + returnItem.from=itemTransfer.generalData.sourceFullPath; + returnItem.to=itemTransfer.generalData.destinationFullPath; + returnItem.current_file=itemTransfer.generalData.destinationFileName+", "+facilityEngine->sizeToString(itemTransfer.generalData.size); + returnItem.id=itemTransfer.generalData.id; + switch(itemTransfer.actionType) + { + case Ultracopier::CustomOperation: + if(!itemTransfer.custom_with_progression) + returnItem.progressBar_read=-1; + else + { + if(itemTransfer.generalData.size>0) + { + returnItem.progressBar_read=((double)itemTransfer.currentReadProgression/itemTransfer.generalData.size)*65535; + returnItem.progressBar_write=((double)itemTransfer.currentWriteProgression/itemTransfer.generalData.size)*65535; + } + else + returnItem.progressBar_read=-1; + } + break; + case Ultracopier::Transfer: + if(itemTransfer.generalData.size>0) + { + returnItem.progressBar_read=((double)itemTransfer.currentReadProgression/itemTransfer.generalData.size)*65535; + returnItem.progressBar_write=((double)itemTransfer.currentWriteProgression/itemTransfer.generalData.size)*65535; + } + else + { + returnItem.progressBar_read=0; + returnItem.progressBar_write=0; + } + break; + case Ultracopier::PostOperation: + ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Warning,QStringLiteral("wrong action type for file %1: actionType: %2").arg(itemTransfer.generalData.id).arg(itemTransfer.actionType).toStdString()); + returnItem.progressBar_read=65535; + returnItem.progressBar_write=65535; + break; + //should never pass here + case Ultracopier::PreOperation: + ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Warning,QStringLiteral("wrong action type for file %1: actionType: %2").arg(itemTransfer.generalData.id).arg(itemTransfer.actionType).toStdString()); + returnItem.progressBar_read=0; + returnItem.progressBar_write=0; + break; + default: + returnItem.progressBar_read=65535; + returnItem.progressBar_write=65535; + ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Warning,QStringLiteral("unknow action type for file %1: actionType: %2").arg(itemTransfer.generalData.id).arg(itemTransfer.actionType).toStdString()); + break; + } + } + } + if(returnItem.haveItem && returnItem.progressBar_read!=-1 && returnItem.progressBar_write>returnItem.progressBar_read) + { + int tempVar=returnItem.progressBar_write; + returnItem.progressBar_write=returnItem.progressBar_read; + returnItem.progressBar_read=tempVar; + } + return returnItem; +} |