예제 #1
0
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;
                }
            }
        }
    }
}
예제 #2
0
//----------------------------------------------------------------------------------------
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;
}
예제 #4
0
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;
}
예제 #5
0
//------------------------------------------------------------------------------------
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()));
    }
}
예제 #6
0
//----------------------------------------------------------------------------------------
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);
    }
}
예제 #7
0
//----------------------------------------------------------------------------------------
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));
    }
}