Example #1
0
void ModelViewer::on_treeWidget_itemDoubleClicked(QTreeWidgetItem* item, int) {
	FileItem* f_item = dynamic_cast<FileItem*>(item);
	const FileInfo& finfo = f_item->getFileInfo();

	if (!f_item)
		return;

	if (f_item->isDirectory()) {
#if 0
		FileInfoSeq infos = gFileSystem->getFileInfos(finfo.fullpath, "*.model;*.ase", File::List_sort);
		for (size_t i = 0; i < infos.size(); i++) {
			FileItem* child = new FileItem(item, infos[i]);
//			f_item->addChild(item);
		}
#endif
		ui.treeWidget->expandItem(item);

//		f_item->setExpanded(true);
	} else {
		RenderWorld* world = ui.previewWidget->getRenderWorld();
		if (m_renderModel) {
			world->removeActor(m_renderModel);
			delete m_renderModel;
		}

		m_renderModel = new PhysicsModel(finfo.fullpath);
//		m_renderModel->setAnimation("models/crouch.anim");
		world->addActor(m_renderModel);

		ui.previewWidget->setFocusActor(m_renderModel);
		ui.previewWidget->update();
	}
}
Example #2
0
void ModelViewer::on_modelType_activated(int index) {
#if 0
	FileInfoSeq infos = gFileSystem->getFileInfos("/models", "*.model;*.ase", File::List_sort);

	ui.treeWidget->clear();
	for (size_t i = 0; i < infos.size(); i++) {
		FileItem* item = new FileItem(ui.treeWidget, infos[i]);
	}
#endif
}
Example #3
0
	StringSeq PathUtil::listFileByExts(const String& base, const String& path, const String& exts, uint_t flags) {

		StringSeq strvec;
		FileInfoSeq fileinfos;

		fileinfos = getFileInfos(base, path, exts, flags);
		for (size_t i=0; i<fileinfos.size(); i++) {
			strvec.push_back(fileinfos[i].fullpath);
		}
		return strvec;
	}
Example #4
0
bool
IcePatch2::Patcher::prepare()
{
    _localFiles.clear();

    bool thorough = _thorough;

    if(!thorough)
    {
        try
        {
            loadFileInfoSeq(_dataDir, _localFiles);
        }
        catch(const string& ex)
        {
            thorough = _feedback->noFileSummary(ex);
            if(!thorough)
            {
                return false;
            }
        }
    }
    
    if(thorough)
    {
        if(!_feedback->checksumStart())
        {
            return false;
        }

        PatcherGetFileInfoSeqCB cb(_feedback);
        if(!getFileInfoSeq(_dataDir, 0, &cb, _localFiles))
        {
            return false;
        }

        if(!_feedback->checksumEnd())
        {
            return false;          
        }

        saveFileInfoSeq(_dataDir, _localFiles);
    }

    FileTree0 tree0;
    getFileTree0(_localFiles, tree0);

    if(tree0.checksum != _serverCompress->getChecksum())
    {
        if(!_feedback->fileListStart())
        {
            return false;
        }
        
        ByteSeqSeq checksumSeq = _serverCompress->getChecksumSeq();
        if(checksumSeq.size() != 256)
        {
            throw string("server returned illegal value");
        }
        
        AsyncResultPtr curCB;
        AsyncResultPtr nxtCB;

        for(int node0 = 0; node0 < 256; ++node0)
        {
            if(tree0.nodes[node0].checksum != checksumSeq[node0])
            {
                if(!curCB)
                {
                    assert(!nxtCB);
                    curCB = _serverCompress->begin_getFileInfoSeq(node0);
                }
                else
                {
                    assert(nxtCB);
                    swap(nxtCB, curCB);
                }
                
                int node0Nxt = node0;
                
                do
                {
                    ++node0Nxt;
                }
                while(node0Nxt < 256 && tree0.nodes[node0Nxt].checksum == checksumSeq[node0Nxt]);

                if(node0Nxt < 256)
                {
                    nxtCB = _serverCompress->begin_getFileInfoSeq(node0Nxt);
                }

                FileInfoSeq files = _serverCompress->end_getFileInfoSeq(curCB);
                
                sort(files.begin(), files.end(), FileInfoLess());
                files.erase(unique(files.begin(), files.end(), FileInfoEqual()), files.end());

                //
                // Compute the set of files which were removed.
                //
                set_difference(tree0.nodes[node0].files.begin(),
                               tree0.nodes[node0].files.end(),
                               files.begin(),
                               files.end(),
                               back_inserter(_removeFiles),
                               FileInfoWithoutFlagsLess()); // NOTE: We ignore the flags here.

                //
                // Compute the set of files which were updated (either the file contents, flags or both).
                //
                FileInfoSeq updatedFiles;
                updatedFiles.reserve(files.size());
                                    
                set_difference(files.begin(),
                               files.end(),
                               tree0.nodes[node0].files.begin(),
                               tree0.nodes[node0].files.end(),
                               back_inserter(updatedFiles),
                               FileInfoLess());

                //
                // Compute the set of files whose contents was updated.
                //
                FileInfoSeq contentsUpdatedFiles;
                contentsUpdatedFiles.reserve(files.size());

                set_difference(files.begin(),
                               files.end(),
                               tree0.nodes[node0].files.begin(),
                               tree0.nodes[node0].files.end(),
                               back_inserter(contentsUpdatedFiles),
                               FileInfoWithoutFlagsLess()); // NOTE: We ignore the flags here.
                copy(contentsUpdatedFiles.begin(), contentsUpdatedFiles.end(), back_inserter(_updateFiles));

                //
                // Compute the set of files whose flags were updated.
                //
                set_difference(updatedFiles.begin(),
                               updatedFiles.end(),
                               contentsUpdatedFiles.begin(),
                               contentsUpdatedFiles.end(),
                               back_inserter(_updateFlags),
                               FileInfoLess());
            }

            if(!_feedback->fileListProgress((node0 + 1) * 100 / 256))
            {
                return false;
            }
        }

        if(!_feedback->fileListEnd())
        {
            return false;
        }
    }    

    sort(_removeFiles.begin(), _removeFiles.end(), FileInfoLess());
    sort(_updateFiles.begin(), _updateFiles.end(), FileInfoLess());
    sort(_updateFlags.begin(), _updateFlags.end(), FileInfoLess());
                
    string pathLog = simplify(_dataDir + '/' + logFile);
    _log = IceUtilInternal::fopen(pathLog, "w");
    if(!_log)
    {
        throw "cannot open `" + pathLog + "' for writing:\n" + IceUtilInternal::lastErrorToString();
    }

    return true;
}