void ModularZoneFactory::loadZoneTemplates(void)
{
mZoneTemplates.clear();
if(OgitorsRoot::getSingletonPtr()->IsSceneLoaded())
{
//scene is loaded, we can get the project directories
//parse all the .zone files from the project directory
//if I had a custom zone resmanager I could get them this way
//pList = Ogre::ResourceGroupManager::getSingleton().findResourceNames(PROJECT_RESOURCE_GROUP,"*.zone",false);
//maybe TODO: create .zone resourcemanager
//Because my.zone files are not a resource I have to manaully get them:
OFS::OfsPtr& ofsFile = OgitorsRoot::getSingletonPtr()->GetProjectFile();
OFS::FileList list;
ofsFile->listFilesRecursive("/", list);
//get rid of everthing except .zone files
list.erase(std::remove_if(list.begin(),list.end(),not_a_zonefile),list.end());
int key = 0;
OFS::FileList::iterator zonefile;
for(zonefile = list.begin();zonefile!=list.end();++zonefile)
{
//load the .zone XML file and get the zone info
//.
ZoneInfo zone = this->_loadZoneDescription((*zonefile).name);
if(!zone.mName.empty())
{
//make sure dependencies are available
bool resources = false;
//mesh:
resources = Ogre::ResourceGroupManager::getSingletonPtr()->resourceExistsInAnyGroup(zone.mMesh);
if(resources)
{
//add to map
mZoneTemplates.insert(ZoneInfoMap::value_type(key,zone));
++key;
}
}
}
}
}
//----------------------------------------------------------------------------------------
void OfsTreeWidget::fillTree(QTreeWidgetItem *pItem, std::string path)
{
OFS::FileList list = mFile->listFiles(path.c_str(), OFS::OFS_DIR);
std::sort(list.begin(), list.end(), OFS::FileEntry::Compare);
for(unsigned int i = 0;i < list.size();i++)
{
Ogre::String name = list[i].name;
QTreeWidgetItem* item = new QTreeWidgetItem((QTreeWidget*)0, QStringList(QString(name.c_str())));
item->setIcon(0, mOgitorMainWindow->mIconProvider.icon(QFileIconProvider::Folder));
item->setTextColor(0, Qt::blue);
std::string fullpath = path + name + "/";
item->setWhatsThis(0, QString(fullpath.c_str()));
if(mCapabilities & CAP_SHOW_COLORS)
{
bool isReadOnly = (list[i].flags & OFS::OFS_READONLY) > 0;
bool isHidden = (list[i].flags & OFS::OFS_HIDDEN) > 0;
QColor textColor = Qt::black;
if(isReadOnly && isHidden)
textColor = QColor(255, 210, 210);
else if(isReadOnly)
textColor = QColor(255, 0, 0);
else if(isHidden)
textColor = QColor(210, 210, 210);
if(list[i].flags & OFS::OFS_LINK)
textColor.setBlue(255);
item->setTextColor(0, textColor);
}
pItem->addChild(item);
mItemMap.insert(NameTreeWidgetMap::value_type(fullpath, item));
fillTree(item, fullpath);
}
if(path != "/" && list.size() == 0)
{
QTreeWidgetItem* item = new QTreeWidgetItem((QTreeWidget*)0, QStringList(QString(".")));
item->setTextColor(0, Qt::black);
item->setWhatsThis(0, QString(path.c_str()));
pItem->addChild(item);
}
}
//----------------------------------------------------------------------------
void extractOFS(Ogre::String path)
{
unsigned int MAX_BUFFER_SIZE = 16 * 1024 * 1024;
char *tmp_buffer = new char[MAX_BUFFER_SIZE];
OFS::OfsPtr& ofsFile = OgitorsRoot::getSingletonPtr()->GetProjectFile();
OFS::FileList list;
ofsFile->listFilesRecursive("/", list);
std::sort(list.begin(), list.end(), OFS::FileEntry::Compare);
std::ofstream out_handle;
OFS::OFSHANDLE in_handle;
for(unsigned int i = 0; i < list.size(); i++)
{
std::string file_path = path + list[i].name;
if(list[i].flags & OFS::OFS_DIR)
{
OgitorsSystem::getSingletonPtr()->MakeDirectory(file_path);
}
else
{
std::string file_ofs_path = list[i].name;
out_handle.open(file_path.c_str(), std::ofstream::out | std::ofstream::binary);
if(out_handle.is_open())
{
try
{
OFS::OfsResult ret = ofsFile->openFile(in_handle, file_ofs_path.c_str());
if(ret != OFS::OFS_OK)
{
out_handle.close();
continue;
}
unsigned int total = list[i].file_size;
while(total > 0)
{
if(total < MAX_BUFFER_SIZE)
{
ofsFile->read(in_handle, tmp_buffer, total);
out_handle.write(tmp_buffer, total);
total = 0;
}
else
{
ofsFile->read(in_handle, tmp_buffer, MAX_BUFFER_SIZE);
out_handle.write(tmp_buffer, MAX_BUFFER_SIZE);
total -= MAX_BUFFER_SIZE;
}
}
}
catch(OFS::Exception&)
{
}
out_handle.close();
ofsFile->closeFile(in_handle);
}
}
}
delete [] tmp_buffer;
}
int COFSSceneSerializer::Import(Ogre::String importfile)
{
OgitorsRoot *ogRoot = OgitorsRoot::getSingletonPtr();
OgitorsSystem *mSystem = OgitorsSystem::getSingletonPtr();
OFS::OfsPtr& mFile = OgitorsRoot::getSingletonPtr()->GetProjectFile();
if(importfile == "")
{
UTFStringVector extlist;
extlist.push_back(OTR("Ogitor File System File"));
extlist.push_back("*.ofs");
extlist.push_back(OTR("Ogitor Scene File"));
extlist.push_back("*" + Globals::OGSCENE_FORMAT_EXTENSION);
importfile = mSystem->GetSetting("system", "oldOpenPath", "");
importfile = mSystem->DisplayOpenDialog(OTR("Open"), extlist, importfile);
if(importfile == "")
return SCF_CANCEL;
mSystem->SetSetting("system", "oldOpenPath", importfile);
}
importfile = OgitorsUtils::QualifyPath(importfile);
Ogre::String filePath = OgitorsUtils::ExtractFilePath(importfile);
Ogre::String fileName = OgitorsUtils::ExtractFileName(importfile);
bool testpassed = false;
try
{
std::ofstream test((filePath + "test.dat").c_str());
if(test.is_open())
testpassed = true;
test.close();
mSystem->DeleteFile(filePath + "test.dat");
}
catch(...)
{
testpassed = false;
}
if(!testpassed)
{
mSystem->DisplayMessageDialog("The path is read-only. Ogitor can not work with read-only project paths!", DLGTYPE_OK);
return SCF_CANCEL;
}
Ogre::UTFString loadmsg = "";
int typepos = importfile.find_last_of(".");
if(typepos != -1 && (importfile.substr(typepos, 4) != ".ofs"))
importfile = filePath;
OFS::OfsResult oRet;
if((oRet = mFile.mount(importfile.c_str(), OFS::OFS_MOUNT_OPEN | OFS::OFS_MOUNT_RECOVER)) != OFS::OFS_OK)
{
if(oRet == OFS::OFS_PREVIOUS_VERSION)
{
mSystem->DisplayMessageDialog("The OFS file is a previous version, please use qtOFS to upgrade it to new file version.", DLGTYPE_OK);
}
loadmsg = mSystem->Translate("Please load a Scene File...");
mSystem->UpdateLoadProgress(-1, loadmsg);
return SCF_ERRPARSE;
}
OFS::FileSystemStats fsStats;
mFile->getFileSystemStats(fsStats);
PROJECTOPTIONS *pOpt = ogRoot->GetProjectOptions();
pOpt->CreatedIn = "";
pOpt->ProjectDir = filePath;
typepos = fileName.find_last_of(".");
if(typepos != -1)
fileName.erase(typepos, fileName.length() - typepos);
pOpt->ProjectName = fileName;
fileName += Globals::OGSCENE_FORMAT_EXTENSION;
OFS::ofs64 file_size = 0;
if(mFile->getFileSize(fileName.c_str(), file_size) != OFS::OFS_OK)
{
// OGSCENE file name needs to match OFS container file name. If the later was renamed, we
// need to automatically adapt the OGSCENE file name now.
OFS::FileList files = mFile->listFiles("/", OFS::OFS_FILE);
unsigned int ogsceneFileExtensionLength = strlen(Globals::OGSCENE_FORMAT_EXTENSION.c_str());
for(OFS::FileList::iterator iter = files.begin(); iter != files.end(); iter++)
{
// Filter out too short names
if(iter->name.size() <= ogsceneFileExtensionLength)
continue;
if(stricmp(iter->name.c_str() + (iter->name.size() - (ogsceneFileExtensionLength)), Globals::OGSCENE_FORMAT_EXTENSION.c_str()) == 0)
{
mFile->renameFile(iter->name.c_str(), fileName.c_str());
break;
}
}
if(mFile->getFileSize(fileName.c_str(), file_size) != OFS::OFS_OK)
return SCF_ERRFILE;
}
char *file_data = new char[(unsigned int)file_size + 1];
OFS::OFSHANDLE projHandle;
if(mFile->openFile(projHandle, fileName.c_str(), OFS::OFS_READ) != OFS::OFS_OK)
{
delete [] file_data;
return SCF_ERRFILE;
}
mFile->read(projHandle, file_data, file_size);
mFile->closeFile(projHandle);
TiXmlDocument docImport;
if(!docImport.LoadFromMemory(file_data, file_size))
{
delete [] file_data;
return SCF_ERRFILE;
}
delete [] file_data;
loadmsg = mSystem->Translate("Parsing Scene File");
mSystem->UpdateLoadProgress(1, loadmsg);
TiXmlNode* ogitorSceneNode = 0;
TiXmlNode* projectNode;
TiXmlElement* element = 0;
bool upgradeExecuted = false;
ogitorSceneNode = docImport.FirstChild("OGITORSCENE");
if(!ogitorSceneNode)
return SCF_ERRPARSE;
element = ogitorSceneNode->ToElement();
// Old OGSCENE version check and attempt to fix/update
int version = Ogre::StringConverter::parseInt(ValidAttr(element->Attribute("version"), "0"));
if(Ogre::StringConverter::toString(version) < Globals::OGSCENE_FORMAT_VERSION)
{
mSystem->DisplayMessageDialog(mSystem->Translate("Old OGSCENE file version detected. Ogitor will now attempt to upgrade the format and will also create a backup version of your OFS file."), DLGTYPE_OK);
loadmsg = mSystem->Translate("Upgrading OGSCENE file.");
mSystem->UpdateLoadProgress(10, loadmsg);
if(version == 0)
{
mSystem->DisplayMessageDialog(mSystem->Translate("OGSCENE files contains no version number set and therefore cannot be loaded."), DLGTYPE_OK);
return SCF_ERRPARSE;
}
else if(version == 1)
{
mSystem->DisplayMessageDialog(mSystem->Translate("OGSCENE files with version 1 cannot be upgraded automatically. Please contact the Ogitor team for further details."), DLGTYPE_OK);
return SCF_ERRPARSE;
}
if(version > 1)
{
if((mFile->getFileSystemType() == OFS::OFS_PACKED) && (!mSystem->CopyFile(importfile, importfile + ".backup")))
mSystem->DisplayMessageDialog(mSystem->Translate("Error while trying to create backup file."), DLGTYPE_OK);
}
switch(version)
{
case 2:
_upgradeOgsceneFileFrom2To3(ogitorSceneNode);
_upgradeOgsceneFileFrom3To4(ogitorSceneNode);
break;
case 3:
_upgradeOgsceneFileFrom3To4(ogitorSceneNode);
break;
}
upgradeExecuted = true;
}
projectNode = ogitorSceneNode->FirstChild("PROJECT");
if(projectNode)
{
loadmsg = mSystem->Translate("Parsing project options");
mSystem->UpdateLoadProgress(5, loadmsg);
ogRoot->LoadProjectOptions(projectNode->ToElement());
ogRoot->PrepareProjectResources();
}
element = ogitorSceneNode->FirstChildElement();
loadmsg = mSystem->Translate("Creating scene objects");
mSystem->UpdateLoadProgress(10, loadmsg);
unsigned int obj_count = 0;
Ogre::String objecttype;
OgitorsPropertyValueMap params;
OgitorsPropertyValue tmpPropVal;
Ogre::String objAttValue;
Ogre::String elementName;
TiXmlElement* properties = 0;
Ogre::String attID;
Ogre::String attValue;
CBaseEditor* result = 0;
TiXmlElement* customprop = 0;
Ogre::StringVector invalidEditorTypes;
do
{
// Make sure its NON-ZERO
if(pOpt->ObjectCount)
{
++obj_count;
mSystem->UpdateLoadProgress(10 + ((obj_count * 70) / pOpt->ObjectCount), loadmsg);
}
params.clear();
objAttValue = ValidAttr(element->Attribute("object_id"), "");
if(objAttValue != "")
{
tmpPropVal.propType = PROP_UNSIGNED_INT;
tmpPropVal.val = Ogre::Any(Ogre::StringConverter::parseUnsignedInt(objAttValue));
params.insert(OgitorsPropertyValueMap::value_type("object_id", tmpPropVal));
}
objAttValue = ValidAttr(element->Attribute("parentnode"), "");
if(objAttValue != "")
{
tmpPropVal.propType = PROP_STRING;
tmpPropVal.val = Ogre::Any(objAttValue);
params.insert(OgitorsPropertyValueMap::value_type("parentnode", tmpPropVal));
}
objAttValue = ValidAttr(element->Attribute("name"), "");
if(objAttValue != "")
{
tmpPropVal.propType = PROP_STRING;
tmpPropVal.val = Ogre::Any(objAttValue);
params.insert(OgitorsPropertyValueMap::value_type("name", tmpPropVal));
}
else
continue;
objAttValue = ValidAttr(element->Attribute("typename"), "");
if(objAttValue != "")
{
tmpPropVal.propType = PROP_STRING;
tmpPropVal.val = Ogre::Any(objAttValue);
params.insert(OgitorsPropertyValueMap::value_type("typename", tmpPropVal));
}
else
continue;
properties = element->FirstChildElement();
if(properties)
{
do
{
elementName = properties->Value();
if(elementName != "PROPERTY")
continue;
attID = ValidAttr(properties->Attribute("id"), "");
int attType = Ogre::StringConverter::parseInt(ValidAttr(properties->Attribute("type"), ""));
attValue = ValidAttr(properties->Attribute("value"), "");
params.insert(OgitorsPropertyValueMap::value_type(attID, OgitorsPropertyValue::createFromString((OgitorsPropertyType)attType, attValue)));
} while(properties = properties->NextSiblingElement());
}
objecttype = Ogre::any_cast<Ogre::String>(params["typename"].val);
result = ogRoot->CreateEditorObject(0, objecttype, params, false, false);
if(result)
{
customprop = element->FirstChildElement("CUSTOMPROPERTIES");
if(customprop)
{
OgitorsUtils::ReadCustomPropertySet(customprop, result->getCustomProperties());
}
}
else
invalidEditorTypes.push_back(objecttype);
} while(element = element->NextSiblingElement());
// Print out invalid/unsupported editor types (= types where no factory could be found)
if(invalidEditorTypes.size() > 0)
{
std::sort(invalidEditorTypes.begin(), invalidEditorTypes.end());
invalidEditorTypes.erase(std::unique(invalidEditorTypes.begin(), invalidEditorTypes.end()), invalidEditorTypes.end());
Ogre::String invalidTypesResultString;
for(unsigned int i = 0; i < invalidEditorTypes.size(); i++)
{
invalidTypesResultString += invalidEditorTypes.at(i) + "\n";
}
mSystem->DisplayMessageDialog(mSystem->Translate("Could not create objects of types:\n" + invalidTypesResultString), DLGTYPE_OK);
}
//// Save directly after upgrade
//if(upgradeExecuted)
// Export(false, importfile);
ogRoot->AfterLoadScene();
return SCF_OK;
}
//------------------------------------------------------------------------------------
void MainWindow::showFiles()
{
while(mFileListWidget->rowCount() > 0)
mFileListWidget->removeRow(0);
mCurrentFiles.clear();
QIcon folderIcon = mIconProvider.icon(QFileIconProvider::Folder);
if(mOfsFile.valid())
{
OFS::FileList dirs = mOfsFile->listFiles(mCurrentDir.c_str(), OFS::OFS_DIR);
OFS::FileList files = mOfsFile->listFiles(mCurrentDir.c_str(), OFS::OFS_FILE);
std::sort(dirs.begin(), dirs.end(), OFS::FileEntry::Compare);
std::sort(files.begin(), files.end(), OFS::FileEntry::Compare);
int current_row = 0;
if(mCurrentDir.size() > 1)
{
mFileListWidget->insertRow(current_row);
mFileListWidget->setRowHeight(current_row, mRowHeight);
QTableWidgetItem *witem = new QTableWidgetItem(folderIcon, QString(".."));
mFileListWidget->setItem(0, 0, witem);
witem = new QTableWidgetItem("");
mFileListWidget->setItem(current_row, 1, witem);
witem = new QTableWidgetItem(tr("Directory"));
mFileListWidget->setItem(current_row, 2, witem);
witem = new QTableWidgetItem("");
mFileListWidget->setItem(current_row, 3, witem);
witem = new QTableWidgetItem("");
mFileListWidget->setItem(current_row, 4, witem);
current_row++;
OFS::FileEntry updata;
updata.flags = OFS::OFS_DIR;
updata.name = "..";
updata.file_size = 0;
mCurrentFiles.push_back(updata);
}
mDirUpButton->setEnabled(mCurrentDir.size() > 1);
for(unsigned int i = 0;i < dirs.size();i++)
{
mFileListWidget->insertRow(current_row);
mFileListWidget->setRowHeight(current_row, mRowHeight);
bool isReadOnly = (dirs[i].flags & OFS::OFS_READONLY) > 0;
bool isHidden = (dirs[i].flags & OFS::OFS_HIDDEN) > 0;
if(isHidden && (actViewShowHidden->isChecked() == false))
continue;
QColor textColor = Qt::black;
if(isReadOnly && isHidden)
textColor = QColor(255, 210, 210);
else if(isReadOnly)
textColor = QColor(255, 0, 0);
else if(isHidden)
textColor = QColor(210, 210, 210);
QTableWidgetItem *witem = new QTableWidgetItem(folderIcon, QString(dirs[i].name.c_str()));
witem->setTextColor(textColor);
mFileListWidget->setItem(current_row, 0, witem);
witem = new QTableWidgetItem("");
mFileListWidget->setItem(current_row, 1, witem);
witem = new QTableWidgetItem(tr("Directory"));
witem->setTextColor(textColor);
mFileListWidget->setItem(current_row, 2, witem);
witem = new QTableWidgetItem(QDateTime::fromTime_t(dirs[i].create_time).toString());
witem->setTextColor(textColor);
mFileListWidget->setItem(current_row, 3, witem);
witem = new QTableWidgetItem(QString("{ ") + QString(dirs[i].uuid.toString().c_str()) + QString(" }"));
witem->setTextColor(textColor);
mFileListWidget->setItem(current_row, 4, witem);
current_row++;
mCurrentFiles.push_back(dirs[i]);
}
for(unsigned int i = 0;i < files.size();i++)
{
mFileListWidget->insertRow(current_row);
mFileListWidget->setRowHeight(current_row, mRowHeight);
std::string ext_name = files[i].name;
bool isReadOnly = (files[i].flags & OFS::OFS_READONLY) > 0;
bool isHidden = (files[i].flags & OFS::OFS_HIDDEN) > 0;
if(isHidden && (actViewShowHidden->isChecked() == false))
continue;
QColor textColor = Qt::black;
if(isReadOnly && isHidden)
textColor = QColor(255, 210, 210);
else if(isReadOnly)
textColor = QColor(255, 0, 0);
else if(isHidden)
textColor = QColor(210, 210, 210);
QIcon icon = mUnknownFileIcon;
int ext_pos = ext_name.find_last_of(".");
if(ext_pos > 0)
{
ext_name.erase(0, ext_pos);
FileIconMap::iterator it = mFileIconMap.find(ext_name);
if(it == mFileIconMap.end())
{
std::string filename = "./qtOfs_icontest";
filename += ext_name;
std::fstream stream;
stream.open(filename.c_str(), std::fstream::in | std::fstream::out | std::fstream::binary | std::fstream::trunc);
stream.close();
QFileInfo info(QString(filename.c_str()));
icon = mIconProvider.icon(info);
if(icon.isNull())
icon = mUnknownFileIcon;
mFileIconMap.insert(FileIconMap::value_type(ext_name, icon));
QFile::remove(QString(filename.c_str()));
}
else
icon = it->second;
}
QTableWidgetItem *witem = new QTableWidgetItem(icon, QString(files[i].name.c_str()));
witem->setTextColor(textColor);
mFileListWidget->setItem(current_row, 0, witem);
unsigned int file_size = files[i].file_size;
QString size_str = QString("%1").arg(file_size);
int len = size_str.length();
int runs = (len - 1) / 3;
for(int j = 0;j < runs;j++)
{
size_str.insert(len - (3 * j) - 3, '.');
}
witem = new QTableWidgetItem(size_str + QString(" "));
witem->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter);
witem->setTextColor(textColor);
mFileListWidget->setItem(current_row, 1, witem);
witem = new QTableWidgetItem(tr("File"));
witem->setTextColor(textColor);
mFileListWidget->setItem(current_row, 2, witem);
witem = new QTableWidgetItem(QDateTime::fromTime_t(files[i].create_time).toString());
witem->setTextColor(textColor);
mFileListWidget->setItem(current_row, 3, witem);
witem = new QTableWidgetItem(QString("{ ") + QString(files[i].uuid.toString().c_str()) + QString(" }"));
witem->setTextColor(textColor);
mFileListWidget->setItem(current_row, 4, witem);
++current_row;
mCurrentFiles.push_back(files[i]);
}
if(mCurrentDir.size() > 1)
--current_row;
mTotalEntriesLabel->setText(tr("Total Entries : ") + QString("%1").arg(current_row));
mDirectoryDisplay->setText(QString(mCurrentDir.c_str()));
}
}
//----------------------------------------------------------------------------------------
void OfsTreeWidget::fillRecycleBin(QTreeWidgetItem *pItem)
{
OFS::FileList list = mFile->listRecycleBinFiles();
if( list.size() > 0 )
pItem->setIcon(0, QIcon(":/icons/recyclebin_full.svg"));
else
pItem->setIcon(0, QIcon(":/icons/recyclebin_empty.svg"));
std::sort(list.begin(), list.end(), OFS::FileEntry::Compare);
for(unsigned int i = 0;i < list.size();i++)
{
Ogre::String name = list[i].name;
Ogre::String ext_name = name;
QIcon icon = mUnknownFileIcon;
if( list[i].flags & OFS::OFS_DIR )
icon = mOgitorMainWindow->mIconProvider.icon(QFileIconProvider::Folder);
else
{
int ext_pos = ext_name.find_last_of(".");
if(ext_pos > 0)
{
ext_name.erase(0, ext_pos);
FileIconMap::iterator it = mOgitorMainWindow->mFileIconMap.find(ext_name);
if(it == mOgitorMainWindow->mFileIconMap.end())
{
std::string filename = "./qtOgitor_icontest";
filename += ext_name;
std::fstream stream;
stream.open(filename.c_str(), std::fstream::in | std::fstream::out | std::fstream::binary | std::fstream::trunc);
stream.close();
QFileInfo info(QString(filename.c_str()));
icon = mOgitorMainWindow->mIconProvider.icon(info);
if(icon.isNull())
icon = mUnknownFileIcon;
mOgitorMainWindow->mFileIconMap.insert(FileIconMap::value_type(ext_name, icon));
QFile::remove(QString(filename.c_str()));
}
else
icon = it->second;
}
}
QTreeWidgetItem* item = new QTreeWidgetItem((QTreeWidget*)0, QStringList(QString(name.c_str())));
item->setIcon(0, icon);
item->setTextColor(0, Qt::black);
item->setWhatsThis(0, QString("%1").arg(list[i].id));
item->setToolTip(0, QString(name.c_str()) + QString(" (%1)").arg(list[i].id));
pItem->addChild(item);
}
}
//----------------------------------------------------------------------------------------
void OfsTreeWidget::fillTreeFiles(QTreeWidgetItem *pItem, std::string path)
{
OFS::FileList list = mFile->listFiles(path.c_str(), OFS::OFS_FILE);
std::sort(list.begin(), list.end(), OFS::FileEntry::Compare);
for(unsigned int i = 0;i < list.size();i++)
{
Ogre::String name = list[i].name;
Ogre::String ext_name = name;
QIcon icon = mUnknownFileIcon;
int ext_pos = ext_name.find_last_of(".");
if(ext_pos > 0)
{
ext_name.erase(0, ext_pos);
FileIconMap::iterator it = mOgitorMainWindow->mFileIconMap.find(ext_name);
if(it == mOgitorMainWindow->mFileIconMap.end())
{
std::string filename = "./qtOgitor_icontest";
filename += ext_name;
std::fstream stream;
stream.open(filename.c_str(), std::fstream::in | std::fstream::out | std::fstream::binary | std::fstream::trunc);
stream.close();
QFileInfo info(QString(filename.c_str()));
icon = mOgitorMainWindow->mIconProvider.icon(info);
if(icon.isNull())
icon = mUnknownFileIcon;
mOgitorMainWindow->mFileIconMap.insert(FileIconMap::value_type(ext_name, icon));
QFile::remove(QString(filename.c_str()));
}
else
icon = it->second;
}
QTreeWidgetItem* item = new QTreeWidgetItem((QTreeWidget*)0, QStringList(QString(name.c_str())));
item->setIcon(0, icon);
item->setTextColor(0, Qt::black);
std::string fullpath = path + name;
item->setWhatsThis(0, QString(fullpath.c_str()));
if(mCapabilities & CAP_SHOW_COLORS)
{
bool isReadOnly = (list[i].flags & OFS::OFS_READONLY) > 0;
bool isHidden = (list[i].flags & OFS::OFS_HIDDEN) > 0;
QColor textColor = Qt::black;
if(isReadOnly && isHidden)
textColor = QColor(255, 210, 210);
else if(isReadOnly)
textColor = QColor(255, 0, 0);
else if(isHidden)
textColor = QColor(210, 210, 210);
if(list[i].flags & OFS::OFS_LINK)
textColor.setBlue(255);
item->setTextColor(0, textColor);
}
pItem->addChild(item);
mItemMap.insert(NameTreeWidgetMap::value_type(fullpath, item));
}
}
