static void
update_IrPoints( irInfo* irs)
{
int cnt;
Point rpos;
float rrot;
float distanceToObstacle = ROB_RADIUS + IR_THRESHOLD_DIST;
updateActualPosition( &rpos, &rrot, DONT_CONSIDER_DIRECTION);
for ( cnt = 0; cnt < irs->numberOfActivatedIrs; cnt++) {
float angle = rrot + irs->angle[cnt];
Ir_Obstacle_Points.points[cnt].x =
rpos.x + (fcos( angle) * distanceToObstacle);
Ir_Obstacle_Points.points[cnt].y =
rpos.y + (fsin( angle) * distanceToObstacle);
}
if ( irs->numberOfActivatedIrs > 0)
setStartTime( IR_TIMER);
Ir_Obstacle_Points.no_of_points = irs->numberOfActivatedIrs;
}
std::unique_ptr<Path> DirectTargetPathPlanner::run(PlanRequest& planRequest) {
const MotionInstant& startInstant = planRequest.start;
const auto& motionConstraints = planRequest.constraints.mot;
const Geometry2d::ShapeSet& obstacles = planRequest.obstacles;
std::unique_ptr<Path>& prevPath = planRequest.prevPath;
const Planning::DirectPathTargetCommand& command =
dynamic_cast<const Planning::DirectPathTargetCommand&>(
*planRequest.motionCommand);
if (shouldReplan(planRequest)) {
Geometry2d::Point endTarget = command.pathGoal.pos;
const auto direction = (endTarget - startInstant.pos).normalized();
float endSpeed = command.pathGoal.vel.mag();
auto path = std::make_unique<TrapezoidalPath>(
startInstant.pos, vectorInDirection(startInstant.vel, direction),
endTarget, vectorInDirection(command.pathGoal.vel, direction),
motionConstraints);
path->setStartTime(RJ::now());
return std::move(path);
} else {
return std::move(prevPath);
}
}
bool ShowFunction::loadXML(QXmlStreamReader &root)
{
if (root.name() != KXMLShowFunction)
{
qWarning() << Q_FUNC_INFO << "ShowFunction node not found";
return false;
}
QXmlStreamAttributes attrs = root.attributes();
if (attrs.hasAttribute(KXMLShowFunctionID))
setFunctionID(attrs.value(KXMLShowFunctionID).toString().toUInt());
if (attrs.hasAttribute(KXMLShowFunctionStartTime))
setStartTime(attrs.value(KXMLShowFunctionStartTime).toString().toUInt());
if (attrs.hasAttribute(KXMLShowFunctionDuration))
setDuration(attrs.value(KXMLShowFunctionDuration).toString().toUInt());
if (attrs.hasAttribute(KXMLShowFunctionColor))
setColor(QColor(attrs.value(KXMLShowFunctionColor).toString()));
if (attrs.hasAttribute(KXMLShowFunctionLocked))
setLocked(true);
root.skipCurrentElement();
return true;
}
int64_t FPS_Manager::resetTime(const long long& time)
{
//LOG("Warning, FPS timer reset!");
setStartTime(time);
m_frameCount = 0;
return 0;
}
int main(void) {
setEnvironment();
setOutput();
setScoreboard();
while(1) {
setRaceMode();
PLAYER ppp[numOfPlayers];
setPlayer(&ppp, 0, STARTING_POSITION_X, 18, '1', 65, 66, 67, 68);
setPlayer(&ppp, 1, STARTING_POSITION_X, 20, '2', 119, 115, 100, 97);
players = &ppp;
redrawScreen();
splashScreen();
countdown();
setStartTime(&ppp);
char c;
while (!weHaveAWinner(&ppp)) {
c = getc(stdin);
checkMove(c, &ppp);
}
printWins();
checkeredFlag();
waitForEnter();
}
return EXIT_SUCCESS;
}
EPGWidget::EPGWidget( QWidget *parent ) : QWidget( parent )
{
m_rulerWidget = new EPGRuler( this );
m_epgView = new EPGView( this );
m_channelsWidget = new EPGChannels( this, m_epgView );
m_channelsWidget->setMinimumWidth( 100 );
m_epgView->setSizePolicy( QSizePolicy::Expanding, QSizePolicy::Expanding );
setZoom( 1 );
QGridLayout* layout = new QGridLayout( this );
layout->addWidget( m_rulerWidget, 0, 1 );
layout->addWidget( m_channelsWidget, 1, 0 );
layout->addWidget( m_epgView, 1, 1 );
layout->setSpacing( 0 );
setLayout( layout );
connect( m_epgView, SIGNAL( startTimeChanged(QDateTime) ),
m_rulerWidget, SLOT( setStartTime(QDateTime) ) );
connect( m_epgView, SIGNAL( durationChanged(int) ),
m_rulerWidget, SLOT( setDuration(int) ) );
connect( m_epgView->horizontalScrollBar(), SIGNAL( valueChanged(int) ),
m_rulerWidget, SLOT( setOffset(int) ) );
connect( m_epgView->verticalScrollBar(), SIGNAL( valueChanged(int) ),
m_channelsWidget, SLOT( setOffset(int) ) );
connect( m_epgView, SIGNAL( eventFocusedChanged(EPGEvent*)),
this, SIGNAL(itemSelectionChanged(EPGEvent*)) );
}
// root search
void SimplePVSearch::search(Board board) {
prepareToSearch();
setStartTime(getTickCount());
setTimeToStop();
searchScore = idSearch(board);
time = getTickCount()-getStartTime();
}
void QmlProfilerModelManager::load()
{
QString filename = d->fileName;
QFile file(filename);
if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
emit error(tr("Could not open %1 for reading.").arg(filename));
return;
}
// erase current
clear();
setState(QmlProfilerDataState::AcquiringData);
QmlProfilerFileReader reader;
connect(&reader, SIGNAL(error(QString)), this, SIGNAL(error(QString)));
connect(&reader, SIGNAL(rangedEvent(int,int,qint64,qint64,QStringList,QmlDebug::QmlEventLocation,
qint64, qint64, qint64, qint64, qint64)),
this, SLOT(addQmlEvent(int,int,qint64,qint64,QStringList,QmlDebug::QmlEventLocation,
qint64, qint64, qint64, qint64, qint64)));
connect(&reader, SIGNAL(traceStartTime(qint64)), traceTime(), SLOT(setStartTime(qint64)));
connect(&reader, SIGNAL(traceEndTime(qint64)), traceTime(), SLOT(setEndTime(qint64)));
reader.setV8DataModel(d->v8Model);
reader.load(&file);
complete();
}
QList<EventDay *> *TablesWizard::getSchedule()
{
QList<EventDay*>* result = new QList<EventDay*>();
int day = ui->m_dayCount->value();
for(auto key : m_editors.keys())
{
auto value = m_editors.value(key);
auto time = key->time();
value->setData(Qt::DisplayRole,time);
}
for(int i = 0; i < day ; ++i)
{
auto itemStart = ui->tableWidget->item(i,0);
auto itemEnd = ui->tableWidget->item(i,1);
auto event = new EventDay();
event->setId(i);
QTime time1 = itemStart->data(Qt::DisplayRole).toTime();
int time1Min = time1.minute()+time1.hour()*60;
event->setStartTime(time1Min);
QTime time2 = itemEnd->data(Qt::DisplayRole).toTime();
int time2Min = time2.minute()+time2.hour()*60;
event->setEndTime(time2Min);
result->append(event);
}
return result;
}
DivePlannerWidget::DivePlannerWidget(QWidget *parent, Qt::WindowFlags f) : QWidget(parent, f)
{
ui.setupUi(this);
ui.dateEdit->setDisplayFormat(getDateFormat());
ui.tableWidget->setTitle(tr("Dive planner points"));
ui.tableWidget->setModel(DivePlannerPointsModel::instance());
DivePlannerPointsModel::instance()->setRecalc(true);
ui.tableWidget->view()->setItemDelegateForColumn(DivePlannerPointsModel::GAS, new AirTypesDelegate(this));
ui.cylinderTableWidget->setTitle(tr("Available gases"));
ui.cylinderTableWidget->setModel(CylindersModel::instance());
QTableView *view = ui.cylinderTableWidget->view();
view->setColumnHidden(CylindersModel::START, true);
view->setColumnHidden(CylindersModel::END, true);
view->setColumnHidden(CylindersModel::DEPTH, false);
view->setItemDelegateForColumn(CylindersModel::TYPE, new TankInfoDelegate(this));
connect(ui.cylinderTableWidget, SIGNAL(addButtonClicked()), DivePlannerPointsModel::instance(), SLOT(addCylinder_clicked()));
connect(ui.tableWidget, SIGNAL(addButtonClicked()), DivePlannerPointsModel::instance(), SLOT(addStop()));
connect(CylindersModel::instance(), SIGNAL(dataChanged(QModelIndex, QModelIndex)),
GasSelectionModel::instance(), SLOT(repopulate()));
connect(CylindersModel::instance(), SIGNAL(rowsInserted(QModelIndex, int, int)),
GasSelectionModel::instance(), SLOT(repopulate()));
connect(CylindersModel::instance(), SIGNAL(rowsRemoved(QModelIndex, int, int)),
GasSelectionModel::instance(), SLOT(repopulate()));
connect(CylindersModel::instance(), SIGNAL(dataChanged(QModelIndex, QModelIndex)),
plannerModel, SIGNAL(cylinderModelEdited()));
connect(CylindersModel::instance(), SIGNAL(rowsInserted(QModelIndex, int, int)),
plannerModel, SIGNAL(cylinderModelEdited()));
connect(CylindersModel::instance(), SIGNAL(rowsRemoved(QModelIndex, int, int)),
plannerModel, SIGNAL(cylinderModelEdited()));
ui.tableWidget->setBtnToolTip(tr("Add dive data point"));
connect(ui.startTime, SIGNAL(timeChanged(QTime)), plannerModel, SLOT(setStartTime(QTime)));
connect(ui.dateEdit, SIGNAL(dateChanged(QDate)), plannerModel, SLOT(setStartDate(QDate)));
connect(ui.ATMPressure, SIGNAL(valueChanged(int)), this, SLOT(atmPressureChanged(int)));
connect(ui.atmHeight, SIGNAL(valueChanged(int)), this, SLOT(heightChanged(int)));
connect(ui.salinity, SIGNAL(valueChanged(double)), this, SLOT(salinityChanged(double)));
connect(DivePlannerPointsModel::instance(), SIGNAL(startTimeChanged(QDateTime)), this, SLOT(setupStartTime(QDateTime)));
// Creating (and canceling) the plan
replanButton = ui.buttonBox->addButton(tr("Save new"), QDialogButtonBox::ActionRole);
connect(replanButton, SIGNAL(clicked()), plannerModel, SLOT(saveDuplicatePlan()));
connect(ui.buttonBox, SIGNAL(accepted()), plannerModel, SLOT(savePlan()));
connect(ui.buttonBox, SIGNAL(rejected()), plannerModel, SLOT(cancelPlan()));
QShortcut *closeKey = new QShortcut(QKeySequence(Qt::Key_Escape), this);
connect(closeKey, SIGNAL(activated()), plannerModel, SLOT(cancelPlan()));
// This makes shure the spinbox gets a setMinimum(0) on it so we can't have negative time or depth.
ui.tableWidget->view()->setItemDelegateForColumn(DivePlannerPointsModel::DEPTH, new SpinBoxDelegate(0, INT_MAX, 1, this));
ui.tableWidget->view()->setItemDelegateForColumn(DivePlannerPointsModel::RUNTIME, new SpinBoxDelegate(0, INT_MAX, 1, this));
ui.tableWidget->view()->setItemDelegateForColumn(DivePlannerPointsModel::DURATION, new SpinBoxDelegate(0, INT_MAX, 1, this));
ui.tableWidget->view()->setItemDelegateForColumn(DivePlannerPointsModel::CCSETPOINT, new DoubleSpinBoxDelegate(0, 2, 0.1, this));
/* set defaults. */
ui.ATMPressure->setValue(1013);
ui.atmHeight->setValue(0);
setMinimumWidth(0);
setMinimumHeight(0);
}
void LogVariablesWidget::setLogVariableChecked( int pIndex, bool pChecked )
{
mHeaderView->setChecked(pIndex, pChecked);
if ( pChecked )
{
Qt::ItemFlags flags = Qt::ItemIsEditable|Qt::ItemIsSelectable
|Qt::ItemIsUserCheckable|Qt::ItemIsEnabled|Qt::ItemIsDragEnabled|Qt::ItemIsDropEnabled;
ui->logVariableTable->item(pIndex, 0)->setFlags(Qt::ItemIsEnabled);
ui->logVariableTable->item(pIndex, 1)->setFlags(flags);
ui->logVariableTable->item(pIndex, 2)->setFlags(flags);
ui->logVariableTable->item(pIndex, 3)->setFlags(flags);
}
else
{
ui->logVariableTable->item(pIndex, 0)->setFlags(Qt::NoItemFlags);
ui->logVariableTable->item(pIndex, 1)->setFlags(Qt::NoItemFlags);
ui->logVariableTable->item(pIndex, 2)->setFlags(Qt::NoItemFlags);
ui->logVariableTable->item(pIndex, 3)->setFlags(Qt::NoItemFlags);
setFrequency(pIndex, DataRepository::instance()->frequency());
setStartTime(pIndex, 0);
setDuration(pIndex, DataRepository::instance()->duration());
}
QFont font = ui->logVariableTable->item(pIndex, 0)->font();
font.setBold(pChecked);
ui->logVariableTable->item(pIndex, 0)->setFont(font);
ui->logVariableTable->item(pIndex, 1)->setFont(font);
ui->logVariableTable->item(pIndex, 2)->setFont(font);
ui->logVariableTable->item(pIndex, 3)->setFont(font);
}
bool LedCycle::loadEepromDatas()
{
uint8_t tempValue;
time_t tempTime;
uint8_t readValues[8];
for (int i = 0; i < 8; i++) {
tempValue = EEPROM.read(eepromAddress + i);
if (tempValue > 60) {
applyDefaultTime();
return false;
}
readValues[i] = tempValue;
}
setStartTime(hoursToTime_t(readValues[0]) +
minutesToTime_t(readValues[1]));
setFadeInTime(hoursToTime_t(readValues[2]) +
minutesToTime_t(readValues[3]));
setStopTime(hoursToTime_t(readValues[4]) +
minutesToTime_t(readValues[5]));
setFadeOutTime(hoursToTime_t(readValues[6]) +
minutesToTime_t(readValues[7]));
return true;
}
std::unique_ptr<Path> EscapeObstaclesPathPlanner::run(
SinglePlanRequest& planRequest) {
const MotionInstant& startInstant = planRequest.startInstant;
const auto& motionConstraints = planRequest.robotConstraints.mot;
const Geometry2d::ShapeSet& obstacles = planRequest.obstacles;
std::unique_ptr<Path>& prevPath = planRequest.prevPath;
boost::optional<Point> optPrevPt;
if (prevPath) optPrevPt = prevPath->end().motion.pos;
const Point unblocked =
findNonBlockedGoal(startInstant.pos, optPrevPt, obstacles);
// reuse path if there's not a significantly better spot to target
if (prevPath && unblocked == prevPath->end().motion.pos) {
return std::move(prevPath);
}
// TODO(justbuchanan): build a bezier path instead of a trapezoidal one. As
// is, the path isn't dynamically feasible if the robot has any initial
// velocity. We could potentially even use a kinodynamic RRT in
// findNonBlockedGoal() so it takes initial velocity into account
auto path = std::unique_ptr<Path>(
new TrapezoidalPath(startInstant.pos, motionConstraints.maxSpeed,
unblocked, 0, motionConstraints));
path->setStartTime(RJ::timestamp());
return std::move(path);
}
void ExecData::setStartTime(string startTime) {
stringstream ss;
long val = -1;
ss << startTime;
ss >> val;
setStartTime(val);
}
void KDGanttViewEventItem::setLeadTime( const QDateTime& leadTimeStart )
{
if (!myLeadTime) myLeadTime = new QDateTime;
*myLeadTime = leadTimeStart;
if ( startTime() < leadTime() )
setStartTime( leadTimeStart );
else {
updateCanvasItems();
}
}
VTTCue::VTTCue(ScriptExecutionContext& context, const WebVTTCueData& cueData)
: TextTrackCue(context, 0, 0)
{
initialize(context);
setText(cueData.content());
setStartTime(cueData.startTime(), IGNORE_EXCEPTION);
setEndTime(cueData.endTime(), IGNORE_EXCEPTION);
setId(cueData.id());
setCueSettings(cueData.settings());
m_originalStartTime = cueData.originalStartTime();
}
void UIActionFrame::initWithDictionary(cs::CSJsonDictionary *dic)
{
setFrameId(DICTOOL->getIntValue_json(dic, "frameid"));
setStartTime(DICTOOL->getFloatValue_json(dic, "starttime"));
setPosition(ccp(DICTOOL->getFloatValue_json(dic, "positionx"), DICTOOL->getFloatValue_json(dic, "positiony")));
setScaleX(DICTOOL->getFloatValue_json(dic, "scalex"));
setScaleY(DICTOOL->getFloatValue_json(dic, "scaley"));
setRotation(DICTOOL->getFloatValue_json(dic, "rotation"));
setOpacity(DICTOOL->getIntValue_json(dic, "opacity"));
setColor(ccc3(DICTOOL->getIntValue_json(dic, "colorr"), DICTOOL->getIntValue_json(dic, "colorg"), DICTOOL->getIntValue_json(dic, "colorb")));
}
int EventEditor::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QObject::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 11)
qt_static_metacall(this, _c, _id, _a);
_id -= 11;
}
#ifndef QT_NO_PROPERTIES
else if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast< QString*>(_v) = subject(); break;
case 1: *reinterpret_cast< QString*>(_v) = location(); break;
case 2: *reinterpret_cast< QDateTime*>(_v) = startTime(); break;
case 3: *reinterpret_cast< QDateTime*>(_v) = endTime(); break;
case 4: *reinterpret_cast< int*>(_v) = folderId(); break;
case 5: *reinterpret_cast< int*>(_v) = accountId(); break;
case 6: *reinterpret_cast< Mode*>(_v) = mode(); break;
}
_id -= 7;
} else if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: setSubject(*reinterpret_cast< QString*>(_v)); break;
case 1: setLocation(*reinterpret_cast< QString*>(_v)); break;
case 2: setStartTime(*reinterpret_cast< QDateTime*>(_v)); break;
case 3: setEndTime(*reinterpret_cast< QDateTime*>(_v)); break;
case 4: setFolderId(*reinterpret_cast< int*>(_v)); break;
case 5: setAccountId(*reinterpret_cast< int*>(_v)); break;
case 6: setMode(*reinterpret_cast< Mode*>(_v)); break;
}
_id -= 7;
} else if (_c == QMetaObject::ResetProperty) {
_id -= 7;
} else if (_c == QMetaObject::QueryPropertyDesignable) {
_id -= 7;
} else if (_c == QMetaObject::QueryPropertyScriptable) {
_id -= 7;
} else if (_c == QMetaObject::QueryPropertyStored) {
_id -= 7;
} else if (_c == QMetaObject::QueryPropertyEditable) {
_id -= 7;
} else if (_c == QMetaObject::QueryPropertyUser) {
_id -= 7;
}
#endif // QT_NO_PROPERTIES
return _id;
}
bool Video::loadXML(const QDomElement& root)
{
if (root.tagName() != KXMLQLCFunction)
{
qWarning() << Q_FUNC_INFO << "Function node not found";
return false;
}
if (root.attribute(KXMLQLCFunctionType) != typeToString(Function::Video))
{
qWarning() << Q_FUNC_INFO << root.attribute(KXMLQLCFunctionType)
<< "is not Video";
return false;
}
QDomNode node = root.firstChild();
while (node.isNull() == false)
{
QDomElement tag = node.toElement();
if (tag.tagName() == KXMLQLCVideoSource)
{
if (tag.hasAttribute(KXMLQLCVideoStartTime))
setStartTime(tag.attribute(KXMLQLCVideoStartTime).toUInt());
if (tag.hasAttribute(KXMLQLCVideoColor))
setColor(QColor(tag.attribute(KXMLQLCVideoColor)));
if (tag.hasAttribute(KXMLQLCVideoLocked))
setLocked(true);
if (tag.hasAttribute(KXMLQLCVideoScreen))
setScreen(tag.attribute(KXMLQLCVideoScreen).toInt());
if (tag.hasAttribute(KXMLQLCVideoFullscreen))
{
if (tag.attribute(KXMLQLCVideoFullscreen) == "1")
setFullscreen(true);
else
setFullscreen(false);
}
if (tag.text().contains("://") == true)
setSourceUrl(tag.text());
else
setSourceUrl(m_doc->denormalizeComponentPath(tag.text()));
}
else if (tag.tagName() == KXMLQLCFunctionSpeed)
{
loadXMLSpeed(tag);
}
node = node.nextSibling();
}
return true;
}
void TextTrackCue::setStartTime(double value, ExceptionCode& ec)
{
// NaN, Infinity and -Infinity values should trigger a TypeError.
if (std::isinf(value) || std::isnan(value)) {
ec = TypeError;
return;
}
// TODO(93143): Add spec-compliant behavior for negative time values.
if (m_startTime.toDouble() == value || value < 0)
return;
setStartTime(MediaTime::createWithDouble(value));
}
/*!
Specifies the middle time of this summary item. The parameter must be valid
and non-null. If the parameter is invalid or null, no value is set.
\param dateTime the middle time
\sa middleTime()
*/
void KDGanttViewSummaryItem::setMiddleTime( const QDateTime& dateTime )
{
if (! dateTime.isValid() ) {
qDebug("KDGanttViewSummaryItem::setMiddleTime():Invalid parameter-no time set");
return;
}
if (!myMiddleTime) myMiddleTime = new QDateTime;
*myMiddleTime = dateTime;
if ( myEndTime < middleTime() )
setEndTime( middleTime() );
if ( myStartTime > middleTime() )
setStartTime( middleTime() );
updateCanvasItems();
}
void LogVariablesWidget::on_logVariableTable_itemChanged(QTableWidgetItem *item)
{
if ( item->column() == 1 ) // Frequency
{
setFrequency(item->row(), item->text().toDouble());
}
else if ( item->column() == 2 ) // Start Time
{
setStartTime(item->row(), item->text().toDouble());
}
else if ( item->column() == 3 ) // Duration
{
setDuration(item->row(), item->text().toDouble());
}
}
void startupInit()
{
usbdataEnable();
gdispSetBacklight(50);
gdispSetContrast(50);
geventListenerInit(&gl);
gwinAttachListener(&gl);
// Setup UI objects and show splash
guiCreate();
gwinProgressbarSetResolution(ghProgbarLoad, 10);
gwinProgressbarStart(ghProgbarLoad, 300);
graphInit();
// Setup INA219 I2C Current Sensor
ina219Init();
sduObjectInit(USB_SERIAL_DRIVER);
sduStart(USB_SERIAL_DRIVER, &serusbcfg);
/*
* Activates the USB driver and then the USB bus pull-up on D+.
* Note, a delay is inserted in order to not have to disconnect the cable
* after a reset.
*/
usbDisconnectBus(serusbcfg.usbp);
chThdSleepMilliseconds(1000);
usbStart(serusbcfg.usbp, &usbcfg);
usbConnectBus(serusbcfg.usbp);
setStartTime();
chThdCreateStatic(ledThread, sizeof(ledThread), LOWPRIO, ThreadLED, NULL);
chThdCreateStatic(inaThread, sizeof(inaThread), HIGHPRIO, ThreadINA, NULL);
chThdCreateStatic(gfxvalThread, sizeof(gfxvalThread), NORMALPRIO, ThreadGFXVal, NULL);
chThdCreateStatic(timeThread, sizeof(timeThread), NORMALPRIO, ThreadTIME, NULL);
chThdCreateStatic(gfxEventThread, sizeof(gfxEventThread), NORMALPRIO, ThreadGFXEvent, NULL);
chThdSleepMilliseconds(2000);
chThdCreateStatic(graphThread, sizeof(graphThread), NORMALPRIO+5, ThreadGRAPH, NULL);
// Destroy splay screen and show main page
gwinDestroy(ghContainerPageSplash);
guiShowPage(1);
}
bool Audio::loadXML(QXmlStreamReader &root)
{
if (root.name() != KXMLQLCFunction)
{
qWarning() << Q_FUNC_INFO << "Function node not found";
return false;
}
if (root.attributes().value(KXMLQLCFunctionType).toString() != typeToString(Function::Audio))
{
qWarning() << Q_FUNC_INFO << root.attributes().value(KXMLQLCFunctionType).toString()
<< "is not Audio";
return false;
}
QString fname = name();
while (root.readNextStartElement())
{
if (root.name() == KXMLQLCAudioSource)
{
QXmlStreamAttributes attrs = root.attributes();
if (attrs.hasAttribute(KXMLQLCAudioDevice))
setAudioDevice(attrs.value(KXMLQLCAudioDevice).toString());
if (attrs.hasAttribute(KXMLQLCAudioStartTime))
setStartTime(attrs.value(KXMLQLCAudioStartTime).toString().toUInt());
if (attrs.hasAttribute(KXMLQLCAudioColor))
setColor(QColor(attrs.value(KXMLQLCAudioColor).toString()));
if (attrs.hasAttribute(KXMLQLCAudioLocked))
setLocked(true);
setSourceFileName(m_doc->denormalizeComponentPath(root.readElementText()));
}
else if (root.name() == KXMLQLCFunctionSpeed)
{
loadXMLSpeed(root);
}
else
{
qWarning() << Q_FUNC_INFO << "Unknown Audio tag:" << root.name();
root.skipCurrentElement();
}
}
setName(fname);
return true;
}
void FrameHandler::frame(Time frameTime)
{
if(_mfUninitializedFrameTasks.size() != 0)
{
this->init();
}
setCurrTime(frameTime);
if(osgAbs(_sfStartTime.getValue()) < 0.00001)
{
setStartTime(_sfCurrTime.getValue());
setLastTime(0.f);
}
_sfCurrTime.getValue() -= _sfStartTime.getValue();
if(_sfPaused.getValue() == false)
{
SFTime *pSFTimeStamp = editSFTimeStamp();
if(_sfConstantTime.getValue() == true)
{
pSFTimeStamp->getValue() += _sfConstantTimeStep.getValue();
if(pSFTimeStamp->getValue() < 0.)
pSFTimeStamp->setValue(0.0);
}
else
{
pSFTimeStamp->getValue() +=
(_sfCurrTime.getValue() - _sfLastTime.getValue()) *
_sfTimeScale.getValue();
if(pSFTimeStamp->getValue() < 0.)
pSFTimeStamp->setValue(0.0);
}
}
setLastTime(_sfCurrTime.getValue());
++(editSFFrameCount()->getValue());
callTasks();
}
EPGWidget::EPGWidget( QWidget *parent ) : QWidget( parent )
{
b_input_type_known = false;
m_rulerWidget = new EPGRuler( this );
m_epgView = new EPGView( this );
m_channelsWidget = new EPGChannels( this, m_epgView );
m_channelsWidget->setMinimumWidth( 100 );
m_epgView->setSizePolicy( QSizePolicy::Expanding, QSizePolicy::Expanding );
setZoom( 1 );
rootWidget = new QStackedWidget( this );
QWidget *containerWidget = new QWidget( this );
QGridLayout* layout = new QGridLayout( this );
layout->addWidget( m_rulerWidget, 0, 1 );
layout->addWidget( m_channelsWidget, 1, 0 );
layout->addWidget( m_epgView, 1, 1 );
layout->setSpacing( 0 );
containerWidget->setLayout( layout );
rootWidget->insertWidget( EPGVIEW_WIDGET, containerWidget );
QLabel *noepgLabel = new QLabel( qtr("No EPG Data Available"), this );
noepgLabel->setAlignment( Qt::AlignCenter );
rootWidget->insertWidget( NOEPG_WIDGET, noepgLabel );
rootWidget->setCurrentIndex( 1 );
layout = new QGridLayout( this );
layout->addWidget( rootWidget );
setLayout( layout );
CONNECT( m_epgView, startTimeChanged(QDateTime),
m_rulerWidget, setStartTime(QDateTime) );
CONNECT( m_epgView, durationChanged(int),
m_rulerWidget, setDuration(int) );
CONNECT( m_epgView->horizontalScrollBar(), valueChanged(int),
m_rulerWidget, setOffset(int) );
CONNECT( m_epgView->verticalScrollBar(), valueChanged(int),
m_channelsWidget, setOffset(int) );
connect( m_epgView, SIGNAL( itemFocused(EPGItem*)),
this, SIGNAL(itemSelectionChanged(EPGItem*)) );
CONNECT( m_epgView, channelAdded(QString), m_channelsWidget, addChannel(QString) );
CONNECT( m_epgView, channelRemoved(QString), m_channelsWidget, removeChannel(QString) );
}
/**
* @brief Initializes an ISIS cube converting it into a SPICE segment
*
* This method is called to extract the perinent contents of an ISIS cube file
* and accumulate generic information that is used to create the output SPICE
* kernel segment. Other specific kernel types can use this class as its base
* class and add to it additional elements to complete the needed content for
* the NAIF kernel.
*
* @param cube ISIS cube file to accumulate information from
*/
void SpiceSegment::init(Cube &cube) {
_kernels.UnLoad(); // Unload all active, owned kernels
init(); // Init local variables
_fname = cube.fileName();
// Extract ISIS CK blob and transform to CK 3 content
NaifStatus::CheckErrors();
try {
// Order is somewhat important here. The call to initialize Kernels
// object checks the NAIF pool for existance. It logs their NAIF
// status as loaded which may cause trouble from here on...
Pvl *label = cube.label();
_kernels.Init(*label);
Camera *camera = cube.camera();
// Determine segment ID from product ID if it exists, otherwise basename
if ( _name.isEmpty() ) {
_name = getKeyValue(*label, "ProductId");
if (_name.isEmpty() ) {
_name = FileName(_fname).baseName();
}
}
// Get instrument and target ids
QString value("");
value = getKeyValue(*label, "InstrumentId");
if (!value.isEmpty()) { _instId = value; }
value = getKeyValue(*label, "TargetName");
if (!value.isEmpty()) { _target = value; }
// Get default times for sorting purposes
setStartTime(camera->cacheStartTime().Et());
setEndTime(camera->cacheEndTime().Et());
} catch ( IException &ie ) {
ostringstream mess;
mess << "Failed to construct Spice Segment basics from ISIS file " << _fname;
throw IException(ie, IException::User, mess.str(), _FILEINFO_);
}
return;
}
void Scheduler::scheduleOneOffInFreeSpace(std::shared_ptr<std::vector<std::shared_ptr<Event>>> & scheduledEvents, const std::shared_ptr<const Task> & currentTask)
{
unsigned int remainingDuration = currentTask->getDuration();
unsigned int nextStartTime = currentTask->getEarliestStartTime();
while(remainingDuration > 0)
{
auto newEvent = std::make_shared<Event>();
unsigned int freeStartTime = 0;
unsigned int freeDuration = 0;
newEvent->setParent(currentTask);
auto spaceIsAvailable = findFreeSpaceBetween(
nextStartTime,
currentTask->getLatestEndTime(),
freeStartTime,freeDuration);
if(!spaceIsAvailable)
{
freeDuration = remainingDuration;
}
if(freeDuration > remainingDuration)
{
newEvent->setDuration(remainingDuration);
}
else
{
newEvent->setDuration(freeDuration);
}
newEvent->setStartTime(freeStartTime);
scheduledEvents->push_back(newEvent);
remainingDuration -= newEvent->getDuration();
nextStartTime = newEvent->getEndTime();
}
}
void LogVariablesWidget::loadSettings(QSettings &pSettings)
{
pSettings.beginGroup("logVariablesWidget");
restoreGeometry( pSettings.value("geometry").toByteArray() );
setVisible( pSettings.value("visible").toBool() );
for ( int i = 0; i < ui->logVariableTable->rowCount(); ++i )
{
if ( pSettings.childGroups().contains(ui->logVariableTable->item(i, 0)->text()) )
{
pSettings.beginGroup(ui->logVariableTable->item(i, 0)->text());
setLogVariableChecked( i, true );
setFrequency(i, pSettings.value("frequency", DataRepository::instance()->frequency()).toDouble());
setStartTime(i, pSettings.value("startTime", 0).toDouble());
setDuration(i, pSettings.value("duration", DataRepository::instance()->duration()).toDouble());
pSettings.endGroup();
}
}
pSettings.endGroup();
}
void
PerfGraph::push(const PerfID id)
{
if (!_active)
return;
auto new_node = _stack[_current_position]->getChild(id);
// Set the start time
new_node->setStartTime(std::chrono::steady_clock::now());
// Increment the number of calls
new_node->incrementNumCalls();
_current_position++;
if (_current_position >= MAX_STACK_SIZE)
mooseError("PerfGraph is out of stack space!");
_stack[_current_position] = new_node;
}
