bool SelectionModel::setData(int row, const QVariant &value, const QByteArray &role) { return setData(index(row), value, m_roles.key(role)); }
void UBGraphicsProxyWidget::setUuid(const QUuid &pUuid) { UBItem::setUuid(pUuid); setData(UBGraphicsItemData::ItemUuid, QVariant(pUuid)); //store item uuid inside the QGraphicsItem to fast operations with Items on the scene }
/*! Initialize data with an array of samples. \param samples Vector of points */ void QwtPlotSpectroCurve::setSamples( const QVector<QwtPoint3D> &samples ) { setData( new QwtPoint3DSeriesData( samples ) ); }
//--------------------------------Execute---------------------------------// //this method performs the actions for the Return object, using the //store as a parameter to access the inventory and alter accordingly //it also uses the file stream to read in the information //according to formatting specifications, setting it for this specified //derived transaction class bool Returnx::execute(ifstream& file, Store& st) { int custIdx; file >> custIdx; Customer* cust = st.getCustomer(custIdx); //read the custtomer index and get the customer at that index //from the store, if the store doesn't have the customer at that //spot then the customer has not been created and we cannot do anything if (cust == NULL) { cout << "Invalid Customer ID. Transaction could not be executed.\n"; //no need for clean up since Customer is still NULL return false; } else { char format; file >> format; //read in the format, the format is specified to only be DVDs if (format != 'D') { cout << "Invalid format. Transaction could not be executed.\n"; //no need for clean up since Formaat is not dynamic return false; } else { char genre; file >> genre; //read in the genre and then use the stores movie factory //to create a temporary movie of this genre, //however, if the genre did not correspond to an appropriate //movie, return false Movie* tempMov = st.getMovieFact().createIt(genre); if (tempMov == NULL) { cout << "Invalid movie. Transaction could not be" << "executed.\n"; //no need for clean up since tempMov is still NULL return false; } else { //everything worked, now we try to set the data //from the format specifications of a return //movie, and if this didn't work, the movie was //created so we must clean this up. otherwise, we try //to return the movie from the inventory if (!tempMov->readTrans(file)) { delete tempMov; tempMov = NULL; return false; } else { if (!cust->returnMovie(tempMov)) { cout << "Invalid movie. Transaction could not be " << "executed.\n"; delete tempMov; tempMov = NULL; return false; } else { Movie* mov; //use a movie locator and a movie return value //to try to return the movie from the stores //inventory, if the return couldn't occur //we must delete the temporary movie if (!st.getInventory().returnMovie(mov, tempMov)) { //if we couldn't return we must clean up cout << "Invalid movie." << "Transaction could not be " << "executed.\n"; delete tempMov; tempMov = NULL; return false; } else { //otherwise everything worked out perfectly //so the data is set and the customer //adds this transaction to his/her trans hist //and clean up our temp mov setData(cust, mov); //cust->returnMovie(mov); delete tempMov; tempMov = NULL; cust->addTransaction(this); return true; } } } } } } }
//-------------------------------------------------------------------------- void CClan::init( ClanData* pData ) { setData(pData); }
uint NotificationsEngine::Notify(const QString &app_name, uint replaces_id, const QString &app_icon, const QString &summary, const QString &body, const QStringList &actions, const QVariantMap &hints, int timeout) { uint id = 0; id = replaces_id ? replaces_id : m_nextId++; QString appname_str = app_name; if (appname_str.isEmpty()) { appname_str = i18n("Unknown Application"); } if (timeout == -1) { const int AVERAGE_WORD_LENGTH = 6; const int WORD_PER_MINUTE = 250; int count = summary.length() + body.length(); timeout = 60000 * count / AVERAGE_WORD_LENGTH / WORD_PER_MINUTE; // Add two seconds for the user to notice the notification, and ensure // it last at least five seconds, otherwise all the user see is a // flash timeout = 2000 + qMax(timeout, 3000); } const QString source = QString("notification %1").arg(id); if (replaces_id) { Plasma::DataContainer *container = containerForSource(source); if (container && container->data()["expireTimeout"].toInt() != timeout) { int timerId = m_sourceTimers.value(source); killTimer(timerId); m_sourceTimers.remove(source); m_timeouts.remove(timerId); } } Plasma::DataEngine::Data notificationData; notificationData.insert("id", QString::number(id)); notificationData.insert("appName", appname_str); notificationData.insert("appIcon", app_icon); notificationData.insert("summary", summary); notificationData.insert("body", body); notificationData.insert("actions", actions); notificationData.insert("expireTimeout", timeout); QImage image; if (hints.contains("image_data")) { QDBusArgument arg = hints["image_data"].value<QDBusArgument>(); image = decodeNotificationSpecImageHint(arg); } else if (hints.contains("image_path")) { QString path = findImageForSpecImagePath(hints["image_path"].toString()); if (!path.isEmpty()) { image.load(path); } } else if (hints.contains("icon_data")) { // This hint was in use in version 1.0 of the spec but has been // replaced by "image_data" in version 1.1. We need to support it for // users of the 1.0 version of the spec. QDBusArgument arg = hints["icon_data"].value<QDBusArgument>(); image = decodeNotificationSpecImageHint(arg); } notificationData.insert("image", image); if (hints.contains("urgency")) { notificationData.insert("urgency", hints["urgency"].toInt()); } setData(source, notificationData ); if (timeout) { int timerId = startTimer(timeout); m_sourceTimers.insert(source, timerId); m_timeouts.insert(timerId, source); } return id; }
bool FunctionCurve::loadData(int points, bool xLog10Scale) { if (!points) points = dataSize(); double *X = (double *)malloc(points*sizeof(double)); if (!X){ QMessageBox::critical(0, QObject::tr("QtiPlot - Memory Allocation Error"), QObject::tr("Not enough memory, operation aborted!")); return false; } double *Y = (double *)malloc(points*sizeof(double)); if (!Y){ QMessageBox::critical(0, QObject::tr("QtiPlot - Memory Allocation Error"), QObject::tr("Not enough memory, operation aborted!")); free(X); return false; } double step = (d_to - d_from)/(double)(points - 1.0); if (d_function_type == Normal){ MyParser parser; double x = d_from; try { parser.DefineVar(d_variable.ascii(), &x); QMapIterator<QString, double> i(d_constants); while (i.hasNext()){ i.next(); parser.DefineConst(i.key().ascii(), i.value()); } parser.SetExpr(d_formulas[0].ascii()); int lastButOne = points - 1; try { double xl = x, xr; double y = parser.EvalRemoveSingularity(&x, false); bool wellDefinedFunction = true; if (!gsl_finite(y)){// try to find a first well defined point (might help for some not really bad functions) wellDefinedFunction = false; for (int i = 0; i < lastButOne; i++){ xl = x; x += step; xr = x; y = parser.Eval(); if (gsl_finite(y)){ wellDefinedFunction = true; int iter = 0; double x0 = x, y0 = y; while(fabs(xr - xl)/step > 1e-15 && iter < points){ x = 0.5*(xl + xr); y = parser.Eval(); if (gsl_finite(y)){ xr = x; x0 = x; y0 = y; } else xl = x; iter++; } d_from = x0; X[0] = x0; Y[0] = y0; step = (d_to - d_from)/(double)(lastButOne); break; } } if (!wellDefinedFunction){ QMessageBox::critical(0, QObject::tr("QtiPlot"), QObject::tr("The function %1 is not defined in the specified interval!").arg(d_formulas[0])); free(X); free(Y); return false; } } else { X[0] = d_from; Y[0] = y; } } catch (MyParser::Pole) {} ScaleEngine *sc_engine = 0; if (plot()) sc_engine = (ScaleEngine *)plot()->axisScaleEngine(xAxis()); if (xLog10Scale || (d_from > 0 && d_to > 0 && sc_engine && sc_engine->type() == ScaleTransformation::Log10)){ step = log10(d_to/d_from)/(double)(points - 1); for (int i = 1; i < lastButOne; i++ ){ x = d_from*pow(10, i*step); X[i] = x; try { Y[i] = parser.EvalRemoveSingularity(&x, false); } catch (MyParser::Pole){} } } else { for (int i = 1; i < lastButOne; i++ ){ x += step; X[i] = x; try { Y[i] = parser.EvalRemoveSingularity(&x, false); } catch (MyParser::Pole){} } } //the last point might be outside the interval, therefore we calculate it separately at its precise value x = d_to; X[lastButOne] = x; try { Y[lastButOne] = parser.EvalRemoveSingularity(&x, false); } catch (MyParser::Pole){} } catch(mu::ParserError &e) {} } else if (d_function_type == Parametric || d_function_type == Polar) { QStringList aux = d_formulas; MyParser xparser; MyParser yparser; double par; if (d_function_type == Polar) { QString swap=aux[0]; aux[0]="("+swap+")*cos("+aux[1]+")"; aux[1]="("+swap+")*sin("+aux[1]+")"; } try { QMapIterator<QString, double> i(d_constants); while (i.hasNext()){ i.next(); xparser.DefineConst(i.key().ascii(), i.value()); yparser.DefineConst(i.key().ascii(), i.value()); } xparser.DefineVar(d_variable.ascii(), &par); yparser.DefineVar(d_variable.ascii(), &par); xparser.SetExpr(aux[0].ascii()); yparser.SetExpr(aux[1].ascii()); par = d_from; for (int i = 0; i<points; i++ ){ X[i] = xparser.Eval(); Y[i] = yparser.Eval(); par += step; } } catch(mu::ParserError &) {} } if (curveType() == QwtPlotCurve::Yfx) setData(X, Y, points); else setData(Y, X, points); free(X); free(Y); return true; }
/*! Assign a series of points setSamples() is just a wrapper for setData() without any additional value - beside that it is easier to find for the developer. \param data Data \warning The item takes ownership of the data object, deleting it when its not used anymore. */ void QwtPlotCurve::setSamples( QwtSeriesData<QPointF> *data ) { setData( data ); }
/*! \brief Initialize the data by pointing to memory blocks which are not managed by QwtPlotCurve. setRawSamples is provided for efficiency. It is important to keep the pointers during the lifetime of the underlying QwtCPointerData class. \param xData pointer to x data \param yData pointer to y data \param size size of x and y \sa QwtCPointerData */ void QwtPlotCurve::setRawSamples( const double *xData, const double *yData, int size ) { setData( new QwtCPointerData( xData, yData, size ) ); }
PropertyItemInt::PropertyItemInt( QString name, const QVariant &value, PropertyItem *parent ) :PropertyItem(name,parent) { setData(value); }
/*! Initialize data with an array of points. \param samples Vector of points \note QVector is implicitly shared \note QPolygonF is derived from QVector<QPointF> */ void QwtPlotCurve::setSamples( const QVector<QPointF> &samples ) { setData( new QwtPointSeriesData( samples ) ); }
void ModelWindow::setDirty() { dirty = true; setData(false); }
void ModelWindow::setBinWidthFromSlider() { binWidthLineEdit->setText(QString("%1").arg(binWidthSlider->value())); setData(false); }
void Input::setRep(QMap<QString, QVariant> rep) { setData(rep); }
QxtSqlPackage& QxtSqlPackage::operator= (const QxtSqlPackage & other) { setData(other.data()); return *this; }
/*! Set data by copying x- and y-values from specified memory blocks. Contrary to setRawSamples(), this function makes a 'deep copy' of the data. \param xData pointer to x values \param yData pointer to y values \param size size of xData and yData \sa QwtPointArrayData */ void QwtPlotCurve::setSamples( const double *xData, const double *yData, int size ) { setData( new QwtPointArrayData( xData, yData, size ) ); }
int QHexEdit::qt_metacall(QMetaObject::Call _c, int _id, void **_a) { _id = QScrollArea::qt_metacall(_c, _id, _a); if (_id < 0) return _id; if (_c == QMetaObject::InvokeMetaMethod) { switch (_id) { case 0: currentAddressChanged((*reinterpret_cast< int(*)>(_a[1]))); break; case 1: currentSizeChanged((*reinterpret_cast< int(*)>(_a[1]))); break; case 2: dataChanged(); break; case 3: overwriteModeChanged((*reinterpret_cast< bool(*)>(_a[1]))); break; case 4: setAddressWidth((*reinterpret_cast< int(*)>(_a[1]))); break; case 5: setAddressArea((*reinterpret_cast< bool(*)>(_a[1]))); break; case 6: setAsciiArea((*reinterpret_cast< bool(*)>(_a[1]))); break; case 7: setHighlighting((*reinterpret_cast< bool(*)>(_a[1]))); break; default: ; } _id -= 8; } #ifndef QT_NO_PROPERTIES else if (_c == QMetaObject::ReadProperty) { void *_v = _a[0]; switch (_id) { case 0: *reinterpret_cast< QByteArray*>(_v) = data(); break; case 1: *reinterpret_cast< int*>(_v) = addressOffset(); break; case 2: *reinterpret_cast< QColor*>(_v) = addressAreaColor(); break; case 3: *reinterpret_cast< QColor*>(_v) = highlightingColor(); break; case 4: *reinterpret_cast< QColor*>(_v) = selectionColor(); break; case 5: *reinterpret_cast< bool*>(_v) = overwriteMode(); break; case 6: *reinterpret_cast< bool*>(_v) = isReadOnly(); break; case 7: *reinterpret_cast< QFont*>(_v) = font(); break; } _id -= 8; } else if (_c == QMetaObject::WriteProperty) { void *_v = _a[0]; switch (_id) { case 0: setData(*reinterpret_cast< QByteArray*>(_v)); break; case 1: setAddressOffset(*reinterpret_cast< int*>(_v)); break; case 2: setAddressAreaColor(*reinterpret_cast< QColor*>(_v)); break; case 3: setHighlightingColor(*reinterpret_cast< QColor*>(_v)); break; case 4: setSelectionColor(*reinterpret_cast< QColor*>(_v)); break; case 5: setOverwriteMode(*reinterpret_cast< bool*>(_v)); break; case 6: setReadOnly(*reinterpret_cast< bool*>(_v)); break; case 7: setFont(*reinterpret_cast< QFont*>(_v)); break; } _id -= 8; } else if (_c == QMetaObject::ResetProperty) { _id -= 8; } else if (_c == QMetaObject::QueryPropertyDesignable) { _id -= 8; } else if (_c == QMetaObject::QueryPropertyScriptable) { _id -= 8; } else if (_c == QMetaObject::QueryPropertyStored) { _id -= 8; } else if (_c == QMetaObject::QueryPropertyEditable) { _id -= 8; } else if (_c == QMetaObject::QueryPropertyUser) { _id -= 8; } #endif // QT_NO_PROPERTIES return _id; }
/*! \brief Initialize data with x- and y-arrays (explicitly shared) \param xData x data \param yData y data \sa QwtPointArrayData */ void QwtPlotCurve::setSamples( const QVector<double> &xData, const QVector<double> &yData ) { setData( new QwtPointArrayData( xData, yData ) ); }
void DataCurve::loadData() { Plot *plot = static_cast<Plot *>(this->plot()); Graph *g = static_cast<Graph *>(plot->parent()); if (!g) return; int xcol = d_table->colIndex(d_x_column); int ycol = d_table->colIndex(title().text()); if (xcol < 0 || ycol < 0){ remove(); return; } int r = abs(d_end_row - d_start_row) + 1; QVarLengthArray<double> X(r), Y(r); int xColType = d_table->columnType(xcol); int yColType = d_table->columnType(ycol); QStringList xLabels, yLabels;// store text labels // int xAxis = QwtPlot::xBottom; // if (d_type == Graph::HorizontalBars) // xAxis = QwtPlot::yLeft; QTime time0; QDateTime date0; QString date_time_fmt = d_table->columnFormat(xcol); if (xColType == Table::Time){ for (int i = d_start_row; i <= d_end_row; i++ ){ QString xval=d_table->text(i,xcol); if (!xval.isEmpty()){ time0 = QTime::fromString (xval, date_time_fmt); if (time0.isValid()) break; } } } else if (xColType == Table::Date){ for (int i = d_start_row; i <= d_end_row; i++ ){ QString xval=d_table->text(i,xcol); if (!xval.isEmpty()){ date0 = QDateTime::fromString (xval, date_time_fmt); if (date0.isValid()) break; } } } int size = 0; for (int i = d_start_row; i <= d_end_row; i++ ){ QString xval = d_table->text(i,xcol); QString yval = d_table->text(i,ycol); if (!xval.isEmpty() && !yval.isEmpty()){ bool valid_data = true; if (xColType == Table::Text){ xLabels << xval; X[size] = (double)(size + 1); } else if (xColType == Table::Time){ QTime time = QTime::fromString (xval, date_time_fmt); if (time.isValid()) X[size]= time0.msecsTo (time); } else if (xColType == Table::Date){ QDateTime d = QDateTime::fromString (xval, date_time_fmt); if (d.isValid()) X[size] = (double) date0.secsTo(d); } else X[size] = plot->locale().toDouble(xval, &valid_data); if (yColType == Table::Text){ yLabels << yval; Y[size] = (double)(size + 1); } else Y[size] = plot->locale().toDouble(yval, &valid_data); if (valid_data) size++; } } X.resize(size); Y.resize(size); // The code for calculating the waterfall offsets, that is here in QtiPlot, has been moved up to // PlotCurve so that MantidCurve can access it as well. if (g->isWaterfallPlot()) { // Calculate the offsets computeWaterfallOffsets(); } // End re-jigged waterfall offset code if (!size){ remove(); return; } else { if (d_type == Graph::HorizontalBars){ setData(Y.data(), X.data(), size); foreach(DataCurve *c, d_error_bars) c->setData(Y.data(), X.data(), size); } else { setData(X.data(), Y.data(), size); foreach(DataCurve *c, d_error_bars) c->setData(X.data(), Y.data(), size); } if (xColType == Table::Text){ if (d_type == Graph::HorizontalBars) g->setLabelsTextFormat(QwtPlot::yLeft, ScaleDraw::Text, d_x_column, xLabels); else g->setLabelsTextFormat(QwtPlot::xBottom, ScaleDraw::Text, d_x_column, xLabels); } else if (xColType == Table::Time || xColType == Table::Date){ int axis = QwtPlot::xBottom; if (d_type == Graph::HorizontalBars) axis = QwtPlot::yLeft; ScaleDraw *old_sd = static_cast<ScaleDraw *>(plot->axisScaleDraw(axis)); ScaleDraw *sd = new ScaleDraw(plot, old_sd); if (xColType == Table::Date) sd->setDateTimeOrigin(date0); else sd->setDateTimeOrigin(QDateTime(QDate::currentDate(), time0)); plot->setAxisScaleDraw(axis, sd); } if (yColType == Table::Text) g->setLabelsTextFormat(QwtPlot::yLeft, ScaleDraw::Text, title().text(), yLabels); } if (!d_labels_list.isEmpty()){ (static_cast<Graph*>(plot->parent()))->updatePlot(); loadLabels(); } }
void XLineEdit::setDataWidgetMap(XDataWidgetMapper* m) { _mapper=m; m->addMapping(this, _fieldName, QByteArray("text"), QByteArray("defaultText")); connect(this, SIGNAL(textChanged(QString)), this, SLOT(setData(QString))); }
void ProcessingInstruction::setNodeValue(const String& nodeValue, ExceptionCode& ec) { // NO_MODIFICATION_ALLOWED_ERR: taken care of by setData() setData(nodeValue, ec); }
void QwtErrorPlotCurve::loadData() { if (!d_master_curve) return; if (!plot()) return; Table *mt = d_master_curve->table(); if (!mt) return; int xcol = mt->colIndex(d_master_curve->xColumnName()); int ycol = mt->colIndex(d_master_curve->title().text()); int errcol = d_table->colIndex(title().text()); if (xcol<0 || ycol<0 || errcol<0) return; int xColType = mt->columnType(xcol); int yColType = mt->columnType(ycol); d_start_row = d_master_curve->startRow(); d_end_row = d_master_curve->endRow(); int r = abs(d_end_row - d_start_row) + 1; QVector<double> X(r), Y(r), err(r); int data_size = 0; QLocale locale = d_table->locale(); for (int i = d_start_row; i <= d_end_row; i++){ QString xval = mt->text(i, xcol); QString yval = mt->text(i, ycol); QString errval = d_table->text(i, errcol); if (!xval.isEmpty() && !yval.isEmpty() && !errval.isEmpty()){ bool ok = true; if (xColType == Table::Text) X[data_size] = (double)(data_size + 1); else X[data_size] = locale.toDouble(xval, &ok); if (yColType == Table::Text) Y[data_size] = (double)(data_size + 1); else Y[data_size] = locale.toDouble(yval, &ok); if (!ok) continue; err[data_size] = locale.toDouble(errval, &ok); if (ok) data_size++; } } if (!data_size) remove(); X.resize(data_size); Y.resize(data_size); err.resize(data_size); setData(X.data(), Y.data(), data_size); setErrors(err); }
void RecycledListItem::updateItemContents() { AbstractViewItem::updateItemContents(); if (m_model && m_index.isValid()) setData(m_model->data(m_index,Qt::DisplayRole), Qt::DisplayRole); }
/// setData() is re-implemented from QStandardItemModel to set the widget window title and icon for the Qt::DecorationRole and Qt::DisplayRole/Qt::EditRole bool AMWindowPaneModel::setData(const QModelIndex &index, const QVariant &value, int role) { if(!index.isValid()) return false; switch(role) { case Qt::DisplayRole: case Qt::EditRole: // alias items and heading items can have separate descriptions, but for normal items, the DisplayRole and EditRole should be the window title if(isAlias(index) || isHeading(index)) return AMDragDropItemModel::setData(index, value, role); if(internalPane(index)) { internalPane(index)->setWindowTitle(value.toString()); return true; } else return false; break; case Qt::DecorationRole: // alias items and heading items can have separate icons, but for normal items, the Decoration role should be the window icon if(isAlias(index) || isHeading(index)) return AMDragDropItemModel::setData(index, value, role); if(internalPane(index)) { internalPane(index)->setWindowIcon(value.value<QIcon>()); return true; } else return false; break; case AMWindowPaneModel::DockStateRole: { // docking an alias? dock the target instead. if(isAlias(index)) { QStandardItem* target = aliasTarget(index); if(target) return setData(target->index(), value, role); else return false; } bool nowDocked = value.toBool(); bool wasDocked = isDocked(index); // set dock state like normal, but emit special signal dockStateChanged() if it's changing. if(AMDragDropItemModel::setData(index, value, role)) { QWidget* w = internalPane(index); if(wasDocked && !nowDocked) emit dockStateChanged(w, false, index.data(AMWindowPaneModel::UndockResizeRole).toBool()); else if(!wasDocked && nowDocked) emit dockStateChanged(w, true, index.data(AMWindowPaneModel::UndockResizeRole).toBool()); return true; } else return false; break; } case AMWindowPaneModel::UndockResizeRole: return AMDragDropItemModel::setData(index, value, role); break; case AMWindowPaneModel::IsVisibleRole: if (AMDragDropItemModel::setData(index, value, role)) { QWidget *pane = internalPane(index); emit visibilityChanged(pane, value.toBool()); return true; } else { return false; } break; default: return AMDragDropItemModel::setData(index, value, role); } }
// Method to store satellite data in this class' data map void SatDataReader::loadData(void) throw(FFStreamError, gpstk::StringUtils::StringException) { // Do this until end-of-file reached or something else happens while(1) { try { std::string line; formattedGetLine(line, true); // If line is too long, we throw an exception if (line.size()>255) { FFStreamError e("Line too long"); GPSTK_THROW(e); } // Let's find and strip comments, wherever they are if( StringUtils::firstWord(line)[0] == '#' ) { formattedGetLine(line, true); } std::string::size_type idx = line.find('#'); if( !(idx == std::string::npos) ) { line = line.substr(0, idx); } // We erase the header (first line) if( StringUtils::firstWord(line) == "Launch" ) { formattedGetLine(line, true); } // Remove trailing and leading blanks line = StringUtils::strip(line); // Skip blank lines if (line.size()==0) { continue; } // Let's start to get data out of file // Launch date string ldate(StringUtils::stripFirstWord(line)); // Deactivation date string ddate(StringUtils::stripFirstWord(line)); // GPS number string gnumber(StringUtils::stripFirstWord(line)); // PRN number string prn(StringUtils::stripFirstWord(line)); // Block tipe string block(StringUtils::upperCase( StringUtils::stripFirstWord(line))); // Get satellite id. If it doesn't fit GPS or Glonass, it is // marked as unknown SatID sat(StringUtils::asInt(prn),SatID::systemUnknown); // Let's identify satellite system if(block[0] == 'I') { sat.system = SatID::systemGPS; } else { if (block.substr(0, 3) == "GLO") { sat.system = SatID::systemGlonass; } } // Declare the structure to store data SatDataReader::svData data; data.block = block; data.gpsNumber = StringUtils::asInt(gnumber); // Get launch date in a proper format if(ldate[0] != '0') { ldate = StringUtils::translate(ldate, "-", " "); scanTime(data.launchDate, ldate, "%Y %m %d"); } // Get deactivation date in a proper format if(ddate[0] != '0') { ddate = StringUtils::translate(ddate, "-", " "); scanTime(data.deactivationDate, ddate, "%Y %m %d"); } // It's not a good way!!! data.launchDate.setTimeSystem(TimeSystem::Any); data.deactivationDate.setTimeSystem(TimeSystem::Any); // Insert data in data map setData(sat, data); } // End of try block catch (EndOfFile& e) { // Close this data stream (*this).close(); return; } catch (...) { // Close this data stream (*this).close(); return; } } // End of while(1) } // End of method 'SatDataReader::loadData()'
Buffer &Buffer::operator=(const Buffer ©) { setData(copy.data, copy.len); return *this; }
void CharacterData::setNodeValue(const String& nodeValue, ExceptionCode& ec) { setData(nodeValue, ec); }
/*! Constructs a copy of \a other with \a parent. */ QxtSqlPackage::QxtSqlPackage(const QxtSqlPackage & other, QObject *parent) : QObject(parent) { record = -1; setData(other.data()); }
/*! Assign a series of samples setSamples() is just a wrapper for setData() without any additional value - beside that it is easier to find for the developer. \param data Data \warning The item takes ownership of the data object, deleting it when its not used anymore. */ void QwtPlotSpectroCurve::setSamples( QwtSeriesData<QwtPoint3D> *data ) { setData( data ); }
UBMimeData::UBMimeData(const QList<UBMimeDataItem> &items) : QMimeData() , mItems(items) { setData(UBApplication::mimeTypeUniboardPage, QByteArray()); }