PitchEdit::PitchEdit(QWidget* parent) : QSpinBox(parent) { setRange(0, 127); deltaMode = false; }
void KDoubleNumInput::setMaxValue(double max) { setRange(minValue(), max, d->spin->lineStep(), m_slider); }
Item::e_sercode Item::deserialize( Stream *file, VMachine *vm ) { byte type = FLC_ITEM_NIL; if ( file->read((byte *) &type, 1 ) == 0 ) return sc_eof; if( ! file->good() ) return sc_ferror; switch( type ) { case FLC_ITEM_NIL: setNil(); return sc_ok; case FLC_ITEM_UNB: setUnbound(); return sc_ok; case FLC_ITEM_BOOL: { byte bval; file->read( (byte *) &bval, sizeof( bval ) ); if ( file->good() ) { setBoolean( bval != 0 ); return sc_ok; } return sc_ferror; } return sc_ok; case FLC_ITEM_INT: { int64 val; file->read( (byte *) &val, sizeof( val ) ); if ( file->good() ) { setInteger(endianInt64(val) ); return sc_ok; } return sc_ferror; } break; case FLC_ITEM_RANGE: { int64 val1; int64 val2; int64 val3; //byte isOpen; file->read( (byte *) &val1, sizeof( val1 ) ); file->read( (byte *) &val2, sizeof( val2 ) ); file->read( (byte *) &val3, sizeof( val3 ) ); //file->read( (byte *) &isOpen, sizeof( isOpen ) ); val1 = endianInt64( val1 ); val2 = endianInt64( val2 ); val3 = endianInt64( val3 ); if ( file->good() ) { setRange( new CoreRange( val1, val2, val3 ) ); return sc_ok; } return sc_ferror; } break; case FLC_ITEM_NUM: { numeric val; file->read( (byte *) &val, sizeof( val ) ); if ( file->good() ) { setNumeric( endianNum( val ) ); return sc_ok; } return sc_ferror; } break; case FLC_ITEM_LBIND: { int32 id; file->read( (byte*) &id, sizeof(id) ); String name; if ( ! name.deserialize( file ) ) return file->bad() ? sc_ferror : sc_invformat; setLBind( new CoreString( name ) ); } break; case FLC_ITEM_STRING: { CoreString *cs = new CoreString; setString( cs ); if ( ! cs->deserialize( file ) ) { return file->bad() ? sc_ferror : sc_invformat; } if ( file->good() ) { return sc_ok; } return sc_ferror; } break; case FLC_ITEM_MEMBUF |0x80: { // get the function pointer in the stream /*MemBuf *(*deserializer)( VMachine *, Stream * ); file->read( &deserializer, sizeof( deserializer ) ); if ( ! file->good() ) { return sc_ferror; } MemBuf *mb = deserializer( vm, file ); if( mb == 0 ) { return sc_invformat; }*/ MemBuf* mb; if( file->read( &mb, sizeof( mb ) ) == sizeof(mb) ) { setMemBuf( mb ); return sc_ok; } return sc_eof; } case FLC_ITEM_MEMBUF: { MemBuf *mb = MemBuf::deserialize( vm, file ); if ( file->good() && mb != 0 ) { setMemBuf( mb ); return sc_ok; } return sc_ferror; } break; case FLC_ITEM_ARRAY: { int32 val; file->read( (byte *) &val, sizeof( val ) ); e_sercode retval = sc_ok; if ( file->good() ) { val = endianInt32(val); CoreArray *array = new CoreArray(); array->resize(val); for( int i = 0; i < val; i ++ ) { retval = array->items()[i].deserialize( file, vm ); if( retval != sc_ok ) { break; } } if ( retval == sc_ok ) { setArray( array ); return sc_ok; } return retval; } } break; case FLC_ITEM_DICT: { byte blessed; file->read( &blessed, 1 ); int32 val; file->read( (byte *) &val, sizeof( val ) ); if ( file->good() ) { val = endianInt32(val); LinearDict *dict = new LinearDict( val ); LinearDictEntry *elems = dict->entries(); e_sercode retval = sc_ok; for( int i = 0; i < val; i ++ ) { LinearDictEntry *entry = elems + i; retval = entry->key().deserialize( file, vm ); if( retval == sc_ok ) retval = entry->value().deserialize( file, vm ); if ( retval != sc_ok ) break; dict->length( i + 1 ); } if( retval == sc_ok ) { CoreDict* cdict = new CoreDict( dict ); cdict->bless( blessed ? true : false ); setDict( cdict ); return sc_ok; } else delete dict; return retval; } } break; case FLC_ITEM_FUNC | 0x80: case FLC_ITEM_FUNC: { if( vm == 0 ) return sc_missvm; return deserialize_function( file, vm ); } break; case FLC_ITEM_METHOD: { if( vm == 0 ) return sc_missvm; Item obj; Item func; e_sercode sc; sc = obj.deserialize( file, vm ); if ( sc != sc_ok ) return sc; sc = func.deserialize( file, vm ); if ( sc != sc_ok ) return sc; if ( func.isFunction() ) setMethod( obj, func.asMethodFunc() ); else if ( func.isArray() && func.isCallable() ) { setMethod( obj, func.asArray() ); } else return sc_invformat; return sc_ok; } case FLC_ITEM_OBJECT | 0x80: case FLC_ITEM_OBJECT: { bool bLive = type != FLC_ITEM_OBJECT; if( vm == 0 ) return sc_missvm; // read the module name Symbol *sym; LiveModule *lmod; e_sercode sc = deserialize_symbol( file, vm, &sym, &lmod ); if ( sc != sc_ok ) return sc; Item *clitem = &lmod->globals()[ sym->itemId() ]; // Create the core object, but don't fill attribs. CoreObject *object = clitem->dereference()->asClass()->createInstance(0, true); if ( ! object->deserialize( file, bLive ) ) { return sc_missclass; } setObject( object ); return file->good() ? sc_ok : sc_ferror; } break; case FLC_ITEM_CLASS: return deserialize_class( file, vm ); case FLC_ITEM_CLSMETHOD: { e_sercode sc = deserialize_class( file, vm ); if ( sc != sc_ok ) return sc; return deserialize_function( file, vm ); } break; default: return sc_invformat; } return sc_ferror; }
//! Check current water column. void checkAltitude(void) { if (m_estate.alt > c_min_alt) setRange((unsigned)(m_estate.alt * m_args.range_modifier_mul_k + m_args.range_modifier_add_k)); }
void KIntNumInput::setMinValue(int min) { setRange(min, m_spin->maxValue(), m_spin->lineStep(), m_slider); }
SequenceDialog::SequenceDialog(QWidget *parent, capture_file *cf, SequenceType type) : QDialog(parent), ui(new Ui::SequenceDialog), cap_file_(cf), num_items_(0), packet_num_(0), node_label_w_(20) { ui->setupUi(this); QCustomPlot *sp = ui->sequencePlot; seq_diagram_ = new SequenceDiagram(sp->yAxis, sp->xAxis2, sp->yAxis2); sp->addPlottable(seq_diagram_); sp->axisRect()->setRangeDragAxes(sp->xAxis2, sp->yAxis); sp->xAxis->setVisible(false); sp->xAxis->setPadding(0); sp->xAxis->setLabelPadding(0); sp->xAxis->setTickLabelPadding(0); sp->xAxis2->setVisible(true); sp->yAxis2->setVisible(true); one_em_ = QFontMetrics(sp->yAxis->labelFont()).height(); ui->horizontalScrollBar->setSingleStep(100 / one_em_); ui->verticalScrollBar->setSingleStep(100 / one_em_); sp->setInteractions(QCP::iRangeDrag); ui->gridLayout->setSpacing(0); connect(sp->yAxis, SIGNAL(rangeChanged(QCPRange)), sp->yAxis2, SLOT(setRange(QCPRange))); ctx_menu_.addAction(ui->actionReset); ctx_menu_.addSeparator(); ctx_menu_.addAction(ui->actionMoveRight10); ctx_menu_.addAction(ui->actionMoveLeft10); ctx_menu_.addAction(ui->actionMoveUp10); ctx_menu_.addAction(ui->actionMoveDown10); ctx_menu_.addAction(ui->actionMoveRight1); ctx_menu_.addAction(ui->actionMoveLeft1); ctx_menu_.addAction(ui->actionMoveUp1); ctx_menu_.addAction(ui->actionMoveDown1); ctx_menu_.addSeparator(); ctx_menu_.addAction(ui->actionGoToPacket); memset (&seq_analysis_, 0, sizeof(seq_analysis_)); ui->showComboBox->blockSignals(true); ui->showComboBox->setCurrentIndex(0); ui->showComboBox->blockSignals(false); ui->addressComboBox->blockSignals(true); ui->addressComboBox->setCurrentIndex(0); ui->addressComboBox->blockSignals(false); QComboBox *fcb = ui->flowComboBox; fcb->addItem(ui->actionFlowAny->text(), SEQ_ANALYSIS_ANY); fcb->addItem(ui->actionFlowTcp->text(), SEQ_ANALYSIS_TCP); ui->flowComboBox->blockSignals(true); switch (type) { case any: seq_analysis_.type = SEQ_ANALYSIS_ANY; ui->flowComboBox->setCurrentIndex(SEQ_ANALYSIS_ANY); break; case tcp: seq_analysis_.type = SEQ_ANALYSIS_TCP; ui->flowComboBox->setCurrentIndex(SEQ_ANALYSIS_TCP); break; case voip: seq_analysis_.type = SEQ_ANALYSIS_VOIP; ui->flowComboBox->hide(); ui->flowLabel->hide(); break; } ui->flowComboBox->blockSignals(false); seq_analysis_.all_packets = TRUE; QPushButton *save_bt = ui->buttonBox->button(QDialogButtonBox::Save); save_bt->setText(tr("Save As...")); // XXX Use recent settings instead if (parent) { resize(parent->width(), parent->height() * 4 / 5); } connect(ui->horizontalScrollBar, SIGNAL(valueChanged(int)), this, SLOT(hScrollBarChanged(int))); connect(ui->verticalScrollBar, SIGNAL(valueChanged(int)), this, SLOT(vScrollBarChanged(int))); connect(sp->xAxis2, SIGNAL(rangeChanged(QCPRange)), this, SLOT(xAxisChanged(QCPRange))); connect(sp->yAxis, SIGNAL(rangeChanged(QCPRange)), this, SLOT(yAxisChanged(QCPRange))); connect(sp, SIGNAL(mousePress(QMouseEvent*)), this, SLOT(diagramClicked(QMouseEvent*))); connect(sp, SIGNAL(mouseMove(QMouseEvent*)), this, SLOT(mouseMoved(QMouseEvent*))); connect(sp, SIGNAL(mouseRelease(QMouseEvent*)), this, SLOT(mouseReleased(QMouseEvent*))); connect(this, SIGNAL(goToPacket(int)), seq_diagram_, SLOT(setSelectedPacket(int))); disconnect(ui->buttonBox, SIGNAL(accepted()), this, SLOT(accept())); fillDiagram(); }
/** Called when asyn clients call pasynInt32->write(). * \param[in] pasynUser pasynUser structure that encodes the reason and address. * \param[in] value Value to write. */ asynStatus drvQuadEM::writeInt32(asynUser *pasynUser, epicsInt32 value) { int function = pasynUser->reason; int status = asynSuccess; int channel; const char *paramName; const char* functionName = "writeInt32"; getAddress(pasynUser, &channel); /* Set the parameter in the parameter library. */ status |= setIntegerParam(channel, function, value); /* Fetch the parameter string name for possible use in debugging */ getParamName(function, ¶mName); if (function == P_Acquire) { if (value) { epicsRingBytesFlush(ringBuffer_); ringCount_ = 0; } status |= setAcquire(value); } else if (function == P_AcquireMode) { if (value != QEAcquireModeContinuous) { status |= setAcquire(0); setIntegerParam(P_Acquire, 0); } status |= setAcquireMode(value); status |= readStatus(); } else if (function == P_BiasState) { status |= setBiasState(value); status |= readStatus(); } else if (function == P_BiasInterlock) { status |= setBiasInterlock(value); status |= readStatus(); } else if (function == P_NumChannels) { status |= setNumChannels(value); status |= readStatus(); } else if (function == P_NumAcquire) { status |= setNumAcquire(value); status |= readStatus(); } else if (function == P_PingPong) { status |= setPingPong(value); status |= readStatus(); } else if (function == P_Range) { status |= setRange(value); status |= readStatus(); } else if (function == P_ReadData) { status |= doDataCallbacks(); } else if (function == P_Resolution) { status |= setResolution(value); status |= readStatus(); } else if (function == P_TriggerMode) { status |= setTriggerMode(value); status |= readStatus(); } else if (function == P_ValuesPerRead) { valuesPerRead_ = value; status |= setValuesPerRead(value); status |= readStatus(); } else if (function == P_ReadFormat) { status |= setReadFormat(value); status |= readStatus(); } else if (function == P_ReadStatus) { // We don't do this if we are acquiring, too disruptive if (!acquiring_) { status |= readStatus(); } } else if (function == P_Reset) { status |= reset(); status |= readStatus(); } else { /* All other parameters just get set in parameter list, no need to * act on them here */ } /* Do callbacks so higher layers see any changes */ status |= (asynStatus) callParamCallbacks(); if (status) epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize, "%s:%s: status=%d, function=%d, name=%s, value=%d", driverName, functionName, status, function, paramName, value); else asynPrint(pasynUser, ASYN_TRACEIO_DRIVER, "%s:%s: function=%d, name=%s, value=%d\n", driverName, functionName, function, paramName, value); return (asynStatus)status; }
/*! A convenience function which just calls setRange( i, maxValue() ) \sa setRange() */ void QSlider::setMinValue( int i ) { setRange( i, maxValue() ); }
/*! A convenience function which just calls setRange( minValue(), i ) \sa setRange() */ void QSlider::setMaxValue( int i ) { setRange( minValue(), i ); }
/** * Copies the contents of fromMsg to the contents of toMsg. Both must be * instances of LinkMessage. The toLink object must be an instance of Link. * It's filled in if the contents of fromMsg are a Link. Returns KNI_TRUE if * successful, otherwise KNI_FALSE. */ static jboolean copy(jobject fromMsg, jobject toMsg, jobject toLink) { jboolean retval; KNI_StartHandles(6); KNI_DeclareHandle(byteArrayClass); KNI_DeclareHandle(stringClass); KNI_DeclareHandle(linkClass); KNI_DeclareHandle(fromContents); KNI_DeclareHandle(newString); KNI_DeclareHandle(newByteArray); KNI_FindClass("[B", byteArrayClass); KNI_FindClass("java/lang/String", stringClass); KNI_FindClass("com/sun/midp/links/Link", linkClass); getContents(fromMsg, fromContents); if (KNI_IsInstanceOf(fromContents, byteArrayClass)) { /* do a byte array copy */ jint fromOffset; jint fromLength; getRange(fromMsg, &fromOffset, &fromLength); SNI_NewArray(SNI_BYTE_ARRAY, fromLength, newByteArray); if (KNI_IsNullHandle(newByteArray)) { retval = KNI_FALSE; } else { KNI_GetRawArrayRegion(fromContents, fromOffset, fromLength, SNI_GetRawArrayPointer(newByteArray)); setContents(toMsg, newByteArray); setRange(toMsg, 0, fromLength); retval = KNI_TRUE; } } else if (KNI_IsInstanceOf(fromContents, stringClass)) { /* do a string copy */ jchar *buf; jsize slen = KNI_GetStringLength(fromContents); SNI_NewArray(SNI_BYTE_ARRAY, slen*sizeof(jchar), newByteArray); if (KNI_IsNullHandle(newByteArray)) { retval = KNI_FALSE; } else { buf = SNI_GetRawArrayPointer(newByteArray); KNI_GetStringRegion(fromContents, 0, slen, buf); KNI_NewString(buf, slen, newString); setContents(toMsg, newString); retval = KNI_TRUE; } } else if (KNI_IsInstanceOf(fromContents, linkClass)) { /* copy the link */ rendezvous *rp = getNativePointer(fromContents); setNativePointer(toLink, rp); rp_incref(rp); setContents(toMsg, toLink); retval = KNI_TRUE; } else { retval = KNI_FALSE; } KNI_EndHandles(); return retval; }
Palette::Palette(const Color &base, double imin, double imax) { setRange(imin,imax); setColor(imin,base); setColor(imax,base); }
SequenceDialog::SequenceDialog(QWidget &parent, CaptureFile &cf, seq_analysis_info_t *sainfo) : WiresharkDialog(parent, cf), ui(new Ui::SequenceDialog), sainfo_(sainfo), num_items_(0), packet_num_(0), node_label_w_(20) { ui->setupUi(this); QCustomPlot *sp = ui->sequencePlot; setWindowSubtitle(sainfo ? tr("Call Flow") : tr("Flow")); if (!sainfo_) { sainfo_ = sequence_analysis_info_new(); sainfo_->type = SEQ_ANALYSIS_ANY; sainfo_->all_packets = TRUE; } else { num_items_ = sequence_analysis_get_nodes(sainfo_); } seq_diagram_ = new SequenceDiagram(sp->yAxis, sp->xAxis2, sp->yAxis2); sp->addPlottable(seq_diagram_); sp->axisRect()->setRangeDragAxes(sp->xAxis2, sp->yAxis); sp->xAxis->setVisible(false); sp->xAxis->setPadding(0); sp->xAxis->setLabelPadding(0); sp->xAxis->setTickLabelPadding(0); sp->xAxis2->setVisible(true); sp->yAxis2->setVisible(true); one_em_ = QFontMetrics(sp->yAxis->labelFont()).height(); ui->horizontalScrollBar->setSingleStep(100 / one_em_); ui->verticalScrollBar->setSingleStep(100 / one_em_); sp->setInteractions(QCP::iRangeDrag); ui->gridLayout->setSpacing(0); connect(sp->yAxis, SIGNAL(rangeChanged(QCPRange)), sp->yAxis2, SLOT(setRange(QCPRange))); ctx_menu_.addAction(ui->actionReset); ctx_menu_.addSeparator(); ctx_menu_.addAction(ui->actionMoveRight10); ctx_menu_.addAction(ui->actionMoveLeft10); ctx_menu_.addAction(ui->actionMoveUp10); ctx_menu_.addAction(ui->actionMoveDown10); ctx_menu_.addAction(ui->actionMoveRight1); ctx_menu_.addAction(ui->actionMoveLeft1); ctx_menu_.addAction(ui->actionMoveUp1); ctx_menu_.addAction(ui->actionMoveDown1); ctx_menu_.addSeparator(); ctx_menu_.addAction(ui->actionGoToPacket); ui->showComboBox->blockSignals(true); ui->showComboBox->setCurrentIndex(0); ui->showComboBox->blockSignals(false); ui->addressComboBox->blockSignals(true); ui->addressComboBox->setCurrentIndex(0); ui->addressComboBox->blockSignals(false); QComboBox *fcb = ui->flowComboBox; fcb->addItem(ui->actionFlowAny->text(), SEQ_ANALYSIS_ANY); fcb->addItem(ui->actionFlowTcp->text(), SEQ_ANALYSIS_TCP); ui->flowComboBox->blockSignals(true); ui->flowComboBox->setCurrentIndex(sainfo_->type); if (sainfo_->type == SEQ_ANALYSIS_VOIP) { ui->controlFrame->hide(); } else { ui->flowComboBox->blockSignals(false); } QPushButton *save_bt = ui->buttonBox->button(QDialogButtonBox::Save); save_bt->setText(tr("Save As...")); // XXX Use recent settings instead resize(parent.width(), parent.height() * 4 / 5); connect(ui->horizontalScrollBar, SIGNAL(valueChanged(int)), this, SLOT(hScrollBarChanged(int))); connect(ui->verticalScrollBar, SIGNAL(valueChanged(int)), this, SLOT(vScrollBarChanged(int))); connect(sp->xAxis2, SIGNAL(rangeChanged(QCPRange)), this, SLOT(xAxisChanged(QCPRange))); connect(sp->yAxis, SIGNAL(rangeChanged(QCPRange)), this, SLOT(yAxisChanged(QCPRange))); connect(sp, SIGNAL(mousePress(QMouseEvent*)), this, SLOT(diagramClicked(QMouseEvent*))); connect(sp, SIGNAL(mouseMove(QMouseEvent*)), this, SLOT(mouseMoved(QMouseEvent*))); connect(sp, SIGNAL(mouseRelease(QMouseEvent*)), this, SLOT(mouseReleased(QMouseEvent*))); connect(this, SIGNAL(goToPacket(int)), seq_diagram_, SLOT(setSelectedPacket(int))); disconnect(ui->buttonBox, SIGNAL(accepted()), this, SLOT(accept())); fillDiagram(); }
void QRoundProgressBar::setMaximun(double max) { setRange(m_min, max); }
void QRoundProgressBar::setMinimun(double min) { setRange(min, m_max); }
void Deadband::setRange(double lower, double upper) { setRange(lower, upper, (lower + upper) / 2); }
void XIntegrationControl::setWholeRange() { setRange(m_totalMinimum, m_totalMaximum); }
Deadband::Deadband(double lower, double upper, double val) { setRange(lower, upper, val); }
/*! Set the maximum value. \param max Maximum value \sa maxValue(), setMinValue() */ void QwtThermo::setMaxValue(double max) { setRange(d_data->minValue, max); }
/***************************************************************************** * Function Name: MainWindow() ****************************************************************************** * Summary: * Create and initialize every items used by the main window. * * Parameters: * Parent. * * Return: * Address of the new MainWindow. * * Note: * Using a Model-Controller-View approach. * *****************************************************************************/ MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), ui(new Ui::MainWindow) { // Create the controller try { controller = new MV_Controller(this); } catch(int e) { throw e; } // .ui form ui->setupUi(this); // Window title this->setWindowTitle("CapSense data acquisition"); // COMBOBOX: Characteristic selection for (int i = 0; i < controller->getNumServices(); i++) { for (int j = 0; j < controller->getNumCharacteristics(i); j++) { if ( !controller->isCharacteristicNameEmpty(i, j) ) ui->characteristicSelection->addItem(controller->getCharacteristicName(i, j), qVariantFromValue((void *)controller->getCharacteristicAddress(i, j))); } } if (ui->characteristicSelection->count() > 0) controller->setCurrChar( (Characteristic *)ui->characteristicSelection->currentData().value<void *>() ); // PUSH BUTTON: Start acquisition ui->startAcquisition->setEnabled(false); // PUSH BUTTON: Stop acquisition ui->stopAcquisition->setEnabled(false); // PUSH BUTTON: Download data ui->downloadData->setEnabled(false); // PUSH BUTTON: Clear if (ui->characteristicSelection->count() > 0) ui->clear->setEnabled(true); // LCD NUMBER: Elapsed time (acquisition) lcdTimer = new QLabel; timerAcquisition = new QTimer(); timerAcquisition->setInterval(1000); connect(timerAcquisition, SIGNAL(timeout()), this, SLOT(setLCD())); timerSending = new QTime(); lcdTimer->setText("Acquisition: 00:00.000\tSending: 00:00:000"); ui->statusBar->addWidget(lcdTimer); // LABELS: Status ui->Ind_Ready_Acq->setVisible(false); ui->Ind_Acq->setVisible(false); ui->Ind_Ready_Send->setVisible(false); ui->Ind_Send->setVisible(false); // PROGRESS BARS: Sensors' last values int max = 0xFFFF; ui->sensor0->setRange(0, max); ui->sensor0->setValue(0); ui->value_sensor0->setText(QString::number(0)); ui->sensor1->setRange(0, max); ui->sensor1->setValue(0); ui->value_sensor1->setText(QString::number(0)); ui->sensor2->setRange(0, max); ui->sensor2->setValue(0); ui->value_sensor2->setText(QString::number(0)); ui->sensor3->setRange(0, max); ui->sensor3->setValue(0); ui->value_sensor3->setText(QString::number(0)); ui->sensor4->setRange(0, max); ui->sensor4->setValue(0); ui->value_sensor4->setText(QString::number(0)); ui->sensor5->setRange(0, max); ui->sensor5->setValue(0); ui->value_sensor5->setText(QString::number(0)); ui->sensor6->setRange(0, max); ui->sensor6->setValue(0); ui->value_sensor6->setText(QString::number(0)); ui->sensor7->setRange(0, max); ui->sensor7->setValue(0); ui->value_sensor7->setText(QString::number(0)); ui->sensor8->setRange(0, max); ui->sensor8->setValue(0); ui->value_sensor8->setText(QString::number(0)); ui->sensor9->setRange(0, max); ui->sensor9->setValue(0); ui->value_sensor9->setText(QString::number(0)); // CHECKBOX: Send data synchronously ui->sendDataSynchronously->setChecked(false); on_sendDataSynchronously_clicked(); // TABLEVIEW: All sensors' values ui->sensorsTable->setModel( controller->getCurrCharDataModelAddress() ); // PLOT: Chart for each sensor ui->plot_sensors->plotLayout()->clear(); ui->plot_sensors->setAntialiasedElements(QCP::aeAll); QPen *pen = new QPen(); pen->setColor(Qt::black); pen->setWidth(3); QVector<QCPAxisRect *> sensor; sensor.resize(controller->getNumSensors()); QVector<QCPGraph *> sensorGraph; sensorGraph.resize(controller->getNumSensors()); QCPMarginGroup *marginGroup = new QCPMarginGroup(ui->plot_sensors); // Global X Axis QCPAxisRect *X_Axis = new QCPAxisRect(ui->plot_sensors); X_Axis->axis(QCPAxis::atBottom)->setTickLabelType(QCPAxis::ltDateTime); X_Axis->axis(QCPAxis::atBottom)->setDateTimeFormat("mm:ss.zzz"); X_Axis->axis(QCPAxis::atBottom)->setAutoTicks(true); X_Axis->axis(QCPAxis::atBottom)->setAutoTickLabels(true); X_Axis->axis(QCPAxis::atBottom)->setAutoTickStep(true); X_Axis->axis(QCPAxis::atBottom)->setAutoTickCount(4); X_Axis->axis(QCPAxis::atBottom)->setAutoSubTicks(true); X_Axis->axis(QCPAxis::atBottom)->grid()->setVisible(false); X_Axis->axis(QCPAxis::atLeft)->setVisible(false); // Sensors' plot for (int i = 0; i < controller->getNumSensors(); i++) { sensor[i] = new QCPAxisRect(ui->plot_sensors); // Y Axis sensor[i]->axis(QCPAxis::atLeft)->setRangeUpper(0xFFFF); sensor[i]->axis(QCPAxis::atLeft)->setAutoTicks(true); sensor[i]->axis(QCPAxis::atLeft)->setAutoTickStep(true); sensor[i]->axis(QCPAxis::atLeft)->setAutoTickCount(3); sensor[i]->axis(QCPAxis::atLeft)->setAutoSubTicks(true); sensor[i]->axis(QCPAxis::atLeft)->setTickLabels(true); sensor[i]->axis(QCPAxis::atLeft)->setLabel( "Sensor " + QString::number(i+1) ); // X Axis sensor[i]->axis(QCPAxis::atBottom)->setTickLabelType(QCPAxis::ltDateTime); sensor[i]->axis(QCPAxis::atBottom)->setDateTimeFormat("mm:ss.zzz"); sensor[i]->axis(QCPAxis::atBottom)->setAutoTicks(true); sensor[i]->axis(QCPAxis::atBottom)->setAutoTickStep(true); sensor[i]->axis(QCPAxis::atBottom)->setAutoTickCount(4); sensor[i]->axis(QCPAxis::atBottom)->setAutoSubTicks(true); sensor[i]->axis(QCPAxis::atBottom)->setTickLabels(true); // Full Axes Box sensor[i]->setupFullAxesBox(); connect(sensor[i]->axis(QCPAxis::atBottom), SIGNAL(rangeChanged(QCPRange)), sensor[i]->axis(QCPAxis::atTop), SLOT(setRange(QCPRange))); connect(sensor[i]->axis(QCPAxis::atLeft), SIGNAL(rangeChanged(QCPRange)), sensor[i]->axis(QCPAxis::atRight), SLOT(setRange(QCPRange))); // Horizontal drag and zoom sensor[i]->setRangeDrag(Qt::Horizontal); sensor[i]->setRangeZoom(Qt::Horizontal); ui->plot_sensors->setInteractions(QCP::iRangeDrag | QCP::iRangeZoom); connect(sensor[i]->axis(QCPAxis::atBottom), SIGNAL(rangeChanged(QCPRange)), X_Axis->axis(QCPAxis::atBottom), SLOT(setRange(QCPRange))); // Add plot to widget ui->plot_sensors->plotLayout()->addElement(i, 0, sensor[i]); sensor[i]->setMarginGroup(QCP::msLeft, marginGroup); // Graph sensorGraph[i] = ui->plot_sensors->addGraph(sensor[i]->axis(QCPAxis::atBottom), sensor[i]->axis(QCPAxis::atLeft)); sensorGraph[i]->setPen(*pen); sensorGraph[i]->setLineStyle(QCPGraph::lsLine); } // Use the Global X Axis to control the range of all the plots (for the horizontal drag event) for (int i = 0; i < controller->getNumSensors(); i++) connect(X_Axis->axis(QCPAxis::atBottom), SIGNAL(rangeChanged(QCPRange)), sensor[i]->axis(QCPAxis::atBottom), SLOT(setRange(QCPRange))); connect(X_Axis->axis(QCPAxis::atBottom), SIGNAL(rangeChanged(QCPRange, QCPRange)), this, SLOT(onXRangeChanged(QCPRange, QCPRange))); // Horizontal drag slider ui->plot_horizontalDrag->setRange(plotXAxis_minRange + X_Axis->axis(QCPAxis::atBottom)->range().size() / 2, plotXAxis_maxRange - X_Axis->axis(QCPAxis::atBottom)->range().size() / 2); ui->plot_horizontalDrag->setValue(X_Axis->axis(QCPAxis::atBottom)->range().lower + X_Axis->axis(QCPAxis::atBottom)->range().size() / 2); connect(ui->plot_horizontalDrag, SIGNAL(sliderMoved(int)), this, SLOT(onHorizontalDragChanged(int))); // PLOT: Center of mass ui->plot_CoM->plotLayout()->clear(); ui->plot_CoM->setAntialiasedElements(QCP::aeAll); QCPAxisRect *CoM_AxisRect = new QCPAxisRect(ui->plot_CoM); QCPMarginGroup *marginGroupCoM = new QCPMarginGroup(ui->plot_CoM); // Y Axis CoM_AxisRect->axis(QCPAxis::atLeft)->setRangeUpper(NUM_SENSORS+0.5); CoM_AxisRect->axis(QCPAxis::atLeft)->setRangeLower(0.5); CoM_AxisRect->axis(QCPAxis::atLeft)->setAutoTicks(true); CoM_AxisRect->axis(QCPAxis::atLeft)->setAutoTickStep(false); CoM_AxisRect->axis(QCPAxis::atLeft)->setTickStep(1); CoM_AxisRect->axis(QCPAxis::atLeft)->setAutoTickCount(NUM_SENSORS); CoM_AxisRect->axis(QCPAxis::atLeft)->setAutoSubTicks(false); CoM_AxisRect->axis(QCPAxis::atLeft)->setTickLabels(true); CoM_AxisRect->axis(QCPAxis::atLeft)->setLabel("Center of mass"); // X Axis CoM_AxisRect->axis(QCPAxis::atBottom)->setTickLabelType(QCPAxis::ltDateTime); CoM_AxisRect->axis(QCPAxis::atBottom)->setDateTimeFormat("mm:ss.zzz"); CoM_AxisRect->axis(QCPAxis::atBottom)->setAutoTicks(true); CoM_AxisRect->axis(QCPAxis::atBottom)->setAutoTickStep(true); CoM_AxisRect->axis(QCPAxis::atBottom)->setAutoTickCount(4); CoM_AxisRect->axis(QCPAxis::atBottom)->setAutoSubTicks(true); CoM_AxisRect->axis(QCPAxis::atBottom)->setTickLabels(true); CoM_AxisRect->axis(QCPAxis::atBottom)->setLabel("Time"); // Full Axes Box CoM_AxisRect->setupFullAxesBox(); connect(CoM_AxisRect->axis(QCPAxis::atBottom), SIGNAL(rangeChanged(QCPRange)), CoM_AxisRect->axis(QCPAxis::atTop), SLOT(setRange(QCPRange))); connect(CoM_AxisRect->axis(QCPAxis::atLeft), SIGNAL(rangeChanged(QCPRange)), CoM_AxisRect->axis(QCPAxis::atRight), SLOT(setRange(QCPRange))); // Horizontal drag and zoom CoM_AxisRect->setRangeDrag(Qt::Horizontal); CoM_AxisRect->setRangeZoom(Qt::Horizontal); ui->plot_CoM->setInteractions(QCP::iRangeDrag | QCP::iRangeZoom); connect(CoM_AxisRect->axis(QCPAxis::atBottom), SIGNAL(rangeChanged(QCPRange)), X_Axis->axis(QCPAxis::atBottom), SLOT(setRange(QCPRange))); connect(X_Axis->axis(QCPAxis::atBottom), SIGNAL(rangeChanged(QCPRange)), CoM_AxisRect->axis(QCPAxis::atBottom), SLOT(setRange(QCPRange))); // Add plot to widget ui->plot_CoM->plotLayout()->addElement(0, 0, CoM_AxisRect); CoM_AxisRect->setMarginGroup(QCP::msLeft, marginGroupCoM); // Graph QCPGraph *CoM_Graph; CoM_Graph = ui->plot_CoM->addGraph(CoM_AxisRect->axis(QCPAxis::atBottom), CoM_AxisRect->axis(QCPAxis::atLeft)); CoM_Graph->setPen(*pen); CoM_Graph->setLineStyle(QCPGraph::lsLine); // Horizontal drag slider ui->plotCoM_horizontalDrag->setRange(plotXAxis_minRange + X_Axis->axis(QCPAxis::atBottom)->range().size() / 2, plotXAxis_maxRange - X_Axis->axis(QCPAxis::atBottom)->range().size() / 2); ui->plotCoM_horizontalDrag->setValue(X_Axis->axis(QCPAxis::atBottom)->range().lower + X_Axis->axis(QCPAxis::atBottom)->range().size() / 2); connect(ui->plotCoM_horizontalDrag, SIGNAL(sliderMoved(int)), ui->plot_horizontalDrag, SLOT(setValue(int))); connect(ui->plotCoM_horizontalDrag, SIGNAL(sliderMoved(int)), this, SLOT(onHorizontalDragChanged(int))); // Subscribe to notifications controller->subscribeToSensorsNotifications(true, false); controller->subscribeToStatusNotifications(false, true); // First read of the status flags controller->readStatusFlags(); }
/*! Set the minimum value. \param min Minimum value \sa minValue(), setMaxValue() */ void QwtThermo::setMinValue(double min) { setRange(min, d_data->maxValue); }
void DataShowWidget::setupUi(){ ui_qcustomplot = new QCustomPlot(this); ui_qcustomplot->addGraph(); // blue line ui_qcustomplot->graph(0)->setPen(QPen(Qt::blue)); ui_qcustomplot->xAxis->setTickLabelType(QCPAxis::ltDateTime); ui_qcustomplot->xAxis->setDateTimeFormat("hh:mm:ss"); ui_qcustomplot->xAxis->setAutoTickStep(true); ui_qcustomplot->axisRect()->setupFullAxesBox(); ui_qcustomplot->yAxis->setRange(0, 6); connect(ui_qcustomplot->xAxis, SIGNAL(rangeChanged(QCPRange)), ui_qcustomplot->xAxis2, SLOT(setRange(QCPRange))); connect(ui_qcustomplot->yAxis, SIGNAL(rangeChanged(QCPRange)), ui_qcustomplot->yAxis2, SLOT(setRange(QCPRange))); QVBoxLayout * ui_layout_main = new QVBoxLayout(this); ui_layout_main->setContentsMargins(5, 0, 5, 0); QHBoxLayout * ui_layout_top = new QHBoxLayout(this); ui_layout_top->addWidget(&ui_show_title); ui_layout_top->addWidget(&ui_show_data); ui_layout_top->addWidget(&ui_show_unit); QSpacerItem* tanhuang = new QSpacerItem(1600,20,QSizePolicy::Preferred); ui_layout_top->addSpacerItem(tanhuang); ui_layout_main->addLayout(ui_layout_top); ui_layout_main->addWidget(ui_qcustomplot); this->setLayout(ui_layout_main); ui_show_title.setText(tr("<b>ËÙ¶È:<\b>")); ui_show_data.setText(tr("0.0")); ui_show_unit.setText(tr("cm/s")); ui_show_title.setMaximumHeight(20); ui_show_data.setMaximumHeight(20); ui_show_unit.setMaximumHeight(20); this->setAutoFillBackground(true); QPalette palette; palette.setColor(QPalette::Background, QColor(255, 255, 255)); this->setPalette(palette); }
/*! \property QProgressBar::minimum \brief the progress bar's minimum value When setting this property, the \l maximum is adjusted if necessary to ensure that the range remains valid. If the current value falls outside the new range, the progress bar is reset with reset(). */ void QProgressBar::setMinimum(int minimum) { setRange(minimum, qMax(d_func()->maximum, minimum)); }
void MainWindow::setupPlot(){ ui->customPlot->addGraph(); // blue line ui->customPlot->graph(0)->setPen(QPen(Qt::blue)); ui->customPlot->graph(0)->setBrush(QBrush(QColor(240, 255, 200))); ui->customPlot->graph(0)->setAntialiasedFill(false); ui->customPlot->addGraph(); // red line ui->customPlot->graph(1)->setPen(QPen(Qt::red)); ui->customPlot->graph(0)->setChannelFillGraph(ui->customPlot->graph(1)); ui->customPlot->addGraph(); // blue dot ui->customPlot->graph(2)->setPen(QPen(Qt::blue)); ui->customPlot->graph(2)->setLineStyle(QCPGraph::lsNone); ui->customPlot->graph(2)->setScatterStyle(QCPScatterStyle::ssDisc); ui->customPlot->addGraph(); // red dot ui->customPlot->graph(3)->setPen(QPen(Qt::red)); ui->customPlot->graph(3)->setLineStyle(QCPGraph::lsNone); ui->customPlot->graph(3)->setScatterStyle(QCPScatterStyle::ssDisc); // make left and bottom axes transfer their ranges to right and top axes: connect(ui->customPlot->xAxis, SIGNAL(rangeChanged(QCPRange)), ui->customPlot->xAxis2, SLOT(setRange(QCPRange))); connect(ui->customPlot->yAxis, SIGNAL(rangeChanged(QCPRange)), ui->customPlot->yAxis2, SLOT(setRange(QCPRange))); }
void QProgressBar::setMaximum(int maximum) { setRange(qMin(d_func()->minimum, maximum), maximum); }
void KIntNumInput::setMaxValue(int max) { setRange(m_spin->minValue(), max, m_spin->lineStep(), m_slider); }
void MainWindow::setup(QCustomPlot *customPlot) { #if QT_VERSION < QT_VERSION_CHECK(4, 7, 0) QMessageBox::critical(this, "", "You're using Qt < 4.7; Qt 4.7 required."); #endif // include this section to fully disable antialiasing for higher performance: /* customPlot->setNotAntialiasedElements(QCP::aeAll); QFont font; font.setStyleStrategy(QFont::NoAntialias); customPlot->xAxis->setTickLabelFont(font); customPlot->yAxis->setTickLabelFont(font); customPlot->legend->setFont(font); */ customPlot->addGraph(); // blue line customPlot->graph(0)->setPen(QPen(Qt::blue)); customPlot->graph(0)->setBrush(QBrush(QColor(240, 255, 200))); customPlot->graph(0)->setAntialiasedFill(false); customPlot->addGraph(); // blue dot customPlot->graph(1)->setPen(QPen(Qt::blue)); customPlot->graph(1)->setLineStyle(QCPGraph::lsNone); customPlot->graph(1)->setScatterStyle(QCPScatterStyle::ssDisc); customPlot->xAxis->setTickLabelType(QCPAxis::ltDateTime); customPlot->xAxis->setDateTimeFormat("hh:mm:ss"); customPlot->xAxis->setAutoTickStep(false); customPlot->xAxis->setTickStep(2); customPlot->axisRect()->setupFullAxesBox(); customPlot->yAxis->setRange(-85, -35); // make left and bottom axes transfer their ranges to right and top axes: connect(customPlot->xAxis, SIGNAL(rangeChanged(QCPRange)), customPlot->xAxis2, SLOT(setRange(QCPRange))); connect(customPlot->yAxis, SIGNAL(rangeChanged(QCPRange)), customPlot->yAxis2, SLOT(setRange(QCPRange))); }
SequenceDialog::SequenceDialog(QWidget &parent, CaptureFile &cf, SequenceInfo *info) : WiresharkDialog(parent, cf), ui(new Ui::SequenceDialog), info_(info), num_items_(0), packet_num_(0), sequence_w_(1) { ui->setupUi(this); loadGeometry(parent.width(), parent.height() * 4 / 5); QCustomPlot *sp = ui->sequencePlot; setWindowSubtitle(info_ ? tr("Call Flow") : tr("Flow")); if (!info_) { info_ = new SequenceInfo(sequence_analysis_info_new()); info_->sainfo()->type = SEQ_ANALYSIS_ANY; info_->sainfo()->all_packets = TRUE; } else { info_->ref(); num_items_ = sequence_analysis_get_nodes(info_->sainfo()); } seq_diagram_ = new SequenceDiagram(sp->yAxis, sp->xAxis2, sp->yAxis2); sp->addPlottable(seq_diagram_); // When dragging is enabled it's easy to drag past the lower and upper // bounds of each axis. Disable it for now. //sp->axisRect()->setRangeDragAxes(sp->xAxis2, sp->yAxis); //sp->setInteractions(QCP::iRangeDrag); sp->xAxis->setVisible(false); sp->xAxis->setPadding(0); sp->xAxis->setLabelPadding(0); sp->xAxis->setTickLabelPadding(0); QPen base_pen(ColorUtils::alphaBlend(palette().text(), palette().base(), 0.25)); base_pen.setWidthF(0.5); sp->xAxis2->setBasePen(base_pen); sp->yAxis->setBasePen(base_pen); sp->yAxis2->setBasePen(base_pen); sp->xAxis2->setVisible(true); sp->yAxis2->setVisible(true); key_text_ = new QCPItemText(sp); key_text_->setText(tr("Time")); sp->addItem(key_text_); key_text_->setPositionAlignment(Qt::AlignRight | Qt::AlignVCenter); key_text_->position->setType(QCPItemPosition::ptAbsolute); key_text_->setClipToAxisRect(false); comment_text_ = new QCPItemText(sp); comment_text_->setText(tr("Comment")); sp->addItem(comment_text_); comment_text_->setPositionAlignment(Qt::AlignLeft | Qt::AlignVCenter); comment_text_->position->setType(QCPItemPosition::ptAbsolute); comment_text_->setClipToAxisRect(false); one_em_ = QFontMetrics(sp->yAxis->labelFont()).height(); ui->horizontalScrollBar->setSingleStep(100 / one_em_); ui->verticalScrollBar->setSingleStep(100 / one_em_); ui->gridLayout->setSpacing(0); connect(sp->yAxis, SIGNAL(rangeChanged(QCPRange)), sp->yAxis2, SLOT(setRange(QCPRange))); ctx_menu_.addAction(ui->actionReset); ctx_menu_.addSeparator(); ctx_menu_.addAction(ui->actionMoveRight10); ctx_menu_.addAction(ui->actionMoveLeft10); ctx_menu_.addAction(ui->actionMoveUp10); ctx_menu_.addAction(ui->actionMoveDown10); ctx_menu_.addAction(ui->actionMoveRight1); ctx_menu_.addAction(ui->actionMoveLeft1); ctx_menu_.addAction(ui->actionMoveUp1); ctx_menu_.addAction(ui->actionMoveDown1); ctx_menu_.addSeparator(); ctx_menu_.addAction(ui->actionGoToPacket); ctx_menu_.addAction(ui->actionGoToNextPacket); ctx_menu_.addAction(ui->actionGoToPreviousPacket); ui->showComboBox->setCurrentIndex(0); ui->addressComboBox->setCurrentIndex(0); QComboBox *fcb = ui->flowComboBox; fcb->addItem(ui->actionFlowAny->text(), SEQ_ANALYSIS_ANY); fcb->addItem(ui->actionFlowTcp->text(), SEQ_ANALYSIS_TCP); ui->flowComboBox->setCurrentIndex(info_->sainfo()->type); if (info_->sainfo()->type == SEQ_ANALYSIS_VOIP) { ui->flowComboBox->blockSignals(true); ui->controlFrame->hide(); } QPushButton *save_bt = ui->buttonBox->button(QDialogButtonBox::Save); save_bt->setText(tr("Save As" UTF8_HORIZONTAL_ELLIPSIS)); ProgressFrame::addToButtonBox(ui->buttonBox, &parent); connect(ui->horizontalScrollBar, SIGNAL(valueChanged(int)), this, SLOT(hScrollBarChanged(int))); connect(ui->verticalScrollBar, SIGNAL(valueChanged(int)), this, SLOT(vScrollBarChanged(int))); connect(sp->xAxis2, SIGNAL(rangeChanged(QCPRange)), this, SLOT(xAxisChanged(QCPRange))); connect(sp->yAxis, SIGNAL(rangeChanged(QCPRange)), this, SLOT(yAxisChanged(QCPRange))); connect(sp, SIGNAL(mousePress(QMouseEvent*)), this, SLOT(diagramClicked(QMouseEvent*))); connect(sp, SIGNAL(mouseMove(QMouseEvent*)), this, SLOT(mouseMoved(QMouseEvent*))); connect(sp, SIGNAL(mouseWheel(QWheelEvent*)), this, SLOT(mouseWheeled(QWheelEvent*))); connect(this, SIGNAL(goToPacket(int)), seq_diagram_, SLOT(setSelectedPacket(int))); disconnect(ui->buttonBox, SIGNAL(accepted()), this, SLOT(accept())); }
KoXYColorSelector::KoXYColorSelector( const KoColorSpace* colorSpace, QWidget *parent ) : KXYSelector( parent ) , m_colorSpace(colorSpace) { setRange(0, 0, 255, 255); }
/*! \property QIntValidator::bottom \brief the validator's lowest acceptable value By default, this property's value is derived from the lowest signed integer available (typically -2147483647). \sa setRange() */ void QIntValidator::setBottom(int bottom) { setRange(bottom, top()); }
PassRefPtrWillBeRawPtr<Interpolation> StringKeyframe::CSSPropertySpecificKeyframe::maybeCreateInterpolation(PropertyHandle propertyHandle, Keyframe::PropertySpecificKeyframe& end, Element* element, const ComputedStyle* baseStyle) const { CSSPropertyID property = propertyHandle.cssProperty(); const Vector<const InterpolationType*>* applicableTypes = applicableTypesForProperty(property); if (applicableTypes) return InvalidatableStyleInterpolation::create(*applicableTypes, *this, toCSSPropertySpecificKeyframe(end)); // TODO(alancutter): Remove the remainder of this function. // FIXME: Refactor this into a generic piece that lives in InterpolationEffect, and a template parameter specific converter. CSSValue* fromCSSValue = m_value.get(); CSSValue* toCSSValue = toCSSPropertySpecificKeyframe(end).value(); InterpolationRange range = RangeAll; // FIXME: Remove this flag once we can rely on legacy's behaviour being correct. bool forceDefaultInterpolation = false; // FIXME: Remove this check once neutral keyframes are implemented in StringKeyframes. if (!fromCSSValue || !toCSSValue) return DeferredLegacyStyleInterpolation::create(fromCSSValue, toCSSValue, property); ASSERT(fromCSSValue && toCSSValue); if (!CSSPropertyMetadata::isInterpolableProperty(property)) { if (fromCSSValue == toCSSValue) return ConstantStyleInterpolation::create(fromCSSValue, property); return nullptr; } if (fromCSSValue->isCSSWideKeyword() || toCSSValue->isCSSWideKeyword()) return createLegacyStyleInterpolation(property, end, element, baseStyle); switch (property) { case CSSPropertyLineHeight: if (LengthStyleInterpolation::canCreateFrom(*fromCSSValue) && LengthStyleInterpolation::canCreateFrom(*toCSSValue)) return LengthStyleInterpolation::create(*fromCSSValue, *toCSSValue, property, RangeNonNegative); if (DoubleStyleInterpolation::canCreateFrom(*fromCSSValue) && DoubleStyleInterpolation::canCreateFrom(*toCSSValue)) return DoubleStyleInterpolation::create(*fromCSSValue, *toCSSValue, property, true, RangeNonNegative); break; case CSSPropertyBorderBottomWidth: case CSSPropertyBorderLeftWidth: case CSSPropertyBorderRightWidth: case CSSPropertyBorderTopWidth: case CSSPropertyFlexBasis: case CSSPropertyFontSize: case CSSPropertyHeight: case CSSPropertyMaxHeight: case CSSPropertyMaxWidth: case CSSPropertyMinHeight: case CSSPropertyMinWidth: case CSSPropertyOutlineWidth: case CSSPropertyPaddingBottom: case CSSPropertyPaddingLeft: case CSSPropertyPaddingRight: case CSSPropertyPaddingTop: case CSSPropertyPerspective: case CSSPropertyR: case CSSPropertyRx: case CSSPropertyRy: case CSSPropertyShapeMargin: case CSSPropertyStrokeWidth: case CSSPropertyWebkitBorderHorizontalSpacing: case CSSPropertyWebkitBorderVerticalSpacing: case CSSPropertyWebkitColumnGap: case CSSPropertyWebkitColumnWidth: case CSSPropertyWidth: range = RangeNonNegative; // Fall through case CSSPropertyBaselineShift: case CSSPropertyBottom: case CSSPropertyCx: case CSSPropertyCy: case CSSPropertyLeft: case CSSPropertyLetterSpacing: case CSSPropertyMarginBottom: case CSSPropertyMarginLeft: case CSSPropertyMarginRight: case CSSPropertyMarginTop: case CSSPropertyMotionOffset: case CSSPropertyOutlineOffset: case CSSPropertyRight: case CSSPropertyStrokeDashoffset: case CSSPropertyTop: case CSSPropertyVerticalAlign: case CSSPropertyWordSpacing: case CSSPropertyWebkitColumnRuleWidth: case CSSPropertyWebkitPerspectiveOriginX: case CSSPropertyWebkitPerspectiveOriginY: case CSSPropertyWebkitTransformOriginX: case CSSPropertyWebkitTransformOriginY: case CSSPropertyWebkitTransformOriginZ: case CSSPropertyX: case CSSPropertyY: if (LengthStyleInterpolation::canCreateFrom(*fromCSSValue, property) && LengthStyleInterpolation::canCreateFrom(*toCSSValue, property)) return LengthStyleInterpolation::create(*fromCSSValue, *toCSSValue, property, range); // FIXME: Handle keywords e.g. 'smaller', 'larger'. if (property == CSSPropertyFontSize) return createLegacyStyleInterpolation(property, end, element, baseStyle); // FIXME: Handle keywords e.g. 'baseline', 'sub'. if (property == CSSPropertyBaselineShift) return createLegacyStyleInterpolation(property, end, element, baseStyle); break; case CSSPropertyOrphans: case CSSPropertyWidows: case CSSPropertyZIndex: case CSSPropertyWebkitColumnCount: case CSSPropertyShapeImageThreshold: case CSSPropertyFillOpacity: case CSSPropertyFloodOpacity: case CSSPropertyFontSizeAdjust: case CSSPropertyOpacity: case CSSPropertyStopOpacity: case CSSPropertyStrokeOpacity: case CSSPropertyStrokeMiterlimit: if (DoubleStyleInterpolation::canCreateFrom(*fromCSSValue) && DoubleStyleInterpolation::canCreateFrom(*toCSSValue)) return DoubleStyleInterpolation::create(*fromCSSValue, *toCSSValue, property, toCSSPrimitiveValue(fromCSSValue)->isNumber(), setRange(property)); break; case CSSPropertyMotionRotation: { RefPtrWillBeRawPtr<Interpolation> interpolation = DoubleStyleInterpolation::maybeCreateFromMotionRotation(*fromCSSValue, *toCSSValue, property); if (interpolation) return interpolation.release(); break; } case CSSPropertyVisibility: if (VisibilityStyleInterpolation::canCreateFrom(*fromCSSValue) && VisibilityStyleInterpolation::canCreateFrom(*toCSSValue) && (VisibilityStyleInterpolation::isVisible(*fromCSSValue) || VisibilityStyleInterpolation::isVisible(*toCSSValue))) return VisibilityStyleInterpolation::create(*fromCSSValue, *toCSSValue, property); break; case CSSPropertyBackgroundColor: case CSSPropertyBorderBottomColor: case CSSPropertyBorderLeftColor: case CSSPropertyBorderRightColor: case CSSPropertyBorderTopColor: case CSSPropertyColor: case CSSPropertyFill: case CSSPropertyFloodColor: case CSSPropertyLightingColor: case CSSPropertyOutlineColor: case CSSPropertyStopColor: case CSSPropertyStroke: case CSSPropertyTextDecorationColor: case CSSPropertyWebkitColumnRuleColor: case CSSPropertyWebkitTextStrokeColor: { RefPtrWillBeRawPtr<Interpolation> interpolation = ColorStyleInterpolation::maybeCreateFromColor(*fromCSSValue, *toCSSValue, property); if (interpolation) return interpolation.release(); // Current color should use LegacyStyleInterpolation if (ColorStyleInterpolation::shouldUseLegacyStyleInterpolation(*fromCSSValue, *toCSSValue)) return createLegacyStyleInterpolation(property, end, element, baseStyle); break; } case CSSPropertyBorderImageSource: case CSSPropertyListStyleImage: case CSSPropertyWebkitMaskBoxImageSource: if (fromCSSValue == toCSSValue) return ConstantStyleInterpolation::create(fromCSSValue, property); if (ImageStyleInterpolation::canCreateFrom(*fromCSSValue) && ImageStyleInterpolation::canCreateFrom(*toCSSValue)) return ImageStyleInterpolation::create(*fromCSSValue, *toCSSValue, property); forceDefaultInterpolation = true; break; case CSSPropertyBorderBottomLeftRadius: case CSSPropertyBorderBottomRightRadius: case CSSPropertyBorderTopLeftRadius: case CSSPropertyBorderTopRightRadius: range = RangeNonNegative; // Fall through case CSSPropertyObjectPosition: if (LengthPairStyleInterpolation::canCreateFrom(*fromCSSValue) && LengthPairStyleInterpolation::canCreateFrom(*toCSSValue)) return LengthPairStyleInterpolation::create(*fromCSSValue, *toCSSValue, property, range); break; case CSSPropertyPerspectiveOrigin: case CSSPropertyTransformOrigin: { RefPtrWillBeRawPtr<Interpolation> interpolation = ListStyleInterpolation<LengthStyleInterpolation>::maybeCreateFromList(*fromCSSValue, *toCSSValue, property, range); if (interpolation) return interpolation.release(); // FIXME: Handle keywords: top, right, left, center, bottom return createLegacyStyleInterpolation(property, end, element, baseStyle); } case CSSPropertyBoxShadow: case CSSPropertyTextShadow: { RefPtrWillBeRawPtr<Interpolation> interpolation = ListStyleInterpolation<ShadowStyleInterpolation>::maybeCreateFromList(*fromCSSValue, *toCSSValue, property); if (interpolation) return interpolation.release(); // FIXME: AnimatableShadow incorrectly animates between inset and non-inset values so it will never indicate it needs default interpolation if (ShadowStyleInterpolation::usesDefaultStyleInterpolation(*fromCSSValue, *toCSSValue)) { forceDefaultInterpolation = true; break; } // FIXME: Handle interpolation from/to none, unspecified color values return createLegacyStyleInterpolation(property, end, element, baseStyle); } case CSSPropertyClip: { if (LengthBoxStyleInterpolation::usesDefaultInterpolation(*fromCSSValue, *toCSSValue)) { forceDefaultInterpolation = true; break; } RefPtrWillBeRawPtr<Interpolation> interpolation = LengthBoxStyleInterpolation::maybeCreateFrom(*fromCSSValue, *toCSSValue, property); if (interpolation) return interpolation.release(); break; } case CSSPropertyBorderImageSlice: case CSSPropertyWebkitMaskBoxImageSlice: { RefPtrWillBeRawPtr<Interpolation> interpolation = ImageSliceStyleInterpolation::maybeCreate(*fromCSSValue, *toCSSValue, property); if (interpolation) return interpolation.release(); if (ImageSliceStyleInterpolation::usesDefaultInterpolation(*fromCSSValue, *toCSSValue)) forceDefaultInterpolation = true; break; } case CSSPropertyStrokeDasharray: { RefPtrWillBeRawPtr<Interpolation> interpolation = SVGStrokeDasharrayStyleInterpolation::maybeCreate(*fromCSSValue, *toCSSValue, property); if (interpolation) return interpolation.release(); break; } case CSSPropertyWebkitFilter: { RefPtrWillBeRawPtr<Interpolation> interpolation = FilterStyleInterpolation::maybeCreateList(*fromCSSValue, *toCSSValue, property); if (interpolation) return interpolation.release(); // FIXME: Support drop shadow interpolation. return createLegacyStyleInterpolation(property, end, element, baseStyle); break; } case CSSPropertyTranslate: { RefPtrWillBeRawPtr<Interpolation> interpolation = ListStyleInterpolation<LengthStyleInterpolation>::maybeCreateFromList(*fromCSSValue, *toCSSValue, property, range); if (interpolation) return interpolation.release(); // TODO(soonm): Legacy mode is used when from and to cssvaluelist length does not match. return createLegacyStyleInterpolation(property, end, element, baseStyle); break; } case CSSPropertyScale: { RefPtrWillBeRawPtr<Interpolation> interpolation = ListStyleInterpolation<DoubleStyleInterpolation>::maybeCreateFromList(*fromCSSValue, *toCSSValue, property, range); if (interpolation) return interpolation.release(); // TODO(soonm): Legacy mode is used when from and to cssvaluelist length does not match. return createLegacyStyleInterpolation(property, end, element, baseStyle); break; } default: // Fall back to LegacyStyleInterpolation. return createLegacyStyleInterpolation(property, end, element, baseStyle); break; } if (fromCSSValue == toCSSValue) return ConstantStyleInterpolation::create(fromCSSValue, property); if (!forceDefaultInterpolation) { ASSERT(AnimatableValue::usesDefaultInterpolation( StyleResolver::createAnimatableValueSnapshot(*element, baseStyle, property, fromCSSValue).get(), StyleResolver::createAnimatableValueSnapshot(*element, baseStyle, property, toCSSValue).get())); } return nullptr; }