bool VideoIO::saveStream(MeshInterchange& mesh)
{
bool successful = false;
if(MeshInterchange::TEXTURE_FORMAT == mesh.getPreferedFormat())
{
return saveStream(*mesh.getTexture());
}
else if(MeshInterchange::IMAGE_FORMAT == mesh.getPreferedFormat())
{
return saveStream(mesh.getIplImage());
}
return successful;
}
void KarisanStreamerConfig::addStream(StreamConfig *stream)
{
int idx = getNumStreams() ;
_allstreams->insert(pair<int, StreamConfig *>(idx, stream)) ;
saveStream(stream) ;
}
void Message::messageToNetwork(QByteArray &qbaOut) const {
char buffer[8192];
PacketDataStream qdsOut(buffer, 8192);
qdsOut << messageType();
qdsOut << uiSession;
saveStream(qdsOut);
if (qdsOut.undersize() == 0) {
qbaOut = QByteArray(buffer, qdsOut.size());
return;
}
unsigned int size = 8192 + qdsOut.undersize();
STACKVAR(char, b, size);
PacketDataStream pdsResized(b, size);
pdsResized << messageType();
pdsResized << uiSession;
saveStream(pdsResized);
qbaOut = QByteArray(b, pdsResized.size());
}
void KarisanStreamerConfig::updateStream(int idx, string old_name)
{
if(idx >= 0) {
_config_file->EraseSection(old_name.c_str()) ;
StreamConfig *stream = (*_allstreams)[idx] ;
saveStream(stream) ;
update() ;
}
}
///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
//
//
// Build the a dicom dataset that contain the directory's
// information.
//
//
///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
ptr<dataSet> dicomDir::buildDataSet()
{
// Adjust the transfer syntax if it isn't already set
///////////////////////////////////////////////////////////
if(m_pDataSet->getString(0x2, 0, 0x10, 0) == "")
{
m_pDataSet->setString(0x2, 0, 0x10, 0, "1.2.840.10008.1.2.1");
}
// Adjust the version if it isn't already set
///////////////////////////////////////////////////////////
ptr<handlers::dataHandlerRaw> versionHandler(m_pDataSet->getDataHandlerRaw(0x2, 0, 0x1, 0, true, "OB"));
if(versionHandler->getSize() != 2)
{
versionHandler->setSize(2);
versionHandler->setUnsignedLong(0, 0);
versionHandler->setUnsignedLong(1, 1);
}
versionHandler.release();
// Adjust the SOP class UID if it isn't already set
///////////////////////////////////////////////////////////
if(m_pDataSet->getString(0x2, 0, 0x2, 0) == "")
{
m_pDataSet->setString(0x2, 0, 0x2, 0, "1.2.840.10008.1.3.10");
}
// Allocate offset fields
///////////////////////////////////////////////////////////
if(m_pFirstRootRecord != 0)
{
m_pFirstRootRecord->updateOffsets();
}
m_pDataSet->setUnsignedLong(0x0004, 0, 0x1200, 0, 0);
// Save to a null stream in order to update the offsets
///////////////////////////////////////////////////////////
ptr<nullStream> saveStream(new nullStream);
ptr<streamWriter> writer(new streamWriter(saveStream));
ptr<codecs::dicomCodec> writerCodec(new codecs::dicomCodec);
writerCodec->write(writer, m_pDataSet);
// Scan all the records and update the pointers
///////////////////////////////////////////////////////////
if(m_pFirstRootRecord != 0)
{
m_pFirstRootRecord->updateOffsets();
m_pDataSet->setUnsignedLong(0x0004, 0, 0x1200, 0, m_pFirstRootRecord->getRecordDataSet()->getItemOffset());
}
return m_pDataSet;
}
void KarisanStreamerConfig::update()
{
for(map<int, StreamConfig *>::iterator itr = _allstreams->begin() ; itr != _allstreams->end() ; ++itr) {
StreamConfig *strm = (*itr).second ;
saveStream(strm) ;
}
StreamNames *stream_names = new StreamNames();
setStreamNames(stream_names) ;
_config_file->WriteString(DEFAULT_CONFIG_NAME, "Streams", stream_names->CommaText) ;
_config_file->UpdateFile() ;
delete stream_names ;
}
void ConfigFile::save(std::string _filename){
if(_filename == ""){
_filename = filename;
}
std::fstream saveStream(_filename.c_str(), std::ios_base::out|std::ios_base::trunc);
if(!saveStream)
{
throw ConfigFile::Exception("Could not open " + _filename);
}
saveStream << *this;
saveStream.close();
}
bool KarisanStreamerConfig::saveStreamNames()
{
bool ret = true ;
TStringList *stream_names = new TStringList() ;
for(int idx = 0 ; idx < _allstreams->size() ; idx++) {
StreamConfig *stream = (*_allstreams)[idx] ;
stream_names->Add(UnicodeString(stream->getName().c_str())) ;
saveStream(stream) ;
}
_config_file->WriteString(DEFAULT_CONFIG_NAME, "streams", stream_names->CommaText) ;
delete stream_names ;
return(ret) ;
}
void Message::messageToNetwork(PacketDataStream &pds) const {
pds << messageType();
pds << uiSession;
saveStream(pds);
pds.truncate();
}
static glui32 classes_iter(glk_object_save_t **objs)
{
classtable_t *ctab;
classref_t *cref;
glui32 num_classes;
glui32 i,j,ct = 0;
glk_object_save_t *o = NULL, *cur;
window_t *win;
stream_t *str_cur = glk_stream_get_current();
if (!objs)
return 0;
*objs = NULL;
num_classes = gidispatch_count_classes();
ct = 0;
for (i = 0; i < num_classes; i++) { // iterate everything quickly
if ((ctab = classes[i])) {
for (j = 0; j < CLASSHASH_SIZE; j++) {
cref = ctab->bucket[j];
for ( ; cref; cref = cref->next) {
if (i == 0) {
window_t *win = (window_t *)cref->obj;
win->store = 0;
} else if (i == 1) {
stream_t *str = (stream_t *)cref->obj;
str->store = 0;
}
ct++;
}
}
}
}
if (!ct) return 0;
// add entries for windows with styles/pair info + the two general styles
win = NULL;
while ((win = gli_window_iterate_backward(win, NULL))) {
if (win->type == wintype_TextBuffer || win->type == wintype_TextGrid
|| win->type == wintype_Pair || win->type == wintype_Graphics)
ct++;
}
// leave off the last 2 in the event of no styles in use!
if (gli_window_has_stylehints())
ct += 2;
o = glulx_malloc(sizeof(glk_object_save_t) * ct);
if (!o) return 0;
ct = 0;
win = NULL;
while ((win = gli_window_iterate_backward(win, NULL))) {
cur = o + ct;
memset(cur, 0, sizeof(glk_object_save_t));
cur->type = gidisp_Class_Window;
cur->id = classes_find_id_for_object(0, win);
saveWin(win, &cur->obj.win);
//!!!cur->obj.win = *win;
win->store = TRUE;
cur->iscurrent = FALSE; //(win == win_cur);
classes_normalize_pointers(cur);
ct++;
// get stream for window
if ((win->type == wintype_TextBuffer) || (win->type == wintype_TextGrid)) {
// write STREAM chunk
cur = o + ct;
memset(cur, 0, sizeof(glk_object_save_t));
cur->type = gidisp_Class_Stream;
cur->id = classes_find_id_for_object(1, win->str);
//!!!cur->obj.str = *win->str;
saveStream(win->str, &cur->obj.str);
win->str->store = TRUE;
cur->iscurrent = (win->str == str_cur);
classes_normalize_pointers(cur);
ct++;
// write STYLE chunk
cur = o + ct;
memset(cur, 0, sizeof(glk_object_save_t));
cur->type = type_Style;
cur->id = classes_find_id_for_object(0, win);
GLK_STYLE_HINTS hints[style_NUMSTYLES];
gli_window_get_stylehints(win, hints);
memcpy(cur->obj.style, hints, sizeof(GLK_STYLE_HINTS) * style_NUMSTYLES);
ct++;
} else if (win->type == wintype_Pair) {
window_pair_t *pairwin = (window_pair_t*)win->data;
// write PAIR chunk
cur = o + ct;
memset(cur, 0, sizeof(glk_object_save_t));
cur->type = type_Pair;
cur->id = classes_find_id_for_object(0, win);
//!!!cur->obj.pair = *((window_pair_t *)win->data);
saveWinPair(pairwin, &cur->obj.pair);
// set the children to their ids so we can find the pair on reload
cur->obj.pair.child1 = classes_find_id_for_object(gidisp_Class_Window, pairwin->child1);
cur->obj.pair.child2 = classes_find_id_for_object(gidisp_Class_Window, pairwin->child2);
//!!!classes_normalize_pointers(cur);
ct++;
} else if (win->type == wintype_Graphics) {
// write GRAPHICS chunk
cur = o + ct;
memset(cur, 0, sizeof(glk_object_save_t));
cur->type = type_Graphics;
cur->id = classes_find_id_for_object(0, win);
saveWinGfx((window_graphics_t *)win->data, &cur->obj.gfx);
ct++;
}
}
// now, iterate other classes; window streams should have already been accounted for, but we check this
for (i = 0; i < num_classes; i++) {
if ((ctab = classes[i])) {
for (j = 0; j < CLASSHASH_SIZE; j++) {
cref = ctab->bucket[j];
for ( ; cref; cref = cref->next) {
if (i == 0) { // windows
window_t *win = (window_t *)cref->obj;
if (!win->store) {
cur = o + ct;
memset(cur, 0, sizeof(glk_object_save_t));
cur->type = i;
cur->id = cref->id;
}
} else {
if (i == 1) { // streams
stream_t *str = (stream_t *)cref->obj;
if (!str->store) {
cur = o + ct;
memset(cur, 0, sizeof(glk_object_save_t));
cur->type = i;
cur->id = cref->id;
//!!!cur->obj.str = *str;
saveStream(str, &cur->obj.str);
cur->iscurrent = (str == str_cur);
classes_normalize_pointers(cur);
ct++;
}
} else if (i == 2) {
fileref_t *fref = (fileref_t *)cref->obj;
cur = o + ct;
memset(cur, 0, sizeof(glk_object_save_t));
cur->type = i;
cur->id = cref->id;
//!!!cur->obj.fref = *fref;
saveFRef(fref, &cur->obj.fref);
classes_normalize_pointers(cur);
ct++;
} else if (i == 3) { // won't happen here
;
}
}
}
}
}
}
// 2 general styles
if (gli_window_has_stylehints()) {
GLK_STYLE_HINTS hints[style_NUMSTYLES];
cur = o + ct;
memset(cur, 0, sizeof(glk_object_save_t));
cur->type = type_Style;
cur->id = STYLEHINT_TEXT_BUFFER;
gli_window_get_stylehints((winid_t)STYLEHINT_TEXT_BUFFER, hints);
memcpy(cur->obj.style, hints, sizeof(GLK_STYLE_HINTS) * style_NUMSTYLES);
ct++;
cur = o + ct;
memset(cur, 0, sizeof(glk_object_save_t));
cur->type = type_Style;
cur->id = STYLEHINT_TEXT_GRID;
gli_window_get_stylehints((winid_t)STYLEHINT_TEXT_GRID, hints);
memcpy(cur->obj.style, hints, sizeof(GLK_STYLE_HINTS) * style_NUMSTYLES);
ct++;
}
*objs = o;
return ct;
}
bool ResourceDock::addNew(Kite::RTypes Type, const QString &Name, bool AskName){
// check name
if (!AskName) {
if (resMap.find(Name) != resMap.end()) {
return false;
}
}
// find category and format
auto pitem = resTree->findItems(Kite::getRTypesName(Type).c_str(), Qt::MatchFlag::MatchRecursive);
auto frmt = resInfoMap.find((size_t)Type)->resFI.first().first;
QString text = Name;
frmnewres *form = nullptr;
QStringList slist;
// shaders have severeal types(vert, frag, geo)
if (Type == Kite::RTypes::Shader) {
slist.push_back("Vertex");
slist.push_back("Fragment");
slist.push_back("Geometry");
form = new frmnewres(slist, this);
// single types resources
} else {
form = new frmnewres(slist, this);
}
while(AskName) {
// show form
form->exec();
// cancel pressed
if (!form->isOk()) {
return false;
}
text = form->getName();
// shader types
if (Type == Kite::RTypes::Shader) {
if (form->getType() == "Vertex") { frmt = ".vert"; }
if (form->getType() == "Fragment") { frmt = ".frag"; }
if (form->getType() == "Geometry") { frmt = ".geom"; }
}
// available name
if (resMap.find(text + frmt) != resMap.end()) {
QMessageBox msg;
msg.setWindowTitle("Message");
msg.setText("this name is already exist!");
msg.exec();
continue;
}
// file validation
QFile file(resDir + text + frmt);
if (file.exists()) {
auto ret = QMessageBox::question(this, "Message",
"this name is exists in the current resources directory.\ndo you want to replace it?",
QMessageBox::Yes | QMessageBox::No,
QMessageBox::No);
if (ret == QMessageBox::StandardButton::No) {
file.close();
continue;
}
}
if (!file.open(QIODevice::ReadWrite)) {
QMessageBox msg;
msg.setWindowTitle("Message");
msg.setText("cant create file in the resource directory.");
msg.exec();
file.close();
continue;
}
file.close();
// ok pressed
if (form->isOk()) {
text = QFileInfo(file.fileName()).fileName();
break;
}
}
delete form;
// create new res
Kite::KResourceManager rman;
auto newres = rman.createOnFly(Type, text.toStdString());
if (newres == nullptr) {
QMessageBox msg;
msg.setWindowTitle("Message");
msg.setText("resource create module return nullptr!\nresource type: " + QString(Kite::getRTypesName(Type).c_str()));
msg.exec();
return false;
}
// save it to the hard disk
Kite::KFOStream fstream;
if (!newres->saveStream(fstream, resDir.toStdString() + text.toStdString())) {
QMessageBox msg;
msg.setWindowTitle("Message");
msg.setText("cant create resource file.!\nresource type: " + QString(Kite::getRTypesName(Type).c_str()));
msg.exec();
delete newres;
return false;
}
delete newres;
// add to tree
auto item = new QTreeWidgetItem(pitem.first());
item->setText(0, text);
// add to map
resMap.insert(text, qMakePair(resDir + text, Type));
emit(resAdded(text, Type));
return true;
}
void Net::saveToFile(const char * file_name) {
//printf("save to %s\n", file_name);
ofstream saveStream(file_name, ios::out | ios::binary);
save(saveStream);
}
