uint8_t MD_TCS230::readFSM(uint8_t s) // Finite State Machine to read a value (internal function) { static const uint8_t seq[] = { TCS230_RGB_R, TCS230_RGB_G, TCS230_RGB_B }; static uint8_t currCol; // index for seq above switch(s) { case 0: // enable the hardware for reading DUMPS("\n0"); currCol = 0; // RGB_R but we don't care setEnable(true); s++; // fall through to the next state case 1: // select a filter and start a reading DUMPS("\n1"); setFilter(seq[currCol]); FreqCount.begin(1000/_readDiv); s++; break; case 2: // see if a value is available DUMPS("2"); if (FreqCount.available()) { DUMP(" VALUE ", FreqCount.read()); // read the value and save it _Fo.value[seq[currCol++]] = FreqCount.read() * _readDiv; if (currCol < RGB_SIZE) { // loop around again on next call to available() s--; } else { // end this reading session FreqCount.end(); setEnable(false); RGBTransformation(); s = 0; } } break; } return(s); }
UIConfig::UIConfig() { m_Scale = 1; m_band = 0; m_column = 0; m_row = 0; debug = 0; setFilter( NN_FILTER ); setCoordMode( ANA_MODE ); m_delta_treshold = 0; m_translate = true; m_sync = true; m_aim = true; }
Node::~Node() { #if FZ_GL_SHADERS setFilter(NULL); setGLProgram(nullptr); #endif if(p_camera) delete p_camera; Node *child; FZ_LIST_FOREACH_MUTABLE(m_children, child) { child->setParent(NULL); child->release(); }
void sim_bandstack_cb(GtkWidget *widget, gpointer data) { BANDSTACK_ENTRY *entry; fprintf(stderr,"sim_bandstack_cb\n"); if(function) { entry=bandstack_entry_previous(); } else { entry=bandstack_entry_next(); } setFrequency(entry->frequencyA); setMode(entry->mode); FILTER* band_filters=filters[entry->mode]; FILTER* band_filter=&band_filters[entry->filter]; setFilter(band_filter->low,band_filter->high); vfo_update(NULL); }
void LensDistortionTool::preparePreview() { double m = d->mainInput->value(); double e = d->edgeInput->value(); double r = d->rescaleInput->value(); double b = d->brightenInput->value(); LensDistortionFilter transformPreview(&d->previewRasterImage, 0, m, e, r, b, 0, 0); transformPreview.startFilterDirectly(); d->maskPreviewLabel->setPixmap(transformPreview.getTargetImage().convertToPixmap()); ImageIface* const iface = d->previewWidget->imageIface(); setFilter(new LensDistortionFilter(iface->original(), this, m, e, r, b, 0, 0)); }
Message::Message(const std::string& message) : m_command (), m_commandStr (), m_idPattern (), m_filterBits (Filter::Global), m_idMatchMethod (nullptr), m_tagMatchMethod (nullptr) { if (!message.empty()) { setFilter(message); std::size_t startPos = message.find_first_of(']'); m_command << (startPos == std::string::npos ? message : message.substr(std::min(message.length() - 1, message.find_first_not_of(' ', startPos + 1)))); } }
bool MultiQFileDialog::eventFilter(QObject *obj, QEvent *e) { if (e->type() == QEvent::KeyPress) { QKeyEvent* keyEvent = dynamic_cast<QKeyEvent*>(e); Qt::KeyboardModifiers modifiers = QApplication::queryKeyboardModifiers(); if (modifiers.testFlag(Qt::ControlModifier) && keyEvent && keyEvent->key() == Qt::Key_H) { if (showHidden) { if (multiSelect) { setFilter(QDir::AllDirs | QDir::AllEntries | QDir::NoDotAndDotDot); } else { setFilter(QDir::AllDirs | QDir::NoDotAndDotDot); } } else { if (multiSelect) { setFilter(QDir::AllDirs | QDir::AllEntries | QDir::Hidden | QDir::System | QDir::NoDotAndDotDot); } else { setFilter(QDir::AllDirs | QDir::Hidden | QDir::System | QDir::NoDotAndDotDot); } } showHidden = !showHidden; } } return QFileDialog::eventFilter(obj, e); }
ImageViewerDirModel::ImageViewerDirModel(QObject *parent /*= 0*/) : QDirModel(parent) { //insertColumn(1); QStringList nameFilterList; QList<QByteArray> formats = QImageReader::supportedImageFormats(); for (QList<QByteArray>::iterator it = formats.begin(); it != formats.end(); ++it) { QString filter("*."); filter.append(it->data()); nameFilterList << filter; } setNameFilters(nameFilterList); setFilter(QDir::Files); }
void KNoteTip::timerEvent(QTimerEvent *) { killTimers(); if(!isVisible()) { startTimer(15000); // show the tooltip for 15 sec reposition(); show(); } else { setFilter(false); hide(); } }
Status ParsedUpdate::parseQueryToCQ() { dassert(!_canonicalQuery.get()); const ExtensionsCallbackReal extensionsCallback(_opCtx, &_request->getNamespaceString()); // The projection needs to be applied after the update operation, so we do not specify a // projection during canonicalization. auto qr = stdx::make_unique<QueryRequest>(_request->getNamespaceString()); qr->setFilter(_request->getQuery()); qr->setSort(_request->getSort()); qr->setCollation(_request->getCollation()); qr->setExplain(_request->isExplain()); // Limit should only used for the findAndModify command when a sort is specified. If a sort // is requested, we want to use a top-k sort for efficiency reasons, so should pass the // limit through. Generally, a update stage expects to be able to skip documents that were // deleted/modified under it, but a limit could inhibit that and give an EOF when the update // has not actually updated a document. This behavior is fine for findAndModify, but should // not apply to update in general. if (!_request->isMulti() && !_request->getSort().isEmpty()) { qr->setLimit(1); } // $expr is not allowed in the query for an upsert, since it is not clear what the equality // extraction behavior for $expr should be. MatchExpressionParser::AllowedFeatureSet allowedMatcherFeatures = MatchExpressionParser::kAllowAllSpecialFeatures; if (_request->isUpsert()) { allowedMatcherFeatures &= ~MatchExpressionParser::AllowedFeatures::kExpr; } boost::intrusive_ptr<ExpressionContext> expCtx; auto statusWithCQ = CanonicalQuery::canonicalize( _opCtx, std::move(qr), std::move(expCtx), extensionsCallback, allowedMatcherFeatures); if (statusWithCQ.isOK()) { _canonicalQuery = std::move(statusWithCQ.getValue()); } if (statusWithCQ.getStatus().code() == ErrorCodes::QueryFeatureNotAllowed) { // The default error message for disallowed $expr is not descriptive enough, so we rewrite // it here. return {ErrorCodes::QueryFeatureNotAllowed, "$expr is not allowed in the query predicate for an upsert"}; } return statusWithCQ.getStatus(); }
bool Image::loadVolatilePOT() { glGenTextures(1,(GLuint *)&texture); bindTexture(texture); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); float p2width = next_p2(width); float p2height = next_p2(height); float s = width/p2width; float t = height/p2height; vertices[1].t = t; vertices[2].t = t; vertices[2].s = s; vertices[3].s = s; glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, (GLsizei)p2width, (GLsizei)p2height, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0); glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, (GLsizei)width, (GLsizei)height, GL_RGBA, GL_UNSIGNED_BYTE, data->getData()); setMipmapSharpness(mipmapsharpness); setFilter(filter); setWrap(wrap); return true; }
FilmModel::FilmModel(QObject *parent) : QSqlTableModel(parent) { setTable("films"); setEditStrategy(QSqlTableModel::OnManualSubmit); setSort(0, Qt::AscendingOrder); setFilter(""); select(); setHeaderData(1, Qt::Horizontal, "Name"); setHeaderData(2, Qt::Horizontal, "Year"); setHeaderData(3, Qt::Horizontal, "Country"); setHeaderData(4, Qt::Horizontal, "Director"); setHeaderData(5, Qt::Horizontal, "Actors"); setHeaderData(6, Qt::Horizontal, "Type"); setHeaderData(7, Qt::Horizontal, "Genre"); setHeaderData(8, Qt::Horizontal, "Score"); }
void ActionEditor::setFormWindow(QDesignerFormWindowInterface *formWindow) { if (formWindow != 0 && formWindow->mainContainer() == 0) formWindow = 0; // we do NOT rely on this function to update the action editor if (m_formWindow == formWindow) return; if (m_formWindow != 0) { const ActionList actionList = m_formWindow->mainContainer()->findChildren<QAction*>(); foreach (QAction *action, actionList) disconnect(action, SIGNAL(changed()), this, SLOT(slotActionChanged())); } m_formWindow = formWindow; m_actionView->model()->clearActions(); m_actionEdit->setEnabled(false); #ifndef QT_NO_CLIPBOARD m_actionCopy->setEnabled(false); m_actionCut->setEnabled(false); #endif m_actionDelete->setEnabled(false); if (!formWindow || !formWindow->mainContainer()) { m_actionNew->setEnabled(false); m_filterWidget->setEnabled(false); return; } m_actionNew->setEnabled(true); m_filterWidget->setEnabled(true); const ActionList actionList = formWindow->mainContainer()->findChildren<QAction*>(); foreach (QAction *action, actionList) if (!action->isSeparator() && core()->metaDataBase()->item(action) != 0) { // Show unless it has a menu. However, listen for change on menu actions also as it might be removed if (!action->menu()) m_actionView->model()->addAction(action); connect(action, SIGNAL(changed()), this, SLOT(slotActionChanged())); } setFilter(m_filter); }
void sim_band_cb(GtkWidget *widget, gpointer data) { BAND* band; BANDSTACK_ENTRY *entry; fprintf(stderr,"sim_band_cb\n"); int b=band_get_current(); if(function) { b--; if(b<0) { b=BANDS-1; } #ifdef LIMESDR if(protocol!=LIMESDR_PROTOCOL) { if(b==band3400) { b=band6; } } #endif } else { b++; if(b>=BANDS) { b=0; } #ifdef LIMESDR if(protocol!=LIMESDR_PROTOCOL) { if(b==band70) { b=bandGen; } } #endif } band=band_set_current(b); entry=bandstack_entry_get_current(); setFrequency(entry->frequencyA); setMode(entry->mode); FILTER* band_filters=filters[entry->mode]; FILTER* band_filter=&band_filters[entry->filter]; setFilter(band_filter->low,band_filter->high); band=band_get_current_band(); set_alex_rx_antenna(band->alexRxAntenna); set_alex_tx_antenna(band->alexTxAntenna); set_alex_attenuation(band->alexAttenuation); vfo_update(NULL); }
RKImportDialog::RKImportDialog (const QString &context_id, QWidget *parent) : KFileDialog (KUrl (), QString (), parent, format_selector=new RKImportDialogFormatSelector ()) { RK_TRACE (DIALOGS); setModal (false); context = RKComponentMap::getContext (context_id); if (!context) { KMessageBox::sorry (this, i18n ("No plugins defined for context '%1'", context_id)); return; } component_ids = context->components (); QString formats = "*|" + i18n ("All Files") + " (*)\n"; int format_count = 0; for (QStringList::const_iterator it = component_ids.constBegin (); it != component_ids.constEnd (); ++it) { if (format_count++) formats.append ('\n'); RKComponentHandle *handle = RKComponentMap::getComponentHandle (*it); if (!handle) { RK_ASSERT (false); continue; } QString filter = handle->getAttributeValue ("format"); QString label = handle->getAttributeLabel ("format"); QString elabel = label; elabel.replace ('/', "\\/"); elabel.replace ('|', "\\|"); formats.append (filter + '|' + elabel + " (" + filter + ')'); format_labels.append (label); filters.append (filter); } // file format selection box format_selector->combo->insertItems (0, format_labels); // initialize setMode (KFile::File | KFile::ExistingOnly | KFile::LocalOnly); setFilter (formats); connect (this, SIGNAL (filterChanged(QString)), this, SLOT (filterWasChanged(QString))); filterWasChanged (QString ()); show (); }
/** * Test that hitting the cached plan stage trial period's threshold for work cycles causes the * query to be replanned. Also verify that the replanning results in a new plan cache entry. */ TEST_F(QueryStageCachedPlan, QueryStageCachedPlanHitMaxWorks) { AutoGetCollectionForReadCommand ctx(&_opCtx, nss); Collection* collection = ctx.getCollection(); ASSERT(collection); // Query can be answered by either index on "a" or index on "b". auto qr = stdx::make_unique<QueryRequest>(nss); qr->setFilter(fromjson("{a: {$gte: 8}, b: 1}")); auto statusWithCQ = CanonicalQuery::canonicalize(opCtx(), std::move(qr)); ASSERT_OK(statusWithCQ.getStatus()); const std::unique_ptr<CanonicalQuery> cq = std::move(statusWithCQ.getValue()); // We shouldn't have anything in the plan cache for this shape yet. PlanCache* cache = collection->infoCache()->getPlanCache(); ASSERT(cache); ASSERT_EQ(cache->get(*cq).state, PlanCache::CacheEntryState::kNotPresent); // Get planner params. QueryPlannerParams plannerParams; fillOutPlannerParams(&_opCtx, collection, cq.get(), &plannerParams); // Set up queued data stage to take a long time before returning EOF. Should be long // enough to trigger a replan. const size_t decisionWorks = 10; const size_t mockWorks = 1U + static_cast<size_t>(internalQueryCacheEvictionRatio * decisionWorks); auto mockChild = stdx::make_unique<QueuedDataStage>(&_opCtx, &_ws); for (size_t i = 0; i < mockWorks; i++) { mockChild->pushBack(PlanStage::NEED_TIME); } CachedPlanStage cachedPlanStage( &_opCtx, collection, &_ws, cq.get(), plannerParams, decisionWorks, mockChild.release()); // This should succeed after triggering a replan. PlanYieldPolicy yieldPolicy(PlanExecutor::NO_YIELD, _opCtx.getServiceContext()->getFastClockSource()); ASSERT_OK(cachedPlanStage.pickBestPlan(&yieldPolicy)); ASSERT_EQ(getNumResultsForStage(_ws, &cachedPlanStage, cq.get()), 2U); // This time we expect to find something in the plan cache. Replans after hitting the // works threshold result in a cache entry. ASSERT_EQ(cache->get(*cq).state, PlanCache::CacheEntryState::kPresentInactive); }
void JConsoleHandler::configure() { //TODO JLogManager* manager = JLogManager::getLogManager(); //TODO JString cname = getClass()->getName(); setLevel(JLevel::INFO);//TODO manager.getLevelProperty(cname +".level", Level.INFO)); setFilter(NULL);//TODO manager.getFilterProperty(cname +".filter", null)); setFormatter(new JSimpleFormatter());//TODO manager.getFormatterProperty(cname +".formatter", new SimpleFormatter())); try { setEncoding("");//TODO manager.getStringProperty(cname +".encoding", null)); } catch (JException* ex) { delete ex; try { setEncoding(""); } catch (JException* ex2) { delete ex2; } } }
void Terrain::setup() { frames = 0; meshResolution = 128; dist = 300; begin.set(18, 3, 194); end.set(38, 172, 22); indexLow = 0; indexHigh = 0; setColors(begin, end); gridSurfaceSetup(); setPeeks(); setBands(meshResolution); setFilter(1.25f); setSmoothingFactor(0.975f); cam.setDistance(dist); cam.enableMouseInput(); ofBackground(0, 0, 0); }
int qtMonitor::qt_metacall(QMetaObject::Call _c, int _id, void **_a) { _id = QMainWindow::qt_metacall(_c, _id, _a); if (_id < 0) return _id; if (_c == QMetaObject::InvokeMetaMethod) { switch (_id) { case 0: band_160_buttonPressed(); break; case 1: band_80_buttonPressed(); break; case 2: band_60_buttonPressed(); break; case 3: band_40_buttonPressed(); break; case 4: band_30_buttonPressed(); break; case 5: band_20_buttonPressed(); break; case 6: band_17_buttonPressed(); break; case 7: band_15_buttonPressed(); break; case 8: band_12_buttonPressed(); break; case 9: band_10_buttonPressed(); break; case 10: band_6_buttonPressed(); break; case 11: band_gen_buttonPressed(); break; case 12: mode_lsb_buttonPressed(); break; case 13: mode_usb_buttonPressed(); break; case 14: mode_dsb_buttonPressed(); break; case 15: mode_cwl_buttonPressed(); break; case 16: mode_cwu_buttonPressed(); break; case 17: mode_am_buttonPressed(); break; case 18: connect_buttonPressed(); break; case 19: socketError((*reinterpret_cast< QAbstractSocket::SocketError(*)>(_a[1]))); break; case 20: connected(); break; case 21: socketData(); break; case 22: update(); break; case 23: setMode((*reinterpret_cast< int(*)>(_a[1]))); break; case 24: setFilter((*reinterpret_cast< int(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break; case 25: setFrequency((*reinterpret_cast< long long(*)>(_a[1]))); break; case 26: moveFrequency((*reinterpret_cast< int(*)>(_a[1]))); break; case 27: vfo_dialMoved((*reinterpret_cast< int(*)>(_a[1]))); break; case 28: afgain_dialMoved((*reinterpret_cast< int(*)>(_a[1]))); break; case 29: setGain((*reinterpret_cast< int(*)>(_a[1]))); break; case 30: audioChanged((*reinterpret_cast< int(*)>(_a[1]))); break; default: ; } _id -= 31; } return _id; }
PlaylistWidget::PlaylistWidget(QWidget *parent) : QWidget(parent), ui(new Ui::PlaylistWidget) { ui->setupUi(this); m_delegate = new TrackDelegate(this); ui->listView->setItemDelegate(m_delegate); ui->listView->setAcceptDrops(true); m_model = new PlaylistModel(this); m_model->setTrackCycler(Player::instance()->cycler()); m_model->setMediaLibrary(Player::instance()->media()); m_model->setFavoritesManager(Player::instance()->favorites()); m_favFilterModel = new FavoritesFilterModel(this); m_favFilterModel->setSourceModel(m_model); m_favFilterModel->setDynamicSortFilter(true); connect(ui->listView, SIGNAL(showFavoritesToggled(bool)), this, SLOT(setFavoritesFilterEnabled(bool))); connect(m_favFilterModel, SIGNAL(enabledChanged(bool)), ui->listView, SLOT(toggleFavorites(bool))); m_sortModel = new QSortFilterProxyModel(this); m_sortModel->setSourceModel(m_favFilterModel); m_sortModel->setFilterRole(PlaylistModel::SearchRole); m_sortModel->setDynamicSortFilter(true); m_sortModel->setFilterCaseSensitivity(Qt::CaseInsensitive); ui->listView->setModel(m_sortModel); connect(ui->clearButton, SIGNAL(clicked()), ui->filterEdit, SLOT(clear())); connect(ui->filterEdit, SIGNAL(textChanged(QString)), this, SLOT(setFilter(QString))); TrackCycler * cycler = Player::instance()->cycler(); if (cycler != 0) { connect(cycler, SIGNAL(trackChanged(PlayId)), this, SLOT(onTrackChanged(PlayId))); } PlaylistHistory *history = Player::instance()->history(); if (history != 0) { connect(history,SIGNAL(currentChanged(Playlist*)), this, SLOT(setPlaylist(Playlist*))); connect(history,SIGNAL(countChanged()), this, SLOT(onPlaylistCountChanged())); setPlaylist(history->current()); }
void run() { OldClientWriteContext ctx(&_txn, nss.ns()); addIndex(BSON("a" << 1 << "b" << 1)); addIndex(BSON("a" << 1 << "c" << 1)); // Every doc matches. insert(BSON("_id" << 1 << "a" << 1)); insert(BSON("_id" << 2 << "a" << 2)); insert(BSON("_id" << 3 << "a" << 3)); insert(BSON("_id" << 4)); auto qr = stdx::make_unique<QueryRequest>(nss); qr->setFilter(fromjson("{$or: [{a: 1}, {a: {$ne:1}}]}")); qr->setSort(BSON("d" << 1)); auto cq = unittest::assertGet(CanonicalQuery::canonicalize( txn(), std::move(qr), ExtensionsCallbackDisallowExtensions())); Collection* collection = ctx.getCollection(); QueryPlannerParams plannerParams; fillOutPlannerParams(&_txn, collection, cq.get(), &plannerParams); WorkingSet ws; std::unique_ptr<SubplanStage> subplan( new SubplanStage(&_txn, collection, &ws, plannerParams, cq.get())); PlanYieldPolicy yieldPolicy(PlanExecutor::YIELD_MANUAL, _clock); ASSERT_OK(subplan->pickBestPlan(&yieldPolicy)); size_t numResults = 0; PlanStage::StageState stageState = PlanStage::NEED_TIME; while (stageState != PlanStage::IS_EOF) { WorkingSetID id = WorkingSet::INVALID_ID; stageState = subplan->work(&id); ASSERT_NE(stageState, PlanStage::DEAD); ASSERT_NE(stageState, PlanStage::FAILURE); if (stageState == PlanStage::ADVANCED) { ++numResults; } } ASSERT_EQ(numResults, 4U); }
ofxSynth::ofxSynth(){ currentFrequency = startFrequency = targetFrequency = 440; setFrequency(440); currentAmp = 0; noteTime = 0; usesEnv = false; gain = 0.1; sustain = 0.5; modEnv.setADSR(44100*0.01, 44100*0.2, 0.0, 44100.0*0.1); env.setADSR(0.01*44100, 0.1*44100, 0.5, 0.93*44100); filter.setup(); setFilter(0.7, 0.5); setFilterLowPass(); waveMode = 0; }
int BucketModel::qt_metacall(QMetaObject::Call _c, int _id, void **_a) { _id = BucketListModel::qt_metacall(_c, _id, _a); if (_id < 0) return _id; if (_c == QMetaObject::InvokeMetaMethod) { if (_id < 7) qt_static_metacall(this, _c, _id, _a); _id -= 7; } #ifndef QT_NO_PROPERTIES else if (_c == QMetaObject::ReadProperty) { void *_v = _a[0]; switch (_id) { case 0: *reinterpret_cast< QString*>(_v) = filter(); break; case 1: *reinterpret_cast< QString*>(_v) = jsonAssetPath(); break; case 2: *reinterpret_cast< bool*>(_v) = bucketIsFull(); break; } _id -= 3; } else if (_c == QMetaObject::WriteProperty) { void *_v = _a[0]; switch (_id) { case 0: setFilter(*reinterpret_cast< QString*>(_v)); break; case 1: setJsonAssetPath(*reinterpret_cast< QString*>(_v)); break; } _id -= 3; } else if (_c == QMetaObject::ResetProperty) { _id -= 3; } else if (_c == QMetaObject::QueryPropertyDesignable) { _id -= 3; } else if (_c == QMetaObject::QueryPropertyScriptable) { _id -= 3; } else if (_c == QMetaObject::QueryPropertyStored) { _id -= 3; } else if (_c == QMetaObject::QueryPropertyEditable) { _id -= 3; } else if (_c == QMetaObject::QueryPropertyUser) { _id -= 3; } #endif // QT_NO_PROPERTIES return _id; }
void Enemy::Initialize() { BallBase::CreateBall(); //((UserData*)m_b2Body->GetUserData())->kind = UserData::Enemy; auto ud = (UserData*)m_b2Body->GetUserData(); ud->kind = UserData::Enemy; ud->isCore = true; //setFilterGroup(-3); // random number //setFilter(UserData::Enemy, UserData::ball | UserData::player | UserData::Enemy); //setFilter(UserData::Enemy, -1 & ~UserData::Enemy); setFilter(UserData::Enemy, ~(UserData::Enemy << 1)); m_b2Body->ApplyForceToCenter(b2Vec2(rand() % 2000 - 1000, rand() % 2000 - 1000)); //Gameplay::getInst().MakeCircle(to_Vector2(m_b2Body->GetPosition()), 6, 3); Gameplay::getInst().MakeCircle(to_Vector2(m_b2Body->GetPosition()), 7, 3); }
bool FilterToolButton::setFilter(FilterToolButton::ItemId id,const QString & filter) { QList<QAction *> actions = menu()->actions(); for (int i=0;i<actions.count();i++) { ItemId item_id = ((actions[i]->menu() == NULL)?((IdAction *)actions[i])->id():IS_UNKNOWN); if (actions[i]->menu() == NULL) { bool is_ok = ((id == IS_GROUP) && (id == item_id) && (actions[i]->text() == filter)); if (!is_ok) is_ok = ((id != IS_UNKNOWN) && (id != IS_GROUP) && (id == item_id)); if (is_ok) { actions[i]->trigger(); triggerSignal(actions[i]); return true; } } else if (actions[i]->menu() != NULL) { if (setFilter(actions[i]->menu(),id,filter)) return true; } } return false; }
void ListWidget::append(const String &s, ThemeEngine::FontColor color) { if (_dataList.size() == _listColors.size()) { // If the color list has the size of the data list, we append the color. _listColors.push_back(color); } else if (!_listColors.size() && color != ThemeEngine::kFontColorNormal) { // If it's the first entry to use a non default color, we will fill // up all other entries of the color list with the default color and // add the requested color for the new entry. for (uint i = 0; i < _dataList.size(); ++i) _listColors.push_back(ThemeEngine::kFontColorNormal); _listColors.push_back(color); } _dataList.push_back(s); _list.push_back(s); setFilter(_filter, false); scrollBarRecalc(); }
void Texture::create2DTexture() { // Bind the texture glBindTexture(GL_TEXTURE_2D, _textureID); // Edge wrap mode setWrap(GL_TEXTURE_2D, GL_REPEAT, GL_REPEAT); // Pixel row alignment setAlign(); // Filter method setFilter(GL_TEXTURE_2D); // Mip map parameters setMipMaps(GL_TEXTURE_2D); // Texture image data for (size_t i = 0; i < _image->getMipMapCount(); i++) setMipMapData(GL_TEXTURE_2D, 0, i); }
void JSocketHandler::configure() { //TODO JLogManager* manager = JLogManager::getLogManager(); JString cname = getClass()->getName(); setLevel(JLevel::ALL);//TODO manager.getLevelProperty(cname +".level", Level.ALL)); setFilter(NULL);//TODO manager.getFilterProperty(cname +".filter", null)); setFormatter(new JXMLFormatter());//TODO manager.getFormatterProperty(cname +".formatter", new XMLFormatter())); try { setEncoding("");//TODOmanager.getStringProperty(cname +".encoding", null)); } catch (JException* ex) { delete ex; try { setEncoding(""); } catch (JException* ex2) { delete ex2; } } port = 0;//TODO manager.getIntProperty(cname + ".port", 0); host = new JString("localhost");//TODO manager.getStringProperty(cname + ".host", null); }
/** * Test that on failure, the cached plan stage replans the query but does not create a new cache * entry. */ TEST_F(QueryStageCachedPlan, QueryStageCachedPlanFailure) { AutoGetCollectionForReadCommand ctx(&_opCtx, nss); Collection* collection = ctx.getCollection(); ASSERT(collection); // Query can be answered by either index on "a" or index on "b". auto qr = stdx::make_unique<QueryRequest>(nss); qr->setFilter(fromjson("{a: {$gte: 8}, b: 1}")); auto statusWithCQ = CanonicalQuery::canonicalize(opCtx(), std::move(qr)); ASSERT_OK(statusWithCQ.getStatus()); const std::unique_ptr<CanonicalQuery> cq = std::move(statusWithCQ.getValue()); // We shouldn't have anything in the plan cache for this shape yet. PlanCache* cache = collection->infoCache()->getPlanCache(); ASSERT(cache); ASSERT_EQ(cache->get(*cq).state, PlanCache::CacheEntryState::kNotPresent); // Get planner params. QueryPlannerParams plannerParams; fillOutPlannerParams(&_opCtx, collection, cq.get(), &plannerParams); // Queued data stage will return a failure during the cached plan trial period. auto mockChild = stdx::make_unique<QueuedDataStage>(&_opCtx, &_ws); mockChild->pushBack(PlanStage::FAILURE); // High enough so that we shouldn't trigger a replan based on works. const size_t decisionWorks = 50; CachedPlanStage cachedPlanStage( &_opCtx, collection, &_ws, cq.get(), plannerParams, decisionWorks, mockChild.release()); // This should succeed after triggering a replan. PlanYieldPolicy yieldPolicy(PlanExecutor::NO_YIELD, _opCtx.getServiceContext()->getFastClockSource()); ASSERT_OK(cachedPlanStage.pickBestPlan(&yieldPolicy)); ASSERT_EQ(getNumResultsForStage(_ws, &cachedPlanStage, cq.get()), 2U); // Plan cache should still be empty, as we don't write to it when we replan a failed // query. ASSERT_EQ(cache->get(*cq).state, PlanCache::CacheEntryState::kNotPresent); }
int tlp::FileNameEditorWidget::qt_metacall(QMetaObject::Call _c, int _id, void **_a) { _id = QWidget::qt_metacall(_c, _id, _a); if (_id < 0) return _id; if (_c == QMetaObject::InvokeMetaMethod) { if (_id < 5) qt_static_metacall(this, _c, _id, _a); _id -= 5; } #ifndef QT_NO_PROPERTIES else if (_c == QMetaObject::ReadProperty) { void *_v = _a[0]; switch (_id) { case 0: *reinterpret_cast< QString*>(_v) = fileName(); break; case 1: *reinterpret_cast< QString*>(_v) = filter(); break; } _id -= 2; } else if (_c == QMetaObject::WriteProperty) { void *_v = _a[0]; switch (_id) { case 0: setFileName(*reinterpret_cast< QString*>(_v)); break; case 1: setFilter(*reinterpret_cast< QString*>(_v)); break; } _id -= 2; } else if (_c == QMetaObject::ResetProperty) { _id -= 2; } else if (_c == QMetaObject::QueryPropertyDesignable) { _id -= 2; } else if (_c == QMetaObject::QueryPropertyScriptable) { _id -= 2; } else if (_c == QMetaObject::QueryPropertyStored) { _id -= 2; } else if (_c == QMetaObject::QueryPropertyEditable) { _id -= 2; } else if (_c == QMetaObject::QueryPropertyUser) { _id -= 2; } #endif // QT_NO_PROPERTIES return _id; }