void
main(int argc, char **argv)
{
if(argc != 2){
fprint(2, "usage: ticker keyword\n");
exits("failed");
}
query = argv[1];
fmtinstall('R', urlencode);
watcher();
exits(nil);
}
QScriptValue QDeclarativeQtScriptExpression::eval(QObject *secondaryScope, bool *isUndefined)
{
Q_ASSERT(context() && context()->engine);
DeleteWatcher watcher(this);
QDeclarativeEngine *engine = context()->engine;
QDeclarativeEnginePrivate *ep = QDeclarativeEnginePrivate::get(engine);
QScriptEngine *scriptEngine = QDeclarativeEnginePrivate::getScriptEngine(engine);
QDeclarativeContextData *oldSharedContext = 0;
QObject *oldSharedScope = 0;
QObject *oldOverride = 0;
bool isShared = (expressionFunctionMode == SharedContext);
if (isShared) {
oldSharedContext = ep->sharedContext;
oldSharedScope = ep->sharedScope;
ep->sharedContext = context();
ep->sharedScope = scopeObject;
} else {
oldOverride = ep->contextClass->setOverrideObject(expressionContext, secondaryScope);
}
QScriptValue svalue = expressionFunction.call(); // This could cause this to be deleted
if (isShared) {
ep->sharedContext = oldSharedContext;
ep->sharedScope = oldSharedScope;
} else if (!watcher.wasDeleted()) {
ep->contextClass->setOverrideObject(expressionContext, oldOverride);
}
if (isUndefined)
*isUndefined = svalue.isUndefined() || scriptEngine->hasUncaughtException();
// Handle exception
if (scriptEngine->hasUncaughtException()) {
if (!watcher.wasDeleted())
QDeclarativeExpressionPrivate::exceptionToError(scriptEngine, error);
scriptEngine->clearExceptions();
return QScriptValue();
} else {
if (!watcher.wasDeleted())
error = QDeclarativeError();
return svalue;
}
}
int main()
{
SocketModule theSocket;
MyServerSocket server;
InputWatcher watcher(server);
watcher.start();
server.listen(IP(INADDR_ANY, 65432));
server.accept();
watcher.join();
return 0;
}
MojErr MojDbWatchTest::cancelTest(MojDb& db)
{
// cancel find
MojDbQuery query;
MojErr err = query.from(_T("WatchTest:1"));
MojTestErrCheck(err);
err = query.where(_T("foo"), MojDbQuery::OpLessThanEq, 45);
MojTestErrCheck(err);
MojRefCountedPtr<TestWatcher> watcher(new TestWatcher);
MojTestAssert(watcher.get());
watcher->m_slot.cancel();
MojDbCursor cursor;
err = db.find(query, cursor, watcher->m_slot);
MojTestErrCheck(err);
err = cursor.close();
MojTestErrCheck(err);
MojTestAssert(watcher->m_count == 0);
watcher->m_slot.cancel();
MojTestAssert(watcher->m_count == 0);
MojObject id;
err = put(db, 1, 1, id, m_rev);
MojTestErrCheck(err);
MojTestAssert(watcher->m_count == 0);
// cancel watch
watcher.reset(new TestWatcher);
MojTestAssert(watcher.get());
MojDbQuery queryWithRev;
err = queryWithRev.from(_T("WatchTest:1"));
MojTestErrCheck(err);
err = queryWithRev.where(_T("foo"), MojDbQuery::OpEq, 45);
MojTestErrCheck(err);
err = queryWithRev.where(_T("_rev"), MojDbQuery::OpGreaterThan, m_rev);
MojTestErrCheck(err);
bool fired = false;
err = db.watch(queryWithRev, cursor, watcher->m_slot, fired);
MojTestErrCheck(err);
err = cursor.close();
MojTestErrCheck(err);
MojTestAssert(!fired);
MojTestAssert(watcher->m_count == 0);
watcher->m_slot.cancel();
MojTestAssert(watcher->m_count == 0);
err = put(db, 45, 45, id, m_rev);
MojTestErrCheck(err);
MojTestAssert(watcher->m_count == 0);
return MojErrNone;
}
void
RegisterCommand::requestToken()
{
kDebug( 14100 ) << "requestToken Initialisation";
state = RegisterStateWaitingForToken;
if ( !( session_ = gg_token( 1 ) ) ) {
emit error( i18n( "Gadu-Gadu" ), i18n( "Unable to retrieve token." ) );
state = RegisterStateNoToken;
return;
}
connect( this, SIGNAL(socketReady()), SLOT(watcher()) );
checkSocket( session_->fd, session_->check );
return;
}
void
RegisterCommand::execute()
{
if ( state != RegisterStateGotToken || email_.isEmpty() || password_.isEmpty() || tokenString.isEmpty() ) {
// get token first || fill information
kDebug(14100) << "not enough info to run execute, state: " << state << " , email: " << email_ << ", password present " << !password_.isEmpty() << ", token string:" << tokenString;
return;
}
session_ = gg_register3( email_.toAscii(), password_.toAscii(), tokenId.toAscii(), tokenString.toAscii(), 1 );
if ( !session_ ) {
error( i18n( "Gadu-Gadu" ), i18n( "Registration FAILED" ) );
return;
}
state = RegisterStateWaitingForNumber;
connect( this, SIGNAL(socketReady()), SLOT(watcher()) );
checkSocket( session_->fd, session_->check );
}
MojErr MojDb::find(const MojDbQuery& query, MojDbCursor& cursor, WatchSignal::SlotRef watchHandler, MojDbReqRef req)
{
MojLogTrace(s_log);
MojErr err = beginReq(req);
MojErrCheck(err);
MojRefCountedPtr<MojDbWatcher> watcher(new MojDbWatcher(watchHandler));
MojAllocCheck(watcher.get());
err = findImpl(query, cursor, watcher.get(), req, OpRead);
MojErrCheck(err);
err = req->end(false);
MojErrCheck(err);
return MojErrNone;
}
/*!
Clears the incubator. Any in-progress incubation is aborted. If the incubator is in the
Ready state, the created object is \b not deleted.
*/
void QQmlIncubator::clear()
{
QRecursionWatcher<QQmlIncubatorPrivate, &QQmlIncubatorPrivate::recursion> watcher(d);
Status s = status();
if (s == Null)
return;
QQmlEnginePrivate *enginePriv = 0;
if (s == Loading) {
Q_ASSERT(d->compiledData);
enginePriv = QQmlEnginePrivate::get(d->compiledData->engine);
if (d->result) d->result->deleteLater();
d->result = 0;
}
d->clear();
Q_ASSERT(d->compiledData == 0);
Q_ASSERT(d->waitingOnMe.data() == 0);
Q_ASSERT(d->waitingFor.isEmpty());
d->errors.clear();
d->progress = QQmlIncubatorPrivate::Execute;
d->result = 0;
if (s == Loading) {
Q_ASSERT(enginePriv);
enginePriv->inProgressCreations--;
if (0 == enginePriv->inProgressCreations) {
while (enginePriv->erroredBindings) {
enginePriv->warning(enginePriv->erroredBindings);
enginePriv->erroredBindings->removeError();
}
}
}
d->changeStatus(Null);
}
MojErr MojDbWatchTest::rangeTest(MojDb& db)
{
MojDbQuery query;
MojErr err = query.from(_T("WatchTest:1"));
MojTestErrCheck(err);
err = query.where(_T("foo"), MojDbQuery::OpGreaterThan, 5);
MojTestErrCheck(err);
err = query.where(_T("foo"), MojDbQuery::OpLessThan, 100);
MojTestErrCheck(err);
MojRefCountedPtr<TestWatcher> watcher(new TestWatcher);
MojTestAssert(watcher.get());
MojDbCursor cursor;
err = db.find(query, cursor, watcher->m_slot);
MojTestErrCheck(err);
err = cursor.close();
MojTestErrCheck(err);
MojTestAssert(watcher->m_count == 0);
MojObject id;
MojInt64 rev;
err = put(db, 5, 5, id, rev);
MojTestErrCheck(err);
MojTestAssert(watcher->m_count == 0);
err = put(db, 100, 100, id, rev);
MojTestErrCheck(err);
MojTestAssert(watcher->m_count == 0);
err = put(db, 6, 6, id, rev);
MojTestErrCheck(err);
MojTestAssert(watcher->m_count == 1);
watcher.reset(new TestWatcher);
MojTestAssert(watcher.get());
err = db.find(query, cursor, watcher->m_slot);
MojTestErrCheck(err);
err = cursor.close();
MojTestErrCheck(err);
MojTestAssert(watcher->m_count == 0);
err = put(db, 99, 99, id, rev);
MojTestErrCheck(err);
MojTestAssert(watcher->m_count == 1);
return MojErrNone;
}
HeaderSniffer::HeaderSniffer (GaleonEmbedPersist *aEmbedPersist,
nsIURI* aURL, nsIDOMDocument* aDocument,
nsIInputStream* aPostData,
nsISupports *aCacheKey)
: mEmbedPersist(aEmbedPersist)
, mOriginalURL(aURL)
, mFinalURL (nsnull)
, mDocument(aDocument)
, mPostData(aPostData)
, mCacheKey(aCacheKey)
{
nsCOMPtr<nsIWindowWatcher> watcher
(do_GetService("@mozilla.org/embedcomp/window-watcher;1"));
if (!watcher) return;
watcher->GetNewAuthPrompter (nsnull, getter_AddRefs (mAuthPrompt));
g_object_ref (mEmbedPersist);
mShouldDecode = PR_FALSE;
LOG ("HeaderSniffer ctor (%p)", this);
}
void QuickTrackInfo::setupWatchers()
{
sp::Track track = this->track();
m_albumWatcher->watch(track.album());
int count = artistCount();
m_artistWatchers.clear();
for (int i = 0; i < count; ++i)
{
sp::Artist artist = track.artistAt(i);
ObjectSharedPointer<sp::ArtistWatcher> watcher(new sp::ArtistWatcher(m_session.data(), this));
watcher->watch(artist);
connect(watcher.data(), &sp::ArtistWatcher::loaded, this, &QuickTrackInfo::artistsChanged);
m_artistWatchers.append(watcher);
}
emit artistsChanged();
if (m_albumWatcher->watched().isLoaded())
emit dataUpdated();
}
QScriptValue QDeclarativeQtScriptExpression::scriptValue(QObject *secondaryScope, bool *isUndefined)
{
Q_ASSERT(context() && context()->engine);
Q_ASSERT(!trackChange || (guardObject && guardObjectNotifyIndex != -1));
if (!expressionFunction.isValid()) {
if (isUndefined) *isUndefined = true;
return QScriptValue();
}
DeleteWatcher watcher(this);
QDeclarativeEnginePrivate *ep = QDeclarativeEnginePrivate::get(context()->engine);
bool lastCaptureProperties = ep->captureProperties;
QPODVector<QDeclarativeEnginePrivate::CapturedProperty> lastCapturedProperties;
ep->captureProperties = trackChange;
ep->capturedProperties.copyAndClear(lastCapturedProperties);
QScriptValue value = eval(secondaryScope, isUndefined);
if (!watcher.wasDeleted() && trackChange) {
if (ep->capturedProperties.count() == 0) {
if (guardList) clearGuards();
} else {
updateGuards(ep->capturedProperties);
}
}
lastCapturedProperties.copyAndClear(ep->capturedProperties);
ep->captureProperties = lastCaptureProperties;
return value;
}
void Ut_MAppletInstantiator::testReceivePackageData()
{
static const QString TEST_PACKAGE_NAME = "testPackage.deb";
static const QString CANVAS_DBUS_ADDRESS = "service/path/to/canvas";
static const QString DESKTOP_FILE_NAME = "test.desktop";
captureCalls = true;
// Test that receiving the meta data of the package being installed informs the target canvas about it and starts the installation
QDBusMessage msg;
QDBusPendingCall call = QDBusPendingCall::fromCompletedCall(msg);
QDBusPendingCallWatcher watcher(call, NULL);
watcher.setProperty("packageName", TEST_PACKAGE_NAME);
watcher.setProperty("canvasDBusAddress", CANVAS_DBUS_ADDRESS);
replyDataMap.insert("Maemo-Desktop-File", DESKTOP_FILE_NAME);
emit receivePackageData(&watcher);
// The canvas should be told
QCOMPARE(callServiceNames.first(), QString("service"));
QCOMPARE(callObjectPaths.first(), QString("/path/to/canvas"));
QCOMPARE(callInterfaces.first(), QString("com.meego.core.MAppletInstanceManager"));
QVERIFY(callMethods.count() > 1);
QCOMPARE(callMethods.first(), QString("com.meego.core.MAppletInstanceManager.instantiateAppletFromPackage"));
QCOMPARE(callArguments.first().count(), 2);
QCOMPARE(callArguments.first().at(0).type(), QVariant::String);
QCOMPARE(callArguments.first().at(0).toString(), TEST_PACKAGE_NAME);
QCOMPARE(callArguments.first().at(1).type(), QVariant::Map);
QCOMPARE(callArguments.first().at(1).toMap().value("Maemo-Desktop-File"), QVariant(DESKTOP_FILE_NAME));
// The installation should start
QCOMPARE(callServiceNames.last(), QString("com.nokia.package_manager"));
QCOMPARE(callObjectPaths.last(), QString("/com/nokia/package_manager"));
QCOMPARE(callInterfaces.last(), QString("com.nokia.package_manager"));
QCOMPARE(callMethods.last(), QString("com.nokia.package_manager.Install"));
QCOMPARE(callArguments.last().count(), 1);
QCOMPARE(callArguments.last().at(0).type(), QVariant::String);
QCOMPARE(callArguments.last().at(0).toString(), TEST_PACKAGE_NAME);
}
bool QGalleryTrackerResultSet::waitForFinished(int msecs)
{
Q_D(QGalleryTrackerResultSet);
QTime timer;
timer.start();
do {
if (d->queryWatcher) {
QScopedPointer<QDBusPendingCallWatcher> watcher(d_func()->queryWatcher.take());
watcher->waitForFinished();
d->queryFinished(*watcher);
if (!(d->flags & QGalleryTrackerResultSetPrivate::Active))
return true;
} else if (d->flags & QGalleryTrackerResultSetPrivate::Active) {
if (d->waitForSyncFinish(msecs)) {
d->parseWatcher.waitForFinished();
d->_q_parseFinished();
if (!(d->flags & QGalleryTrackerResultSetPrivate::Active))
return true;
} else {
return false;
}
} else if (d->flags & (QGalleryTrackerResultSetPrivate::Refresh)) {
d->update();
} else {
return true;
}
} while ((msecs -= timer.restart()) > 0);
return false;
}
bool ResourceCache::AddResourceDir(const String& pathName)
{
FileSystem* fileSystem = GetSubsystem<FileSystem>();
if (!fileSystem || !fileSystem->DirExists(pathName))
{
LOGERROR("Could not open directory " + pathName);
return false;
}
String fixedPath = AddTrailingSlash(pathName);
// Check that the same path does not already exist
for (unsigned i = 0; i < resourceDirs_.Size(); ++i)
{
if (!resourceDirs_[i].Compare(fixedPath, false))
return true;
}
resourceDirs_.Push(fixedPath);
// Scan the path for files recursively and add their hash-to-name mappings
Vector<String> fileNames;
fileSystem->ScanDir(fileNames, fixedPath, "*.*", SCAN_FILES, true);
for (unsigned i = 0; i < fileNames.Size(); ++i)
StoreNameHash(fileNames[i]);
// If resource auto-reloading active, create a file watcher for the directory
if (autoReloadResources_)
{
SharedPtr<FileWatcher> watcher(new FileWatcher(context_));
watcher->StartWatching(fixedPath, true);
fileWatchers_.Push(watcher);
}
LOGINFO("Added resource path " + fixedPath);
return true;
}
void ResourceCache::SetAutoReloadResources(bool enable)
{
if (enable != autoReloadResources_)
{
if (enable)
{
for (unsigned i = 0; i < resourceDirs_.Size(); ++i)
{
SharedPtr<FileWatcher> watcher(new FileWatcher(context_));
watcher->StartWatching(resourceDirs_[i], true);
fileWatchers_.Push(watcher);
}
SubscribeToEvent(E_BEGINFRAME, HANDLER(ResourceCache, HandleBeginFrame));
}
else
{
UnsubscribeFromEvent(E_BEGINFRAME);
fileWatchers_.Clear();
}
autoReloadResources_ = enable;
}
}
void QQmlBinding::update(QQmlPropertyPrivate::WriteFlags flags)
{
if (!enabledFlag() || !context() || !context()->isValid())
return;
// Check that the target has not been deleted
if (QQmlData::wasDeleted(object()))
return;
int lineNo = qmlSourceCoordinate(m_lineNumber);
int columnNo = qmlSourceCoordinate(m_columnNumber);
QQmlTrace trace("General Binding Update");
trace.addDetail("URL", m_url);
trace.addDetail("Line", lineNo);
trace.addDetail("Column", columnNo);
if (!updatingFlag()) {
QQmlBindingProfiler prof(m_url, lineNo, columnNo, QQmlProfilerService::QmlBinding);
setUpdatingFlag(true);
QQmlAbstractExpression::DeleteWatcher watcher(this);
if (m_core.propType == qMetaTypeId<QQmlBinding *>()) {
int idx = m_core.coreIndex;
Q_ASSERT(idx != -1);
QQmlBinding *t = this;
int status = -1;
void *a[] = { &t, 0, &status, &flags };
QMetaObject::metacall(*m_coreObject, QMetaObject::WriteProperty, idx, a);
} else {
QQmlEnginePrivate *ep = QQmlEnginePrivate::get(context()->engine);
ep->referenceScarceResources();
bool isUndefined = false;
v8::HandleScope handle_scope;
v8::Context::Scope scope(ep->v8engine()->context());
v8::Local<v8::Value> result =
QQmlJavaScriptExpression::evaluate(context(), v8function, &isUndefined);
trace.event("writing binding result");
bool needsErrorLocationData = false;
if (!watcher.wasDeleted() && !hasError())
needsErrorLocationData = !QQmlPropertyPrivate::writeBinding(*m_coreObject, m_core, context(),
this, result, isUndefined, flags);
if (!watcher.wasDeleted()) {
if (needsErrorLocationData)
delayedError()->setErrorLocation(QUrl(m_url), m_lineNumber, m_columnNumber);
if (hasError()) {
if (!delayedError()->addError(ep)) ep->warning(this->error(context()->engine));
} else {
clearError();
}
}
ep->dereferenceScarceResources();
}
if (!watcher.wasDeleted())
setUpdatingFlag(false);
} else {
QQmlProperty p = property();
QQmlAbstractBinding::printBindingLoopError(p);
}
}
/**
* This method processes all device events since it was last called. It asks
* the input handler to handle each of these events.
*/
bool InputDevices::privateProcessEvents( InputHandler & handler )
{
BW_GUARD;
HRESULT hr;
if (!focus_) return true;
// Update the Joystick state when this is called.
this->joystick_.update();
bool jbLostData = false;
this->joystick().processEvents( handler, isKeyDown_, &jbLostData );
if ( jbLostData )
lostData_ |= JOY_DATA_LOST;
static DogWatch watchHandleKey( "Keyboard" );
{ // DogWatch scope
ScopedDogWatch watcher( watchHandleKey );
if (pKeyboard_ != NULL)
{
DIDEVICEOBJECTDATA didod[ KEYBOARD_BUFFER_SIZE ];
DWORD dwElements = 0;
dwElements = KEYBOARD_BUFFER_SIZE;
if (keyboardAcquired_)
{
hr = pKeyboard_->GetDeviceData(
sizeof(DIDEVICEOBJECTDATA), didod, &dwElements, 0 );
}
else
{
hr = DIERR_NOTACQUIRED;
dwElements = 0;
}
switch (hr)
{
case DI_OK:
break;
case DI_BUFFEROVERFLOW:
// We got an error or we got DI_BUFFEROVERFLOW.
//
// Either way, it means that continuous contact with the device has been
// lost, either due to an external interruption, or because the buffer
// overflowed and some events were lost.
//
DEBUG_MSG( "InputDevices::privateProcessEvents: "
"keyboard buffer overflow\n" );
lostData_ |= KEY_DATA_LOST;
break;
case DIERR_INPUTLOST:
case DIERR_NOTACQUIRED:
// We got an error or we got DI_BUFFEROVERFLOW.
//
// Either way, it means that continuous contact with the device has been
// lost, either due to an external interruption, or because the buffer
// overflowed and some events were lost.
//
keyboardAcquired_ = false;
/*
DEBUG_MSG( "InputDevices::privateProcessEvents: "
"keyboard input not acquired, acquiring\n" );
*/
hr = pKeyboard_->Acquire();
if (FAILED(hr)) {
/*
DEBUG_MSG( "InputDevices::privateProcessEvents: "
"keyboard acquire failed\n" );
*/
return false;
}
keyboardAcquired_ = true;
dwElements = KEYBOARD_BUFFER_SIZE;
hr = pKeyboard_->GetDeviceData( sizeof(DIDEVICEOBJECTDATA),
didod, &dwElements, 0 );
lostData_ |= KEY_DATA_LOST;
break;
default:
DEBUG_MSG( "InputDevices::privateProcessEvents: "
"unhandled keyboard error\n" );
return false;
}
// Handle all those key events then
for (DWORD i = 0; i < dwElements; i++)
{
isKeyDown_[ static_cast<KeyEvent::Key>(didod[ i ].dwOfs) ] = (didod[ i ].dwData & 0x80) ?
true : false;
KeyEvent event(
(didod[ i ].dwData & 0x80) ?
MFEvent::KEY_DOWN :
MFEvent::KEY_UP,
static_cast<KeyEvent::Key>(didod[ i ].dwOfs),
this->modifiers() );
handler.handleKeyEvent( event );
}
}
} // DogWatch scope
// Now handle the mouse events.
// TODO:PM We should probably do this differently. We should really handle
// the event in the order that they were generated. That is, get both
// buffers and then continually handle the earliest until all handled.
if (pMouse_)
{
DIDEVICEOBJECTDATA didod[ MOUSE_BUFFER_SIZE ];
DWORD dwElements = 0;
dwElements = MOUSE_BUFFER_SIZE;
if (mouseAcquired_)
{
hr = pMouse_->GetDeviceData(
sizeof(DIDEVICEOBJECTDATA), didod, &dwElements, 0 );
}
else
{
hr = DIERR_NOTACQUIRED;
dwElements = 0;
}
switch (hr)
{
case DI_OK:
break;
case DI_BUFFEROVERFLOW:
/*
DEBUG_MSG( "InputDevices::privateProcessEvents: "
"mouse buffer overflow\n" );
*/
lostData_ |= MOUSE_DATA_LOST;
break;
case DIERR_INPUTLOST:
case DIERR_NOTACQUIRED:
mouseAcquired_ = false;
/*
DEBUG_MSG( "InputDevices::privateProcessEvents: "
"mouse input not acquired, acquiring\n" );
*/
hr = pMouse_->Acquire();
if (FAILED(hr))
{
/*
DEBUG_MSG( "InputDevices::privateProcessEvents: "
"mouse acquire failed\n" );
*/
return false;
}
mouseAcquired_ = true;
dwElements = MOUSE_BUFFER_SIZE;
hr = pMouse_->GetDeviceData( sizeof(DIDEVICEOBJECTDATA),
didod, &dwElements, 0 );
lostData_ |= MOUSE_DATA_LOST;
break;
default:
DEBUG_MSG( "InputDevices::privateProcessEvents: "
"unhandled mouse error\n" );
return false;
}
// With the keyboard event, we group the mouse movements together and
// only send at the end or when a button is pressed.
// Handle all the mouse events
long dx = 0;
long dy = 0;
long dz = 0;
static DogWatch watchMouse( "Mouse" );
watchMouse.start();
for (DWORD i = 0; i < dwElements; i++)
{
switch ( didod[i].dwOfs )
{
case DIMOFS_BUTTON0:
case DIMOFS_BUTTON1:
case DIMOFS_BUTTON2:
case DIMOFS_BUTTON3:
case DIMOFS_BUTTON4:
case DIMOFS_BUTTON5:
case DIMOFS_BUTTON6:
case DIMOFS_BUTTON7:
{
if ( dx != 0 || dy != 0 || dz != 0 )
{
MouseEvent mouseEvent( dx, dy, dz );
handler.handleMouseEvent( mouseEvent );
dx = dy = dz = 0;
}
KeyEvent keyEvent(
(didod[ i ].dwData & 0x80) ?
MFEvent::KEY_DOWN :
MFEvent::KEY_UP,
static_cast< KeyEvent::Key >(
KeyEvent::KEY_MOUSE0 +
(didod[ i ].dwOfs - DIMOFS_BUTTON0)),
this->modifiers() );
isKeyDown_[ keyEvent.key() ] = keyEvent.isKeyDown();
handler.handleKeyEvent( keyEvent );
}
break;
case DIMOFS_X:
dx += didod[ i ].dwData;
break;
case DIMOFS_Y:
dy += didod[ i ].dwData;
break;
case DIMOFS_Z:
dz += didod[ i ].dwData;
break;
}
}
watchMouse.stop();
if ( dx != 0 || dy != 0 || dz != 0 )
{
MouseEvent mouseEvent( dx, dy, dz );
handler.handleMouseEvent( mouseEvent );
dx = dy = dz = 0;
}
}
//handle lost data
if (lostData_ != NO_DATA_LOST)
handleLostData( handler, lostData_ );
for (uint i = 0; i < gVirtualKeyboards.size(); i++)
{
KeyboardDevice * pKB = gVirtualKeyboards[i];
pKB->update();
KeyEvent event;
while (pKB->next( event ))
{
isKeyDown_[ event.key() ] = event.isKeyDown();
handler.handleKeyEvent( event );
}
}
return true;
}
MojErr MojDbServiceHandler::findImpl(MojServiceMessage* msg, MojObject& payload, MojDbReq& req, MojDbCursor& cursor, bool doCount)
{
MojAssert(msg);
MojLogTrace(s_log);
MojObject queryObj;
MojErr err = payload.getRequired(MojDbServiceDefs::QueryKey, queryObj);
MojErrCheck(err);
bool doWatch = false;
payload.get(MojDbServiceDefs::WatchKey, doWatch);
MojDbQuery query;
err = query.fromObject(queryObj);
MojErrCheck(err);
MojUInt32 limit = query.limit();
if (limit == MojDbQuery::LimitDefault){
query.limit(MaxQueryLimit);
} else if (limit > MaxQueryLimit) {
MojErrThrowMsg(MojErrDbInvalidQuery, _T("db: limit greater than %d not allowed"), MaxQueryLimit);
}
if (doWatch) {
MojRefCountedPtr<Watcher> watcher(new Watcher(msg));
MojAllocCheck(watcher.get());
err = m_db.find(query, cursor, watcher->m_watchSlot, req);
MojErrCheck(err);
} else {
err = m_db.find(query, cursor, req);
MojErrCheck(err);
}
// append results
MojObjectVisitor& writer = msg->writer();
err = writer.beginObject();
MojErrCheck(err);
err = writer.boolProp(MojServiceMessage::ReturnValueKey, true);
MojErrCheck(err);
err = writer.propName(MojDbServiceDefs::ResultsKey);
MojErrCheck(err);
err = writer.beginArray();
MojErrCheck(err);
err = cursor.visit(writer);
MojErrCheck(err);
err = writer.endArray();
MojErrCheck(err);
// append next page
MojDbQuery::Page page;
err = cursor.nextPage(page);
MojErrCheck(err);
if (!page.empty()) {
MojObject pageObj;
err = page.toObject(pageObj);
MojErrCheck(err);
err = writer.objectProp(MojDbServiceDefs::NextKey, pageObj);
MojErrCheck(err);
}
// append count
if (doCount) {
MojUInt32 count = 0;
err = cursor.count(count);
MojErrCheck(err);
err = writer.intProp(MojDbServiceDefs::CountKey, (MojInt64) count);
MojErrCheck(err);
}
err = writer.endObject();
MojErrCheck(err);
if (doWatch) {
// if this is a watched query, it cannot be part of a batch so it's safe to reply here
err = msg->reply();
MojErrCheck(err);
}
// notifications can fire any time after the cursor is closed,
// so don't close it until after sending the reply.
err = cursor.close();
MojErrCheck(err);
return MojErrNone;
}
void RegisterCommand::watcher()
{
gg_pubdir* pubDir;
if ( state == RegisterStateWaitingForToken ) {
disableNotifiers();
if ( gg_token_watch_fd( session_ ) == -1 ) {
deleteNotifiers();
emit error( i18n( "Gadu-Gadu" ), i18n( "Unknown connection error while retrieving token." ) );
gg_token_free( session_ );
session_ = NULL;
state = RegisterStateNoToken;
return;
}
pubDir = (struct gg_pubdir *)session_->data;
emit operationStatus( i18n( "Token retrieving status: %1", GaduSession::stateDescription( session_->state ) ) );
switch ( session_->state ) {
case GG_STATE_CONNECTING:
kDebug( 14100 ) << "Recreating notifiers ";
deleteNotifiers();
checkSocket( session_->fd, 0);
break;
case GG_STATE_ERROR:
deleteNotifiers();
emit error( i18n( "Gadu-Gadu token retrieve problem" ), GaduSession::errorDescription( session_->error ) );
gg_token_free( session_ );
session_ = NULL;
state = RegisterStateNoToken;
return;
break;
case GG_STATE_DONE:
struct gg_token* sp = ( struct gg_token* )session_->data;
tokenId = (char *)sp->tokenid;
kDebug( 14100 ) << "got Token!, ID: " << tokenId;
deleteNotifiers();
if ( pubDir->success ) {
QPixmap tokenImg;
tokenImg.loadFromData( (const unsigned char *)session_->body, session_->body_size );
state = RegisterStateGotToken;
emit tokenRecieved( tokenImg, tokenId );
}
else {
emit error( i18n( "Gadu-Gadu" ), i18n( "Unable to retrieve token." ) );
state = RegisterStateNoToken;
deleteLater();
}
gg_token_free( session_ );
session_ = NULL;
disconnect( this, SLOT(watcher()) );
return;
break;
}
enableNotifiers( session_->check );
}
if ( state == RegisterStateWaitingForNumber ) {
disableNotifiers();
if ( gg_register_watch_fd( session_ ) == -1 ) {
deleteNotifiers();
emit error( i18n( "Gadu-Gadu" ), i18n( "Unknown connection error while registering." ) );
gg_free_register( session_ );
session_ = NULL;
state = RegisterStateGotToken;
return;
}
pubDir = (gg_pubdir*) session_->data;
emit operationStatus( i18n( "Registration status: %1", GaduSession::stateDescription( session_->state ) ) );
switch ( session_->state ) {
case GG_STATE_CONNECTING:
kDebug( 14100 ) << "Recreating notifiers ";
deleteNotifiers();
checkSocket( session_->fd, 0);
break;
case GG_STATE_ERROR:
deleteNotifiers();
emit error( i18n( "Gadu-Gadu Registration Error" ), GaduSession::errorDescription( session_->error ) );
gg_free_register( session_ );
session_ = NULL;
state = RegisterStateGotToken;
return;
break;
case GG_STATE_DONE:
deleteNotifiers();
if ( pubDir->success && pubDir->uin ) {
uin= pubDir->uin;
state = RegisterStateDone;
emit done( i18n( "Registration Finished" ), i18n( "Registration has been completed successfully." ) );
}
else {
emit error( i18n( "Registration Error" ), i18n( "Incorrect data sent to server." ) );
state = RegisterStateGotToken;
}
gg_free_register( session_ );
session_ = NULL;
disconnect( this, SLOT(watcher()) );
deleteLater();
return;
break;
}
enableNotifiers( session_->check );
return;
}
}
QV4::ReturnedValue QQmlJavaScriptExpression::evaluate(QQmlContextData *context,
const QV4::ValueRef function,
QV4::CallData *callData,
bool *isUndefined)
{
Q_ASSERT(context && context->engine);
if (function->isUndefined()) {
if (isUndefined)
*isUndefined = true;
return QV4::Encode::undefined();
}
QQmlEnginePrivate *ep = QQmlEnginePrivate::get(context->engine);
// All code that follows must check with watcher before it accesses data members
// incase we have been deleted.
DeleteWatcher watcher(this);
Q_ASSERT(notifyOnValueChanged() || activeGuards.isEmpty());
GuardCapture capture(context->engine, this, &watcher);
QQmlEnginePrivate::PropertyCapture *lastPropertyCapture = ep->propertyCapture;
ep->propertyCapture = notifyOnValueChanged()?&capture:0;
if (notifyOnValueChanged())
capture.guards.copyAndClearPrepend(activeGuards);
QV4::ExecutionEngine *v4 = QV8Engine::getV4(ep->v8engine());
QV4::Scope scope(v4);
QV4::ScopedValue result(scope, QV4::Primitive::undefinedValue());
QV4::ExecutionContext *ctx = v4->currentContext();
callData->thisObject = v4->globalObject;
if (scopeObject()) {
QV4::ScopedValue value(scope, QV4::QObjectWrapper::wrap(ctx->d()->engine, scopeObject()));
if (value->isObject())
callData->thisObject = value;
}
result = function->asFunctionObject()->call(callData);
if (scope.hasException()) {
if (watcher.wasDeleted())
ctx->catchException(); // ignore exception
else
delayedError()->catchJavaScriptException(ctx);
if (isUndefined)
*isUndefined = true;
} else {
if (isUndefined)
*isUndefined = result->isUndefined();
if (!watcher.wasDeleted() && hasDelayedError())
delayedError()->clearError();
}
if (capture.errorString) {
for (int ii = 0; ii < capture.errorString->count(); ++ii)
qWarning("%s", qPrintable(capture.errorString->at(ii)));
delete capture.errorString;
capture.errorString = 0;
}
while (Guard *g = capture.guards.takeFirst())
g->Delete();
ep->propertyCapture = lastPropertyCapture;
return result.asReturnedValue();
}
void QQmlBinding::update(QQmlPropertyPrivate::WriteFlags flags)
{
if (!enabledFlag() || !context() || !context()->isValid())
return;
// Check that the target has not been deleted
if (QQmlData::wasDeleted(object()))
return;
QString url;
quint16 lineNumber;
quint16 columnNumber;
QQmlEnginePrivate *ep = QQmlEnginePrivate::get(context()->engine);
QV4::Scope scope(ep->v4engine());
QV4::ScopedFunctionObject f(scope, v4function.value());
Q_ASSERT(f);
if (f->bindingKeyFlag()) {
Q_ASSERT(f->as<QV4::QQmlBindingFunction>());
QQmlSourceLocation loc = static_cast<QV4::QQmlBindingFunction *>(f.getPointer())->d()->bindingLocation;
url = loc.sourceFile;
lineNumber = loc.line;
columnNumber = loc.column;
} else {
QV4::Function *function = f->asFunctionObject()->function();
Q_ASSERT(function);
url = function->sourceFile();
lineNumber = function->compiledFunction->location.line;
columnNumber = function->compiledFunction->location.column;
}
int lineNo = qmlSourceCoordinate(lineNumber);
int columnNo = qmlSourceCoordinate(columnNumber);
QQmlTrace trace("General Binding Update");
trace.addDetail("URL", url);
trace.addDetail("Line", lineNo);
trace.addDetail("Column", columnNo);
if (!updatingFlag()) {
QQmlBindingProfiler prof(ep->profiler, url, lineNo, columnNo);
setUpdatingFlag(true);
QQmlAbstractExpression::DeleteWatcher watcher(this);
if (m_core.propType == qMetaTypeId<QQmlBinding *>()) {
int idx = m_core.coreIndex;
Q_ASSERT(idx != -1);
QQmlBinding *t = this;
int status = -1;
void *a[] = { &t, 0, &status, &flags };
QMetaObject::metacall(*m_coreObject, QMetaObject::WriteProperty, idx, a);
} else {
ep->referenceScarceResources();
bool isUndefined = false;
QV4::ScopedValue result(scope, QQmlJavaScriptExpression::evaluate(context(), f, &isUndefined));
trace.event("writing binding result");
bool needsErrorLocationData = false;
if (!watcher.wasDeleted() && !hasError())
needsErrorLocationData = !QQmlPropertyPrivate::writeBinding(*m_coreObject, m_core, context(),
this, result, isUndefined, flags);
if (!watcher.wasDeleted()) {
if (needsErrorLocationData)
delayedError()->setErrorLocation(QUrl(url), lineNumber, columnNumber);
if (hasError()) {
if (!delayedError()->addError(ep)) ep->warning(this->error(context()->engine));
} else {
clearError();
}
}
ep->dereferenceScarceResources();
}
if (!watcher.wasDeleted())
setUpdatingFlag(false);
} else {
QQmlProperty p = property();
QQmlAbstractBinding::printBindingLoopError(p);
}
}
//重构操作
void segmentation::on_morphologyOperationButton_clicked()
{
const int dimension = 3;
typedef itk::Image< unsigned char, dimension > IType;
typedef itk::ImageFileReader< IType > ReaderType;
ReaderType::Pointer reader = ReaderType::New();
IType::Pointer inputImage = IType::New();
reader->SetFileName( initFileName );//读入二值图
reader->Update();
inputImage = reader->GetOutput();
IType::SizeType imgSize;
IType::IndexType voxelIndex;
imgSize = inputImage->GetLargestPossibleRegion().GetSize();
typedef itk::BinaryBallStructuringElement< bool, dimension> KernelType;
KernelType ball;
KernelType::SizeType ballSize;
ofstream fout;
long vol = 0;
unsigned char temp;
float r;
for(int z = 0; z < imgSize[2]; z++)
for(int y = 0; y < imgSize[1]; y++)
for(int x = 0; x < imgSize[0]; x++)
{
voxelIndex[0] = x;
voxelIndex[1] = y;
voxelIndex[2] = z;
temp = inputImage->GetPixel(voxelIndex);
if(temp == 255)
vol += 1;
}
r = pow((3 * vol) / (4 * PI), (1.0 / 3)) ;
r = r / 6;//experiment data
ballSize.Fill( r );//radius
ball.SetRadius(ballSize);
ball.CreateStructuringElement();
typedef itk::BinaryOpeningByReconstructionImageFilter< IType, KernelType > I2LType;
I2LType::Pointer reconstruction = I2LType::New();
reconstruction->SetInput( reader->GetOutput() );
reconstruction->SetKernel( ball );
reconstruction->SetFullyConnected( 1 );
reconstruction->SetForegroundValue( 255 );
itk::SimpleFilterWatcher watcher(reconstruction, "filter");
//文件前缀名
filePrefix = inputFileName;//char* to string
filePrefix = filePrefix.substr(0, filePrefix.length() - 4);
string morphologyFileName;
morphologyFileName = filePrefix + "_morphologyResult.mhd";
strcpy(outputFileName, morphologyFileName.c_str());//string to char*
typedef itk::ImageFileWriter< IType > WriterType;
WriterType::Pointer morphologyWriter = WriterType::New();
morphologyWriter->SetInput( reconstruction->GetOutput() );
morphologyWriter->SetFileName( outputFileName );
morphologyWriter->Update();
//腐蚀结果叠加到原图
typedef itk::Image< unsigned short, dimension > OriginalImageType;
typedef itk::ImageFileReader<OriginalImageType>OriginalReaderType;
OriginalReaderType::Pointer orignalImgreader = OriginalReaderType::New();
OriginalImageType::Pointer originalImage = OriginalImageType::New();
OriginalReaderType::IndexType originalImgVoxelIndex;
reader->SetFileName(outputFileName);//读入重构操作结果图像
reader->Update();
inputImage = reader->GetOutput();
orignalImgreader->SetFileName(inputFileName);//读入原图像
orignalImgreader->Update();
originalImage = orignalImgreader->GetOutput();
for(int z = 0; z < imgSize[2]; z++)
for(int y = 0; y < imgSize[1]; y++)
for(int x = 0; x < imgSize[0]; x++)
{
voxelIndex[0] = x;
voxelIndex[1] = y;
voxelIndex[2] = z;
originalImgVoxelIndex[0] = x;
originalImgVoxelIndex[1] = y;
originalImgVoxelIndex[2] = z;
temp = inputImage->GetPixel(voxelIndex);
if(temp == 255)
originalImage->SetPixel(originalImgVoxelIndex, 65535);
}
//输出结果
typedef itk::ImageFileWriter<OriginalImageType>NewWriterType;
NewWriterType::Pointer writer = NewWriterType::New();
//文件前缀名
filePrefix = inputFileName;//char* to string
filePrefix = filePrefix.substr(0, filePrefix.length() - 4);
filePrefix = filePrefix + "_refinedResult.mhd";
strcpy(outputFileName, filePrefix.c_str());//string to char*
writer->SetFileName(outputFileName);
writer->SetInput(originalImage);
writer->Update();
emit returnInternalFileName(initResultFileName);//更新原视图
emit returnOutputFileName(outputFileName);//显示结果图
}
MojErr MojDbWatchTest::pageTest(MojDb& db)
{
MojObject id;
MojObject idFirst;
MojObject idFourth;
MojObject idLast;
MojInt64 rev;
for (int i = 100; i < 150; ++i) {
MojErr err = put(db, 100, i, id, rev);
MojTestErrCheck(err);
if (i == 100) {
idFirst = id;
} else if (i == 103) {
idFourth = id;
} else if (i == 149) {
idLast = id;
}
}
MojDbQuery query;
MojErr err = query.from(_T("WatchTest:1"));
MojTestErrCheck(err);
err = query.where(_T("foo"), MojDbQuery::OpGreaterThanEq, 100);
MojTestErrCheck(err);
query.limit(3);
MojRefCountedPtr<TestWatcher> watcher(new TestWatcher);
MojTestAssert(watcher.get());
MojDbCursor cursor;
err = db.find(query, cursor, watcher->m_slot);
MojTestErrCheck(err);
bool found = false;
MojUInt32 count = 0;
do {
MojObject obj;
err = cursor.get(obj, found);
MojTestErrCheck(err);
if (found)
++count;
} while (found);
MojTestAssert(count == 3);
MojDbQuery::Page page;
err = cursor.nextPage(page);
MojTestErrCheck(err);
err = cursor.close();
MojTestErrCheck(err);
err = merge(db, idFourth, 53);
MojTestErrCheck(err);
MojTestAssert(watcher->m_count == 0);
query.page(page);
MojRefCountedPtr<TestWatcher> watcher2(new TestWatcher);
MojTestAssert(watcher2.get());
err = db.find(query, cursor, watcher2->m_slot);
MojTestErrCheck(err);
found = false;
count = 0;
do {
MojObject obj;
err = cursor.get(obj, found);
MojTestErrCheck(err);
if (found)
++count;
} while (found);
MojTestAssert(count == 3);
err = cursor.close();
MojTestErrCheck(err);
err = db.del(idFirst, found);
MojTestErrCheck(err);
MojTestAssert(found);
MojTestAssert(watcher->m_count == 1);
MojTestAssert(watcher2->m_count == 0);
err = db.del(idFourth, found);
MojTestErrCheck(err);
MojTestAssert(found);
MojTestAssert(watcher->m_count == 1);
MojTestAssert(watcher2->m_count == 1);
// desc order
query.page(MojDbQuery::Page());
query.desc(true);
MojRefCountedPtr<TestWatcher> watcher3(new TestWatcher);
MojTestAssert(watcher3.get());
err = db.find(query, cursor, watcher3->m_slot);
MojTestErrCheck(err);
found = false;
count = 0;
do {
MojObject obj;
err = cursor.get(obj, found);
MojTestErrCheck(err);
if (found)
++count;
} while (found);
MojTestAssert(count == 3);
err = cursor.close();
MojTestErrCheck(err);
err = merge(db, idLast, 53);
MojTestErrCheck(err);
MojTestAssert(watcher3->m_count == 1);
MojRefCountedPtr<TestWatcher> watcher4(new TestWatcher);
MojTestAssert(watcher4.get());
err = db.find(query, cursor, watcher4->m_slot);
MojTestErrCheck(err);
found = false;
count = 0;
do {
MojObject obj;
err = cursor.get(obj, found);
MojTestErrCheck(err);
if (found)
++count;
} while (found);
MojTestAssert(count == 3);
err = cursor.close();
MojTestErrCheck(err);
err = merge(db, idLast, 54);
MojTestErrCheck(err);
MojTestAssert(watcher4->m_count == 1);
return MojErrNone;
}
void QQmlIncubatorPrivate::incubate(QQmlInstantiationInterrupt &i)
{
if (!compiledData)
return;
QML_MEMORY_SCOPE_URL(compiledData->url());
QExplicitlySharedDataPointer<QQmlIncubatorPrivate> protectThis(this);
QRecursionWatcher<QQmlIncubatorPrivate, &QQmlIncubatorPrivate::recursion> watcher(this);
QQmlEngine *engine = compiledData->engine;
QQmlEnginePrivate *enginePriv = QQmlEnginePrivate::get(engine);
if (!vmeGuard.isOK()) {
QQmlError error;
error.setUrl(compiledData->url());
error.setDescription(QQmlComponent::tr("Object destroyed during incubation"));
errors << error;
progress = QQmlIncubatorPrivate::Completed;
goto finishIncubate;
}
vmeGuard.clear();
if (progress == QQmlIncubatorPrivate::Execute) {
enginePriv->referenceScarceResources();
QObject *tresult = 0;
tresult = creator->create(subComponentToCreate, /*parent*/0, &i);
if (!tresult)
errors = creator->errors;
enginePriv->dereferenceScarceResources();
if (watcher.hasRecursed())
return;
result = tresult;
if (errors.isEmpty() && result == 0)
goto finishIncubate;
if (result) {
QQmlData *ddata = QQmlData::get(result);
Q_ASSERT(ddata);
//see QQmlComponent::beginCreate for explanation of indestructible
ddata->indestructible = true;
ddata->explicitIndestructibleSet = true;
ddata->rootObjectInCreation = false;
if (q)
q->setInitialState(result);
}
if (watcher.hasRecursed())
return;
if (errors.isEmpty())
progress = QQmlIncubatorPrivate::Completing;
else
progress = QQmlIncubatorPrivate::Completed;
changeStatus(calculateStatus());
if (watcher.hasRecursed())
return;
if (i.shouldInterrupt())
goto finishIncubate;
}
if (progress == QQmlIncubatorPrivate::Completing) {
do {
if (watcher.hasRecursed())
return;
QQmlContextData *ctxt = 0;
ctxt = creator->finalize(i);
if (ctxt) {
rootContext = ctxt;
progress = QQmlIncubatorPrivate::Completed;
goto finishIncubate;
}
} while (!i.shouldInterrupt());
}
finishIncubate:
if (progress == QQmlIncubatorPrivate::Completed && waitingFor.isEmpty()) {
QExplicitlySharedDataPointer<QQmlIncubatorPrivate> isWaiting = waitingOnMe;
clear();
if (isWaiting) {
QRecursionWatcher<QQmlIncubatorPrivate, &QQmlIncubatorPrivate::recursion> watcher(isWaiting.data());
changeStatus(calculateStatus());
if (!watcher.hasRecursed())
isWaiting->incubate(i);
} else {
changeStatus(calculateStatus());
}
enginePriv->inProgressCreations--;
if (0 == enginePriv->inProgressCreations) {
while (enginePriv->erroredBindings) {
enginePriv->warning(enginePriv->erroredBindings);
enginePriv->erroredBindings->removeError();
}
}
} else if (!creator.isNull()) {
vmeGuard.guard(creator.data());
}
}
MojErr MojDbWatchTest::eqTest(MojDb& db)
{
MojDbQuery query;
MojErr err = query.from(_T("WatchTest:1"));
MojTestErrCheck(err);
err = query.where(_T("foo"), MojDbQuery::OpEq, 1);
MojTestErrCheck(err);
MojRefCountedPtr<TestWatcher> watcher(new TestWatcher);
MojTestAssert(watcher.get());
MojDbCursor cursor;
err = db.find(query, cursor, watcher->m_slot);
MojTestErrCheck(err);
err = cursor.close();
MojTestErrCheck(err);
MojTestAssert(watcher->m_count == 0);
MojRefCountedPtr<TestWatcher> watcher2(new TestWatcher);
MojTestAssert(watcher2.get());
bool fired = false;
err = db.watch(query, cursor, watcher2->m_slot, fired);
MojTestErrCheck(err);
err = cursor.close();
MojTestErrCheck(err);
MojTestAssert(!fired);
// puts
MojObject id;
err = put(db, 0, 0, id, m_rev);
MojTestErrCheck(err);
MojTestAssert(watcher->m_count == 0);
MojTestAssert(watcher2->m_count == 0);
err = put(db, 2, 2, id, m_rev);
MojTestErrCheck(err);
MojTestAssert(watcher->m_count == 0);
MojTestAssert(watcher2->m_count == 0);
err = put(db, 1, 1, id, m_rev);
MojTestErrCheck(err);
MojTestAssert(watcher->m_count == 1);
MojTestAssert(watcher2->m_count == 1);
err = put(db, 1, 1, id, m_rev);
MojTestErrCheck(err);
MojTestAssert(watcher->m_count == 1);
MojTestAssert(watcher2->m_count == 1);
// put, changing property not in index
watcher.reset(new TestWatcher);
MojTestAssert(watcher.get());
err = db.find(query, cursor, watcher->m_slot);
MojTestErrCheck(err);
err = cursor.close();
MojTestErrCheck(err);
err = put(db, 1, 2, id, m_rev);
MojTestErrCheck(err);
MojTestAssert(watcher->m_count == 1);
// dels
watcher.reset(new TestWatcher);
MojTestAssert(watcher.get());
err = db.find(query, cursor, watcher->m_slot);
MojTestErrCheck(err);
err = cursor.close();
MojTestErrCheck(err);
watcher2.reset(new TestWatcher);
MojTestAssert(watcher2.get());
MojDbQuery queryWithRev;
err = queryWithRev.from(_T("WatchTest:1"));
MojTestErrCheck(err);
err = queryWithRev.where(_T("foo"), MojDbQuery::OpEq, 1);
MojTestErrCheck(err);
err = queryWithRev.where(_T("_rev"), MojDbQuery::OpGreaterThan, m_rev);
MojTestErrCheck(err);
err = queryWithRev.includeDeleted();
MojTestErrCheck(err);
fired = false;
err = db.watch(queryWithRev, cursor, watcher2->m_slot, fired);
MojTestErrCheck(err);
err = cursor.close();
MojTestErrCheck(err);
MojTestAssert(!fired);
MojTestAssert(watcher->m_count == 0);
MojTestAssert(watcher2->m_count == 0);
bool found;
err = db.del(id, found);
MojTestErrCheck(err);
MojTestAssert(found);
MojTestAssert(watcher->m_count == 1);
MojTestAssert(watcher2->m_count == 1);
// ordering
watcher.reset(new TestWatcher);
MojTestAssert(watcher.get());
err = db.find(query, cursor, watcher->m_slot);
MojTestErrCheck(err);
err = put(db, 1, 1, id, m_rev);
MojTestErrCheck(err);
MojTestAssert(watcher->m_count == 0);
err = cursor.close();
MojTestErrCheck(err);
MojTestAssert(watcher->m_count == 1);
return MojErrNone;
}
v8::Local<v8::Value>
QQmlJavaScriptExpression::evaluate(QQmlContextData *context,
v8::Handle<v8::Function> function,
int argc, v8::Handle<v8::Value> args[],
bool *isUndefined)
{
Q_ASSERT(context && context->engine);
if (function.IsEmpty() || function->IsUndefined()) {
if (isUndefined) *isUndefined = true;
return v8::Local<v8::Value>();
}
QQmlEnginePrivate *ep = QQmlEnginePrivate::get(context->engine);
Q_ASSERT(notifyOnValueChanged() || activeGuards.isEmpty());
GuardCapture capture(context->engine, this);
QQmlEnginePrivate::PropertyCapture *lastPropertyCapture = ep->propertyCapture;
ep->propertyCapture = notifyOnValueChanged()?&capture:0;
if (notifyOnValueChanged())
capture.guards.copyAndClearPrepend(activeGuards);
QQmlContextData *lastSharedContext = 0;
QObject *lastSharedScope = 0;
bool sharedContext = useSharedContext();
// All code that follows must check with watcher before it accesses data members
// incase we have been deleted.
DeleteWatcher watcher(this);
if (sharedContext) {
lastSharedContext = ep->sharedContext;
lastSharedScope = ep->sharedScope;
ep->sharedContext = context;
ep->sharedScope = scopeObject();
}
v8::Local<v8::Value> result;
{
v8::TryCatch try_catch;
v8::Handle<v8::Object> This = ep->v8engine()->global();
if (scopeObject() && requiresThisObject()) {
v8::Handle<v8::Value> value = ep->v8engine()->newQObject(scopeObject());
if (value->IsObject()) This = v8::Handle<v8::Object>::Cast(value);
}
result = function->Call(This, argc, args);
if (isUndefined)
*isUndefined = try_catch.HasCaught() || result->IsUndefined();
if (watcher.wasDeleted()) {
} else if (try_catch.HasCaught()) {
v8::Context::Scope scope(ep->v8engine()->context());
v8::Local<v8::Message> message = try_catch.Message();
if (!message.IsEmpty()) {
delayedError()->setMessage(message);
} else {
if (hasDelayedError()) delayedError()->clearError();
}
} else {
if (hasDelayedError()) delayedError()->clearError();
}
}
if (sharedContext) {
ep->sharedContext = lastSharedContext;
ep->sharedScope = lastSharedScope;
}
if (capture.errorString) {
for (int ii = 0; ii < capture.errorString->count(); ++ii)
qWarning("%s", qPrintable(capture.errorString->at(ii)));
delete capture.errorString;
capture.errorString = 0;
}
while (Guard *g = capture.guards.takeFirst())
g->Delete();
ep->propertyCapture = lastPropertyCapture;
return result;
}
