bool EventRecorder::mouseClick(button b, state s, modifier m, int x, int y) { if (isRecording) { recordedEvents.push_back(Event(Event::MOUSE, (int) m, (int) b, (int) s, x, y)); saveEvents(); } else if (isPlaying) { return true; } return next != NULL && next->mouseClick(b, s, m, x, y); }
bool EventsModel::deleteEvent(const QString& eventName) { if (!m_eventNames.contains(eventName)) { return false; } auto eventIndex = m_eventNames.indexOf(eventName); beginRemoveRows(QModelIndex(), eventIndex, eventIndex); m_eventNames.removeAt(eventIndex); m_events.remove(eventName); endRemoveRows(); saveEvents(); return true; }
bool EventRecorder::keyTyped(unsigned char c, modifier m, int x, int y) { if (c == 'p') { isPlaying = ! isPlaying; return true; } if (isRecording) { recordedEvents.push_back(Event(Event::KEYBOARD, (int) m, c, x, y, 0)); saveEvents(); if (c == 27) { specialKey(KEY_F12, m, x, y); } } else if (isPlaying) { if (c == 27) { ::exit(0); } return true; } return next != NULL && next->keyTyped(c, m, x, y); }
bool EventsModel::addOrEditEvent(const QString& eventName, const QDate& startDate, const QDate& endDate) { if (startDate > endDate ) { return false; } if (m_eventNames.contains(eventName)) { m_events[eventName] = QPair<QDate,QDate>(startDate, endDate); auto row = m_eventNames.indexOf(eventName); dataChanged(index(row), index(row)); } else { beginInsertRows(QModelIndex(), rowCount(), rowCount()); m_eventNames.append(eventName); m_events.insert(eventName, QPair<QDate,QDate>(startDate, endDate)); endInsertRows(); } saveEvents(); return true; }
// --- void VSWContentPrjSaver::saveProject (VSWContentProjectPt cntPrj, const std::string& fName, QBOOLEAN saveAll) { #ifdef __DEBUGSYSTEM __KEEPENTRYSIMPLETRACE #endif // Gets the real name of the file... // Initialy it is the name received as parameter, // but it is null, it will be the name keeped // into the aditional data of the content project object. // if that data does not exist, it will be not possible to open the file // and an exception will be thrown. // The method can be used to save an to save as a content project. std::string fileName = fName; if (fName == std::string (__NULL_STRING__)) if (cntPrj -> _aditionalData.exists (std::string (__GENVALUE_DESCRIPTORPATH__))) fileName = cntPrj -> _aditionalData.getStr (std::string (__GENVALUE_DESCRIPTORPATH__)) -> value ().asString (); else throw VSWContentSaverError (__DATAEXCEP (_IMPOSIBLEOPENAFILE_TXTERROR_)); // Extract the location path of the reproduction project description file... std::string pathForFile = onlyPath (fileName); // Open the file. // If not an exception will be thrown... std::ofstream file; std::string txtToSave (__NULL_STRING__); file.open (fileName.c_str ()); if (!file) throw VSWContentSaverError (__DATAEXCEP (_IMPOSIBLEOPENAFILE_TXTERROR_)); // Save the contents, schedulings, and sequences, // and create the list of them for this file. try { // Gets the docType tag, only if exists... std::string docType (__NULL_STRING__); if (cntPrj -> _aditionalData.exists (std::string (__GENVALUE_DOCTYPENAME__))) docType = std::string ("<!DOCTYPE ") + std::string (cntPrj -> _aditionalData.getStr (std::string (__GENVALUE_DOCTYPENAME__)) -> value ().asString ()) + std::string (" SYSTEM \"") + relPathFor (cntPrj -> _aditionalData.getStr (std::string (__GENVALUE_DOCTYPEDTD__)) -> value ().asString (), pathForFile) + std::string ("\">\n"); txtToSave += std::string ("\t<") + std::string (__ELEMENTSXML_TAGNAME__) + std::string (">\n"); txtToSave += saveContents (cntPrj, pathForFile, saveAll); txtToSave += saveSequences (cntPrj, pathForFile, saveAll); txtToSave += saveSchedulings (cntPrj, pathForFile, saveAll); txtToSave += saveEvents (cntPrj); txtToSave += std::string ("\t</") + std::string (__ELEMENTSXML_TAGNAME__) + std::string (">\n"); txtToSave = // Saves the header, and the paths... std::string (__HEADERXML_TAGNAME__) + docType + std::string ("<") + std::string (__CONTENTPROJECTXML_TAGNAME__) + std::string (" name=\"") + cntPrj -> name () + std::string ("\">\n") + std::string ("\t<") + std::string (__PRJPATHXML_TAGNAME__) + std::string (">\n") + extractPathsFrom (cntPrj, pathForFile) + std::string ("\t</") + std::string (__PRJPATHXML_TAGNAME__) + std::string (">\n") + txtToSave + std::string ("</") + std::string (__CONTENTPROJECTXML_TAGNAME__) + std::string (">\n"); } catch (CMTYException& excep) { throw VSWContentSaverError (excep, /* more deep in the history */ __DATAEXCEP (_IMPOSIBLETOSAVEFILE_TXTERROR_)); } // Save the content... file << txtToSave; file.close (); // ...and finaly close the file. #ifdef __DEBUGSYSTEM __KEEPEXITSIMPLETRACE #endif }
// This runs automatically when application is shutting down. void Calendar::closeEvent(QCloseEvent *event) { saveEvents(); }
/** The main function for the background thread * * Loops until the forground thread requests it to stop. Reads data from the *network, * parses it and stores the resulting events (and other metadata) in a temporary * workspace. */ void ISISLiveEventDataListener::run() { try { if (!m_isConnected) // sanity check { throw std::runtime_error(std::string("No connection to the DAE.")); } TCPStreamEventDataNeutron events; while (!m_stopThread) { // get the header with the type of the packet Receive(events.head, "Events header", "Corrupt stream - you should reconnect."); if (!(events.head.type == TCPStreamEventHeader::Neutron)) { // don't know what to do with it - stop throw std::runtime_error("Unknown packet type."); } CollectJunk(events.head); // get the header with the sream size Receive(events.head_n, "Neutrons header", "Corrupt stream - you should reconnect."); CollectJunk(events.head_n); // absolute pulse (frame) time Mantid::Kernel::DateAndTime pulseTime = m_startTime + static_cast<double>(events.head_n.frame_time_zero); // Save the pulse charge in the logs double protons = static_cast<double>(events.head_n.protons); m_eventBuffer[0] ->mutableRun() .getTimeSeriesProperty<double>(PROTON_CHARGE_PROPERTY) ->addValue(pulseTime, protons); events.data.resize(events.head_n.nevents); uint32_t nread = 0; // receive the events while (nread < events.head_n.nevents) { int ntoread = m_socket.available() / static_cast<int>(sizeof(TCPStreamEventNeutron)); if (ntoread > static_cast<int>(events.head_n.nevents - nread)) { ntoread = static_cast<int>(events.head_n.nevents - nread); } if (ntoread > 0) { m_socket.receiveBytes( &(events.data[nread]), ntoread * static_cast<int>(sizeof(TCPStreamEventNeutron))); nread += ntoread; } else { Poco::Thread::sleep(RECV_WAIT); } } if (!events.isValid()) { throw std::runtime_error("corrupt stream - you should reconnect"); } // store the events saveEvents(events.data, pulseTime, events.head_n.period); } } catch (std::runtime_error & e) { // exception handler for generic runtime exceptions g_log.error() << "Caught a runtime exception." << std::endl << "Exception message: " << e.what() << std::endl; m_isConnected = false; m_backgroundException = boost::make_shared<std::runtime_error>(e); } catch (std::invalid_argument & e) { // TimeSeriesProperty (and possibly some other things) can // can throw these errors g_log.error() << "Caught an invalid argument exception." << std::endl << "Exception message: " << e.what() << std::endl; m_isConnected = false; std::string newMsg( "Invalid argument exception thrown from the background thread: "); newMsg += e.what(); m_backgroundException = boost::make_shared<std::runtime_error>(newMsg); } catch (...) { // Default exception handler g_log.error() << "Uncaught exception in ISISLiveEventDataListener network " "read thread." << std::endl; m_isConnected = false; m_backgroundException = boost::shared_ptr<std::runtime_error>( new std::runtime_error("Unknown error in backgound thread")); } }
bool EventRecorder::specialKey(key k, modifier m, int x, int y) { if (isRecording) { if (k == KEY_F12) { char stime[256]; Timer::getDateTimeString(stime, 256); char name[256]; sprintf(name, "record.%s.dat", stime); ofstream out(name, ofstream::binary); int n = recordedEvents.size(); out.write((char*) &n, sizeof(int)); for (int i = 0; i < n; ++i) { Event e = recordedEvents[i]; out.write((char*) &e, sizeof(Event)); } out.close(); isRecording = false; return true; } else { recordedEvents.push_back(Event(Event::SPECIAL, (int) m, (int) k, x, y, 0)); saveEvents(); } } else if (isPlaying) { return true; } if (k == KEY_F11) { if (recordedEvents.empty() && eventFile != NULL) { ifstream in(eventFile, ifstream::binary); int n; in.read((char*) &n, sizeof(int)); for (int i = 0; i < n; ++i) { Event e; in.read((char*) &e, sizeof(Event)); recordedEvents.push_back(e); } in.close(); getRecorded()->saveState(); } if (!recordedEvents.empty()) { getRecorded()->restoreState(); lastPlayed = 0; savedX = -cursW - 1; savedY = -cursH - 1; isPlaying = true; saveVideo = (m & SHIFT) != 0; lastSavedEvent = -1; lastSavedFrame = 0; if ((m & CTRL) != 0 && (m & SHIFT) == 0) { // quit after replay recordedEvents.push_back(Event(0.0, 0.0, 0.0)); recordedEvents.push_back(Event(Event::KEYBOARD, 0, 27, 0, 0, 0)); } } return true; } if (k == KEY_F12) { getRecorded()->saveState(); recordedEvents.clear(); isRecording = true; return true; } return next != NULL && next->specialKey(k, m, x, y); }