Пример #1
0
//------------------------------------------------------------------------------------
OFS::ofs64 ExtractThread::generateList(OFS::FileList& list)
{
    unsigned int list_max = list.size();
    OFS::ofs64 file_size = 0;
    
    std::string tmpSaveCurrentDir;
    OFS::FileList subList;

    for(unsigned int i = 0;i < list_max;i++)
    {
        list[i].name = currentDir + list[i].name;
        file_size += list[i].file_size;

        if(list[i].flags & OFS::OFS_DIR)
        {
            tmpSaveCurrentDir = currentDir;
            currentDir = list[i].name + "/";

            subList = ofsFile->listFiles(currentDir.c_str());

            file_size += generateList(subList);

            for(unsigned int z = 0;z < subList.size();z++)
                list.push_back(subList[z]);

            currentDir = tmpSaveCurrentDir;
        }
    }

    return file_size;
}
Пример #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);
    }
}
Пример #3
0
//-----------------------------------------------------------------------------
void Ogitors::COFSSceneSerializer::_upgradeOgsceneFileFrom3To4(TiXmlNode* ogsceneRootNode)
{
    TiXmlElement* element = ogsceneRootNode->FirstChildElement();   

    OFS::OfsPtr& mFile = OgitorsRoot::getSingletonPtr()->GetProjectFile();
    OgitorsSystem *mSystem = OgitorsSystem::getSingletonPtr();

    OFS::FileList list;
    mFile->listFilesRecursive("/", list);

    Ogre::StringVector terFiles;

    for( unsigned int i = 0;i < list.size(); i++ )
    {
        if(list[i].flags && OFS::OFS_FILE)
        {
            if(list[i].name.substr(list[i].name.size() - 4, 4) == ".ogt")
            {
                terFiles.push_back( list[i].name );
            }
        }
    }

    if( terFiles.size() > 0 )
    {
        Ogre::SceneManager *pUpgSM = Ogre::Root::getSingletonPtr()->createSceneManager("OctreeSceneManager", "UpgradeSCM");

        for( unsigned int i = 0;i < terFiles.size(); i++ )
        {
            Ogre::String filenameorig = terFiles[i];
            Ogre::String filenamebackup = filenameorig + ".backup";

            mFile->renameFile( filenameorig.c_str(), filenamebackup.c_str() );

            OFS::OFSHANDLE *filebackup = new OFS::OFSHANDLE();
            OFS::OFSHANDLE *fileorig = new OFS::OFSHANDLE();

            mFile->createFile(*fileorig, filenameorig.c_str());
            mFile->openFile(*filebackup, filenamebackup.c_str(), OFS::OFS_READ);

            {
                OgreTerrainConverter conv;

                Ogre::DataStreamPtr stream_in = Ogre::DataStreamPtr(OGRE_NEW OfsDataStream(mFile, filebackup));
                Ogre::DataStreamPtr stream_out = Ogre::DataStreamPtr(OGRE_NEW OfsDataStream(mFile, fileorig));
                Ogre::DataStreamPtr compressStream(OGRE_NEW Ogre::DeflateStream(filenameorig, stream_in));
                Ogre::StreamSerialiser ser_in(compressStream);
                Ogre::StreamSerialiser ser_out(stream_out);

                conv.Upgrade( ser_in, ser_out );
            }
        }

        Ogre::Root::getSingletonPtr()->destroySceneManager(pUpgSM);
    }
}
//----------------------------------------------------------------------------
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;
}
Пример #5
0
//------------------------------------------------------------------------------------
void ExtractThread::extractFiles(QString path, const OFS::FileList& list)
{
    std::ofstream out_handle;
    OFS::OFSHANDLE in_handle;

    unsigned int output_amount = 0;

    mutex.lock();
    currentPos = 0.0f; 
    msgProgress = "";
    mutex.unlock();

    for(unsigned int i = 0;i < list.size();i++)
    {
        if(list[i].flags & OFS::OFS_DIR)
        {
            QString dir_path = path + QString("/") + QString(list[i].name.c_str());
            QDir directory(dir_path);
            directory.mkpath(dir_path);
        }
        else
        {
            std::string file_path = path.toStdString() + std::string("/") + list[i].name;
            std::string file_ofs_path = list[i].name;

            QFileInfo info(QString(file_path.c_str()));
            QDir directory(info.absolutePath());
            directory.mkpath(info.absolutePath());

            mutex.lock();
            msgProgress = file_ofs_path.c_str();
            mutex.unlock();

            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);
                            output_amount += 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;
                            output_amount += MAX_BUFFER_SIZE;
                        }

                        if(mTotalFileSize > 0)
                        {
                            mutex.lock();
                            currentPos = (float)output_amount / (float)mTotalFileSize; 
                            mutex.unlock();
                        }
                    }
                }
                catch(OFS::Exception& e)
                {
                    QMessageBox::information(QApplication::activeWindow(),"Ofs Exception:", tr("Error Extracting File : ") + QString(file_ofs_path.c_str()) + QString("\n") + QString(e.getDescription().c_str()), QMessageBox::Ok);
                }

                out_handle.close();
                ofsFile->closeFile(in_handle);
            }
        }
    }

    mutex.lock();
    currentPos = 1.0f;
    msgProgress = tr("Finished Extracting");
    mutex.unlock();
}
Пример #6
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()));
    }
}
Пример #7
0
//-----------------------------------------------------------------------------------------
bool CTerrainGroupEditor::load(bool async)
{
    if(mLoaded->get())
        return true;

    if(!getParent()->load())
        return false;

    Ogre::ResourceGroupManager *mngr = Ogre::ResourceGroupManager::getSingletonPtr();
    Ogre::String terrainDir = OgitorsRoot::getSingletonPtr()->GetProjectOptions()->TerrainDirectory;
    terrainDir = mOgitorsRoot->GetProjectFile()->getFileSystemName() + "::/" + terrainDir + "/";

    mngr->addResourceLocation(terrainDir + "textures/normalheight", "Ofs", "TerrainGroupNormalHeight");
    mngr->initialiseResourceGroup("TerrainGroupNormalHeight");

    mngr->addResourceLocation(terrainDir + "textures/diffusespecular", "Ofs", "TerrainGroupDiffuseSpecular");
    mngr->initialiseResourceGroup("TerrainGroupDiffuseSpecular");

    mngr->addResourceLocation(terrainDir + "plants", "Ofs", "TerrainGroupPlants");
    mngr->initialiseResourceGroup("TerrainGroupPlants");

    OgitorsRoot::getSingletonPtr()->PrepareTerrainResources();
    OgitorsRoot::getSingletonPtr()->ReloadUserResources();

    mDecalFrustum = OGRE_NEW Ogre::Frustum();
    mDecalNode = getSceneManager()->getRootSceneNode()->createChildSceneNode("OgitorTerrainDecalNode");
    mDecalNode->setPosition(99999, -99999, 99999);
    mDecalNode->attachObject(mDecalFrustum);
    mDecalFrustum->setProjectionType(Ogre::PT_ORTHOGRAPHIC);
    mDecalNode->setOrientation(Ogre::Quaternion(Ogre::Degree(-90), Ogre::Vector3::UNIT_X));
    mDecalFrustum->setFOVy(Ogre::Degree(45));
    mDecalFrustum->setNearClipDistance(10);
    mDecalFrustum->setOrthoWindow(10, 10);
    mDecalFrustum->setVisible(false);
    mDecalTexture = Ogre::TextureManager::getSingletonPtr()->createManual("OgitorDecalTexture", "TerrainResources", 
        Ogre::TEX_TYPE_2D, 256, 256, 1, 1, Ogre::PF_A8R8G8B8, Ogre::TU_DYNAMIC_WRITE_ONLY, this);

    mBrushData = OGRE_ALLOC_T(float, BRUSH_DATA_SIZE * BRUSH_DATA_SIZE, Ogre::MEMCATEGORY_GEOMETRY);

    mTerrainGlobalOptions->setMaxPixelError(mMaxPixelError->get());
    mTerrainGlobalOptions->setCompositeMapSize(mCompositeMapTextureSize->get());
    mTerrainGlobalOptions->setCompositeMapDistance(mCompositeMapDistance->get());
    mTerrainGlobalOptions->setLightMapSize(mLightMapTextureSize->get());
    mTerrainGlobalOptions->setLayerBlendMapSize(mBlendMapTextureSize->get());
    mTerrainGlobalOptions->setUseVertexCompressionWhenAvailable(false);
    mTerrainGlobalOptions->setSkirtSize(mSkirtSize->get());
    mTerrainGlobalOptions->setUseRayBoxDistanceCalculation(mUseRayBoxDistanceCalculation->get());

    if(mMaterialGeneratorType->get() == 1)
    {
        Ogre::TerrainMaterialGeneratorPtr matGenPtr(OGRE_NEW Ogre::TerrainMaterialGeneratorC(this, mDecalFrustum));
        mTerrainGlobalOptions->setDefaultMaterialGenerator(matGenPtr);
        mMaxLayersAllowed = 10;
    }
    else
    {
        Ogre::TerrainMaterialGeneratorPtr matGenPtr(OGRE_NEW Ogre::TerrainMaterialGeneratorB(this, mDecalFrustum));
        mTerrainGlobalOptions->setDefaultMaterialGenerator(matGenPtr);
        mMaxLayersAllowed = 6;
    }

    CSceneManagerEditor *mSceneMgr = static_cast<CSceneManagerEditor*>(mOgitorsRoot->GetSceneManagerEditor());

    if(mSceneMgr->getShadowsEnabled())
    {
        if(mMaterialGeneratorType->get() == 1)
        {
            Ogre::TerrainMaterialGeneratorC::SM2Profile* matProfile = static_cast<Ogre::TerrainMaterialGeneratorC::SM2Profile*>(mTerrainGlobalOptions->getDefaultMaterialGenerator()->getActiveProfile());
            matProfile->setReceiveDynamicShadowsEnabled(true);
            matProfile->setReceiveDynamicShadowsLowLod(false);
            matProfile->setReceiveDynamicShadowsDepth(true);
            matProfile->setReceiveDynamicShadowsPSSM(static_cast<Ogre::PSSMShadowCameraSetup*>(mSceneMgr->getPSSMSetup().get()));
        }
        else
        {
            Ogre::TerrainMaterialGeneratorB::SM2Profile* matProfile = static_cast<Ogre::TerrainMaterialGeneratorB::SM2Profile*>(mTerrainGlobalOptions->getDefaultMaterialGenerator()->getActiveProfile());
            matProfile->setReceiveDynamicShadowsEnabled(true);
            matProfile->setReceiveDynamicShadowsLowLod(false);
            matProfile->setReceiveDynamicShadowsDepth(true);
            matProfile->setReceiveDynamicShadowsPSSM(static_cast<Ogre::PSSMShadowCameraSetup*>(mSceneMgr->getPSSMSetup().get()));
        }
    }

    CONNECT_PROPERTY_MEMFN(mSceneMgr, "shadows::enabled", CTerrainGroupEditor, onShadowsChange, mShadowsConnection[0]);
    CONNECT_PROPERTY_MEMFN(mSceneMgr, "shadows::technique", CTerrainGroupEditor, onShadowsTechniqueChange, mShadowsConnection[1]);

    mHandle = OGRE_NEW Ogre::TerrainGroup(mOgitorsRoot->GetSceneManager(), Ogre::Terrain::ALIGN_X_Z, mMapSize->get(), mWorldSize->get());
    mHandle->setOrigin(Ogre::Vector3::ZERO);
    mHandle->setResourceGroup("TerrainResources");
    mHandle->setFilenameConvention(mPageNamePrefix->get(), "ogt");
    StaticGroupPtr = mHandle;

    mPGHandle = new PagedGeometry(mOgitorsRoot->GetViewport()->getCameraEditor()->getCamera(), mPGPageSize->get());
    mPGHandle->addDetailLevel<GrassPage>(mPGDetailDistance->get());

    //Create a GrassLoader object
    mGrassLoaderHandle = new GrassLoader(mPGHandle);
    mGrassLoaderHandle->setVisibilityFlags(1 << mLayer->get());

    //Assign the "grassLoader" to be used to load geometry for the PagedGrass instance
    mPGHandle->setPageLoader(mGrassLoaderHandle);

    //Supply a height function to GrassLoader so it can calculate grass Y values
    mGrassLoaderHandle->setHeightFunction(OgitorTerrainGroupHeightFunction);

    Ogre::Vector3 vDir;
    Ogre::ColourValue cDiffuse;
    Ogre::SceneManager::MovableObjectIterator mit = mOgitorsRoot->GetSceneManager()->getMovableObjectIterator("Light");
    while(mit.hasMoreElements())
    {
        Ogre::Light *l = static_cast<Ogre::Light*>(mit.getNext());
        if(l->getType() == Ogre::Light::LT_DIRECTIONAL && l->getCastShadows())
        {
            vDir = l->getDerivedDirection();
            cDiffuse = l->getDiffuseColour();
            break;
        }
    }

    mTerrainGlobalOptions->setLightMapDirection(vDir);
    mTerrainGlobalOptions->setCompositeMapAmbient(mOgitorsRoot->GetSceneManager()->getAmbientLight());
    mTerrainGlobalOptions->setCompositeMapDiffuse(cDiffuse);

    terrainDir = OgitorsRoot::getSingletonPtr()->GetProjectOptions()->TerrainDirectory + "/terrain/";

    OFS::FileList TGAList = mOgitorsRoot->GetProjectFile()->listFiles(terrainDir.c_str(), OFS::OFS_FILE);

    for(unsigned int t = 0; t < TGAList.size(); t++)
    {
        int pos = TGAList[t].name.find("_density.tga");
        if(pos > 0)
        {
            Ogre::Image _img;
            Ogre::String sLoc = terrainDir + TGAList[t].name;

            // Block to ensure streams are freed when exiting the block
            {
                OFS::OFSHANDLE *iHandle = new OFS::OFSHANDLE();
                mOgitorsRoot->GetProjectFile()->openFile( *iHandle, sLoc.c_str() );
                Ogre::DataStreamPtr img_stream = Ogre::DataStreamPtr(OGRE_NEW OfsDataStream(mOgitorsRoot->GetProjectFile(), iHandle));
                _img.load(img_stream);
            }

            Ogre::String nLoc = terrainDir + TGAList[t].name.substr(0, pos);
            nLoc += "_density.png";

            OgitorsUtils::SaveImageOfs( _img, nLoc );
            mOgitorsRoot->GetProjectFile()->deleteFile( sLoc.c_str() );
        }
    }

    registerForUpdates();

    mLoaded->set(true);
    return true;
}
Пример #8
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);
    }
}
Пример #9
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));
    }
}