#define V8THROW_SQL(error, desc) \
{ \
- v8::Local<v8::Value> v = v8::Exception::Error(engine->toString(desc)); \
+ v8::Handle<v8::Value> v = v8::Exception::Error(engine->toString(desc)); \
v->ToObject()->Set(v8::String::New("code"), v8::Integer::New(error)); \
v8::ThrowException(v); \
return v8::Handle<v8::Value>(); \
#define V8THROW_SQL_VOID(error, desc) \
{ \
- v8::Local<v8::Value> v = v8::Exception::Error(engine->toString(desc)); \
+ v8::Handle<v8::Value> v = v8::Exception::Error(engine->toString(desc)); \
v->ToObject()->Set(v8::String::New("code"), v8::Integer::New(error)); \
v8::ThrowException(v); \
return; \
bool forwardOnly; // type == Rows
};
-static v8::Handle<v8::Value> qmlsqldatabase_version(v8::Local<v8::String> /* property */, const v8::AccessorInfo& info)
+static v8::Handle<v8::Value> qmlsqldatabase_version(v8::Handle<v8::String> /* property */, const v8::AccessorInfo& info)
{
QV8SqlDatabaseResource *r = v8_resource_cast<QV8SqlDatabaseResource>(info.This());
if (!r || r->type != QV8SqlDatabaseResource::Database)
return r->engine->toString(r->version);
}
-static v8::Handle<v8::Value> qmlsqldatabase_rows_length(v8::Local<v8::String> /* property */, const v8::AccessorInfo& info)
+static v8::Handle<v8::Value> qmlsqldatabase_rows_length(v8::Handle<v8::String> /* property */, const v8::AccessorInfo& info)
{
QV8SqlDatabaseResource *r = v8_resource_cast<QV8SqlDatabaseResource>(info.This());
if (!r || r->type != QV8SqlDatabaseResource::Rows)
return v8::Integer::New(s);
}
-static v8::Handle<v8::Value> qmlsqldatabase_rows_forwardOnly(v8::Local<v8::String> /* property */,
+static v8::Handle<v8::Value> qmlsqldatabase_rows_forwardOnly(v8::Handle<v8::String> /* property */,
const v8::AccessorInfo& info)
{
QV8SqlDatabaseResource *r = v8_resource_cast<QV8SqlDatabaseResource>(info.This());
return v8::Boolean::New(r->query.isForwardOnly());
}
-static void qmlsqldatabase_rows_setForwardOnly(v8::Local<v8::String> /* property */,
- v8::Local<v8::Value> value,
+static void qmlsqldatabase_rows_setForwardOnly(v8::Handle<v8::String> /* property */,
+ v8::Handle<v8::Value> value,
const v8::AccessorInfo& info)
{
QV8SqlDatabaseResource *r = v8_resource_cast<QV8SqlDatabaseResource>(info.This());
QSqlRecord record = r->query.record();
// XXX optimize
- v8::Local<v8::Object> row = v8::Object::New();
+ v8::Handle<v8::Object> row = v8::Object::New();
for (int ii = 0; ii < record.count(); ++ii) {
QVariant v = record.value(ii);
if (v.isNull()) {
if (query.prepare(sql)) {
if (args.Length() > 1) {
- v8::Local<v8::Value> values = args[1];
+ v8::Handle<v8::Value> values = args[1];
if (values->IsArray()) {
- v8::Local<v8::Array> array = v8::Local<v8::Array>::Cast(values);
+ v8::Handle<v8::Array> array = v8::Handle<v8::Array>::Cast(values);
uint32_t size = array->Length();
for (uint32_t ii = 0; ii < size; ++ii)
query.bindValue(ii, engine->toVariant(array->Get(ii)->v4Value(), -1));
} else if (values->IsObject() && !values->ToObject()->GetExternalResource()) {
- v8::Local<v8::Object> object = values->ToObject();
- v8::Local<v8::Array> names = object->GetPropertyNames();
+ v8::Handle<v8::Object> object = values->ToObject();
+ v8::Handle<v8::Array> names = object->GetPropertyNames();
uint32_t size = names->Length();
for (uint32_t ii = 0; ii < size; ++ii)
query.bindValue(names->Get(ii)->v4Value().toQString(),
r->query = query;
rows->SetExternalResource(r);
- v8::Local<v8::Object> resultObject = v8::Object::New();
+ v8::Handle<v8::Object> resultObject = v8::Object::New();
result = resultObject;
// XXX optimize
resultObject->Set(v8::String::New("rowsAffected"), v8::Integer::New(query.numRowsAffected()));
if (from_version != r->version)
V8THROW_SQL(SQLEXCEPTION_VERSION_ERR, QQmlEngine::tr("Version mismatch: expected %1, found %2").arg(from_version).arg(r->version));
- v8::Local<v8::Object> instance = databaseData(engine)->queryConstructor->NewInstance();
+ v8::Handle<v8::Object> instance = databaseData(engine)->queryConstructor->NewInstance();
QV8SqlDatabaseResource *r2 = new QV8SqlDatabaseResource(engine);
r2->type = QV8SqlDatabaseResource::Query;
r2->database = db;
QSqlDatabase db = r->database;
v8::Handle<v8::Function> callback = v8::Handle<v8::Function>::Cast(args[0]);
- v8::Local<v8::Object> instance = databaseData(engine)->queryConstructor->NewInstance();
+ v8::Handle<v8::Object> instance = databaseData(engine)->queryConstructor->NewInstance();
QV8SqlDatabaseResource *q = new QV8SqlDatabaseResource(engine);
q->type = QV8SqlDatabaseResource::Query;
q->database = db;
QQmlSqlDatabaseData::QQmlSqlDatabaseData(QV8Engine *engine)
{
{
- v8::Local<v8::FunctionTemplate> ft = v8::FunctionTemplate::New();
+ v8::Handle<v8::FunctionTemplate> ft = v8::FunctionTemplate::New();
ft->InstanceTemplate()->SetHasExternalResource(true);
ft->PrototypeTemplate()->Set(v8::String::New("transaction"),
V8FUNCTION(qmlsqldatabase_transaction, engine));
}
{
- v8::Local<v8::FunctionTemplate> ft = v8::FunctionTemplate::New();
+ v8::Handle<v8::FunctionTemplate> ft = v8::FunctionTemplate::New();
ft->InstanceTemplate()->SetHasExternalResource(true);
ft->PrototypeTemplate()->Set(v8::String::New("executeSql"),
V8FUNCTION(qmlsqldatabase_executeSql, engine));
queryConstructor = qPersistentNew<v8::Function>(ft->GetFunction());
}
{
- v8::Local<v8::FunctionTemplate> ft = v8::FunctionTemplate::New();
+ v8::Handle<v8::FunctionTemplate> ft = v8::FunctionTemplate::New();
ft->InstanceTemplate()->SetHasExternalResource(true);
ft->PrototypeTemplate()->Set(v8::String::New("item"), V8FUNCTION(qmlsqldatabase_rows_item, engine));
ft->PrototypeTemplate()->SetAccessor(v8::String::New("length"), qmlsqldatabase_rows_length);
database.open();
}
- v8::Local<v8::Object> instance = databaseData(engine)->constructor->NewInstance();
+ v8::Handle<v8::Object> instance = databaseData(engine)->constructor->NewInstance();
QV8SqlDatabaseResource *r = new QV8SqlDatabaseResource(engine);
r->database = database;
QQmlV4Handle callerFile(int frameIndex = 0) const
{
- v8::Local<v8::StackTrace> stacks = v8::StackTrace::CurrentStackTrace(10, v8::StackTrace::kDetailed);
+ v8::Handle<v8::StackTrace> stacks = v8::StackTrace::CurrentStackTrace(10, v8::StackTrace::kDetailed);
int count = stacks->GetFrameCount();
if (count >= frameIndex + 1) {
- v8::Local<v8::StackFrame> frame = stacks->GetFrame(frameIndex + 1);
+ v8::Handle<v8::StackFrame> frame = stacks->GetFrame(frameIndex + 1);
return QQmlV4Handle::fromV8Handle(frame->GetScriptNameOrSourceURL());
}
return QQmlV4Handle();
}
int callerLine(int frameIndex = 0) const
{
- v8::Local<v8::StackTrace> stacks = v8::StackTrace::CurrentStackTrace(10, v8::StackTrace::kDetailed);
+ v8::Handle<v8::StackTrace> stacks = v8::StackTrace::CurrentStackTrace(10, v8::StackTrace::kDetailed);
int count = stacks->GetFrameCount();
if (count >= frameIndex + 1) {
- v8::Local<v8::StackFrame> frame = stacks->GetFrame(frameIndex + 1);
+ v8::Handle<v8::StackFrame> frame = stacks->GetFrame(frameIndex + 1);
return frame->GetLineNumber();
}
return -1;
return v8::Number::New(r->datum->curSize());
}
-#define COLOR_GETTER_AND_SETTER(VAR, NAME) static v8::Handle<v8::Value> particleData_get_ ## NAME (v8::Local<v8::String>, const v8::AccessorInfo &info) \
+#define COLOR_GETTER_AND_SETTER(VAR, NAME) static v8::Handle<v8::Value> particleData_get_ ## NAME (v8::Handle<v8::String>, const v8::AccessorInfo &info) \
{ \
QV8ParticleDataResource *r = v8_resource_cast<QV8ParticleDataResource>(info.This()); \
if (!r || !r->datum) \
return v8::Number::New((r->datum->color. VAR )/255.0);\
}\
\
-static void particleData_set_ ## NAME (v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)\
+static void particleData_set_ ## NAME (v8::Handle<v8::String>, v8::Handle<v8::Value> value, const v8::AccessorInfo &info)\
{\
QV8ParticleDataResource *r = v8_resource_cast<QV8ParticleDataResource>(info.This());\
if (!r || !r->datum)\
}
-#define SEMIBOOL_GETTER_AND_SETTER(VARIABLE) static v8::Handle<v8::Value> particleData_get_ ## VARIABLE (v8::Local<v8::String>, const v8::AccessorInfo &info) \
+#define SEMIBOOL_GETTER_AND_SETTER(VARIABLE) static v8::Handle<v8::Value> particleData_get_ ## VARIABLE (v8::Handle<v8::String>, const v8::AccessorInfo &info) \
{ \
QV8ParticleDataResource *r = v8_resource_cast<QV8ParticleDataResource>(info.This()); \
if (!r || !r->datum) \
return v8::Boolean::New(r->datum-> VARIABLE);\
}\
\
-static void particleData_set_ ## VARIABLE (v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)\
+static void particleData_set_ ## VARIABLE (v8::Handle<v8::String>, v8::Handle<v8::Value> value, const v8::AccessorInfo &info)\
{\
QV8ParticleDataResource *r = v8_resource_cast<QV8ParticleDataResource>(info.This());\
if (!r || !r->datum)\
r->datum-> VARIABLE = value->BooleanValue() ? 1.0 : 0.0;\
}
-#define FLOAT_GETTER_AND_SETTER(VARIABLE) static v8::Handle<v8::Value> particleData_get_ ## VARIABLE (v8::Local<v8::String>, const v8::AccessorInfo &info) \
+#define FLOAT_GETTER_AND_SETTER(VARIABLE) static v8::Handle<v8::Value> particleData_get_ ## VARIABLE (v8::Handle<v8::String>, const v8::AccessorInfo &info) \
{ \
QV8ParticleDataResource *r = v8_resource_cast<QV8ParticleDataResource>(info.This()); \
if (!r || !r->datum) \
return v8::Number::New(r->datum-> VARIABLE);\
}\
\
-static void particleData_set_ ## VARIABLE (v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)\
+static void particleData_set_ ## VARIABLE (v8::Handle<v8::String>, v8::Handle<v8::Value> value, const v8::AccessorInfo &info)\
{\
QV8ParticleDataResource *r = v8_resource_cast<QV8ParticleDataResource>(info.This());\
if (!r || !r->datum)\
r->datum-> VARIABLE = value->NumberValue();\
}
-#define FAKE_FLOAT_GETTER_AND_SETTER(VARIABLE, GETTER, SETTER) static v8::Handle<v8::Value> particleData_get_ ## VARIABLE (v8::Local<v8::String>, const v8::AccessorInfo &info) \
+#define FAKE_FLOAT_GETTER_AND_SETTER(VARIABLE, GETTER, SETTER) static v8::Handle<v8::Value> particleData_get_ ## VARIABLE (v8::Handle<v8::String>, const v8::AccessorInfo &info) \
{ \
QV8ParticleDataResource *r = v8_resource_cast<QV8ParticleDataResource>(info.This()); \
if (!r || !r->datum) \
return v8::Number::New(r->datum-> GETTER ());\
}\
\
-static void particleData_set_ ## VARIABLE (v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)\
+static void particleData_set_ ## VARIABLE (v8::Handle<v8::String>, v8::Handle<v8::Value> value, const v8::AccessorInfo &info)\
{\
QV8ParticleDataResource *r = v8_resource_cast<QV8ParticleDataResource>(info.This());\
if (!r || !r->datum)\
QV8ParticleDataDeletable::QV8ParticleDataDeletable(QV8Engine *engine)
{
- v8::Local<v8::FunctionTemplate> ft = v8::FunctionTemplate::New();
+ v8::Handle<v8::FunctionTemplate> ft = v8::FunctionTemplate::New();
ft->InstanceTemplate()->SetHasExternalResource(true);
ft->PrototypeTemplate()->Set(v8::String::New("discard"), V8FUNCTION(particleData_discard, engine));
ft->PrototypeTemplate()->Set(v8::String::New("lifeLeft"), V8FUNCTION(particleData_lifeLeft, engine));
Q_Q(QV8ProfilerService);
v8::HandleScope scope;
- v8::Local<v8::String> title = v8::String::New("");
+ v8::Handle<v8::String> title = v8::String::New("");
DebugServiceOutputStream outputStream;
const v8::HeapSnapshot *snapshot = v8::HeapProfiler::TakeSnapshot(title, snapshotType);
inline uint16_t *utf16Data() const { return (uint16_t *)strData->data(); }
inline bool equals(v8::Handle<v8::String> string) const {
- v8::Local<v8::String> data = isQString() ? v8::String::New(utf16Data(), length)
+ v8::Handle<v8::String> data = isQString() ? v8::String::New(utf16Data(), length)
: v8::String::New(cStrData(), length);
return string->Equals(data);
}
bool isUndefined = false;
- v8::Local<v8::Value> result =
+ v8::Handle<v8::Value> result =
QQmlJavaScriptExpression::evaluate(context(), **v4function, &isUndefined);
trace.event("writing binding result");
bool isUndefined = false;
- v8::Local<v8::Value> result =
+ v8::Handle<v8::Value> result =
QQmlJavaScriptExpression::evaluate(context(), **v4function, &isUndefined);
ep->dereferenceScarceResources();
public:
QV8IncubatorResource(QV8Engine *engine, IncubationMode = Asynchronous);
- static v8::Handle<v8::Value> StatusChangedGetter(v8::Local<v8::String>,
+ static v8::Handle<v8::Value> StatusChangedGetter(v8::Handle<v8::String>,
const v8::AccessorInfo& info);
- static v8::Handle<v8::Value> StatusGetter(v8::Local<v8::String>,
+ static v8::Handle<v8::Value> StatusGetter(v8::Handle<v8::String>,
const v8::AccessorInfo& info);
- static v8::Handle<v8::Value> ObjectGetter(v8::Local<v8::String>,
+ static v8::Handle<v8::Value> ObjectGetter(v8::Handle<v8::String>,
const v8::AccessorInfo& info);
- static v8::Handle<v8::Value> ForceCompletionGetter(v8::Local<v8::String>,
+ static v8::Handle<v8::Value> ForceCompletionGetter(v8::Handle<v8::String>,
const v8::AccessorInfo& info);
static v8::Handle<v8::Value> ForceCompletion(const v8::Arguments &args);
- static void StatusChangedSetter(v8::Local<v8::String>, v8::Local<v8::Value> value,
+ static void StatusChangedSetter(v8::Handle<v8::String>, v8::Handle<v8::Value> value,
const v8::AccessorInfo& info);
void dispose();
Q_ASSERT(args);
QObject *parent = 0;
- v8::Local<v8::Object> valuemap;
+ v8::Handle<v8::Object> valuemap;
if (args->Length() >= 1)
parent = args->engine()->toQObject((*args)[0]->v4Value());
if (args->Length() >= 2) {
- v8::Local<v8::Value> v = (*args)[1];
+ v8::Handle<v8::Value> v = (*args)[1];
if (!v->IsObject() || v->IsArray()) {
qmlInfo(this) << tr("createObject: value is not an object");
args->returnValue(v8::Null());
return;
}
- valuemap = v8::Local<v8::Object>::Cast(v);
+ valuemap = v8::Handle<v8::Object>::Cast(v);
}
QV8Engine *v8engine = args->engine();
Q_ASSERT(args);
QObject *parent = 0;
- v8::Local<v8::Object> valuemap;
+ v8::Handle<v8::Object> valuemap;
QQmlIncubator::IncubationMode mode = QQmlIncubator::Asynchronous;
if (args->Length() >= 1)
parent = args->engine()->toQObject((*args)[0]->v4Value());
if (args->Length() >= 2) {
- v8::Local<v8::Value> v = (*args)[1];
+ v8::Handle<v8::Value> v = (*args)[1];
if (v->IsNull()) {
} else if (!v->IsObject() || v->IsArray()) {
qmlInfo(this) << tr("createObject: value is not an object");
args->returnValue(v8::Null());
return;
} else {
- valuemap = v8::Local<v8::Object>::Cast(v);
+ valuemap = v8::Handle<v8::Object>::Cast(v);
}
}
QQmlComponentExtension *e = componentExtension(args->engine());
QV8IncubatorResource *r = new QV8IncubatorResource(args->engine(), mode);
- v8::Local<v8::Object> o = e->incubationConstructor->NewInstance();
+ v8::Handle<v8::Object> o = e->incubationConstructor->NewInstance();
o->SetExternalResource(r);
if (!valuemap.IsEmpty()) {
forceCompletion = qPersistentNew(V8FUNCTION(QV8IncubatorResource::ForceCompletion, engine));
{
- v8::Local<v8::FunctionTemplate> ft = v8::FunctionTemplate::New();
+ v8::Handle<v8::FunctionTemplate> ft = v8::FunctionTemplate::New();
ft->InstanceTemplate()->SetHasExternalResource(true);
ft->InstanceTemplate()->SetInternalFieldCount(1);
ft->InstanceTemplate()->SetAccessor(v8::String::New("onStatusChanged"),
}
}
-v8::Handle<v8::Value> QV8IncubatorResource::ObjectGetter(v8::Local<v8::String>,
+v8::Handle<v8::Value> QV8IncubatorResource::ObjectGetter(v8::Handle<v8::String>,
const v8::AccessorInfo& info)
{
QV8IncubatorResource *r = v8_resource_check<QV8IncubatorResource>(info.This());
return r->engine->newQObject(r->object());
}
-v8::Handle<v8::Value> QV8IncubatorResource::ForceCompletionGetter(v8::Local<v8::String>,
+v8::Handle<v8::Value> QV8IncubatorResource::ForceCompletionGetter(v8::Handle<v8::String>,
const v8::AccessorInfo& info)
{
QV8IncubatorResource *r = v8_resource_check<QV8IncubatorResource>(info.This());
return v8::Undefined();
}
-v8::Handle<v8::Value> QV8IncubatorResource::StatusGetter(v8::Local<v8::String>,
+v8::Handle<v8::Value> QV8IncubatorResource::StatusGetter(v8::Handle<v8::String>,
const v8::AccessorInfo& info)
{
QV8IncubatorResource *r = v8_resource_check<QV8IncubatorResource>(info.This());
return v8::Integer::NewFromUnsigned(r->status());
}
-v8::Handle<v8::Value> QV8IncubatorResource::StatusChangedGetter(v8::Local<v8::String>,
+v8::Handle<v8::Value> QV8IncubatorResource::StatusChangedGetter(v8::Handle<v8::String>,
const v8::AccessorInfo& info)
{
return info.This()->GetInternalField(0);
}
-void QV8IncubatorResource::StatusChangedSetter(v8::Local<v8::String>, v8::Local<v8::Value> value,
+void QV8IncubatorResource::StatusChangedSetter(v8::Handle<v8::String>, v8::Handle<v8::Value> value,
const v8::AccessorInfo& info)
{
info.This()->SetInternalField(0, value);
}
if (!me.IsEmpty()) { // Will be false in synchronous mode
- v8::Local<v8::Value> callback = me->GetInternalField(0);
+ v8::Handle<v8::Value> callback = me->GetInternalField(0);
if (!callback.IsEmpty() && !callback->IsUndefined()) {
if (callback->IsFunction()) {
- v8::Local<v8::Function> f = v8::Local<v8::Function>::Cast(callback);
+ v8::Handle<v8::Function> f = v8::Handle<v8::Function>::Cast(callback);
v8::Handle<v8::Value> args[] = { v8::Integer::NewFromUnsigned(s) };
v8::TryCatch tc;
f->Call(me, 1, args);
}
// Must be called with a valid handle scope
-v8::Local<v8::Value> QQmlExpressionPrivate::v8value(bool *isUndefined)
+v8::Handle<v8::Value> QQmlExpressionPrivate::v8value(bool *isUndefined)
{
if (!expressionFunctionValid) {
bool ok = true;
ep->referenceScarceResources(); // "hold" scarce resources in memory during evaluation.
{
- v8::Local<v8::Value> result = v8value(isUndefined);
+ v8::Handle<v8::Value> result = v8value(isUndefined);
rv = ep->v8engine()->toVariant(result->v4Value(), -1);
}
QVariant value(bool *isUndefined = 0);
- v8::Local<v8::Value> v8value(bool *isUndefined = 0);
+ v8::Handle<v8::Value> v8value(bool *isUndefined = 0);
static inline QQmlExpressionPrivate *get(QQmlExpression *expr);
static inline QQmlExpression *get(QQmlExpressionPrivate *expr);
clearGuards();
}
-v8::Local<v8::Value>
+v8::Handle<v8::Value>
QQmlJavaScriptExpression::evaluate(QQmlContextData *context,
v8::Handle<v8::Function> function, bool *isUndefined)
{
return evaluate(context, function, 0, 0, isUndefined);
}
-v8::Local<v8::Value>
+v8::Handle<v8::Value>
QQmlJavaScriptExpression::evaluate(QQmlContextData *context,
v8::Handle<v8::Function> function,
int argc, v8::Handle<v8::Value> args[],
if (function.IsEmpty() || function->IsUndefined()) {
if (isUndefined) *isUndefined = true;
- return v8::Local<v8::Value>();
+ return v8::Handle<v8::Value>();
}
QQmlEnginePrivate *ep = QQmlEnginePrivate::get(context->engine);
ep->sharedScope = scopeObject();
}
- v8::Local<v8::Value> result;
+ v8::Handle<v8::Value> result;
{
v8::TryCatch try_catch;
v8::Handle<v8::Object> This = v8::Value::fromV4Value(ep->v8engine()->global());
if (watcher.wasDeleted()) {
} else if (try_catch.HasCaught()) {
- v8::Local<v8::Message> message = try_catch.Message();
+ v8::Handle<v8::Message> message = try_catch.Message();
if (!message.IsEmpty()) {
delayedError()->setMessage(message);
} else {
v8::Handle<v8::String> description = message->Get();
int lineNumber = message->GetLineNumber();
- v8::Local<v8::String> file = name->IsString()?name->ToString():v8::Local<v8::String>();
+ v8::Handle<v8::String> file = name->IsString()?name->ToString():v8::Handle<v8::String>();
if (file.IsEmpty() || file->Length() == 0)
error.setUrl(QUrl());
else
QQmlEnginePrivate *ep = QQmlEnginePrivate::get(engine);
v8::TryCatch tc;
- v8::Local<v8::Object> scopeobject = ep->v8engine()->qmlScope(ctxt, scope);
- v8::Local<v8::Script> script = ep->v8engine()->qmlModeCompile(code, codeLength, filename, line);
+ v8::Handle<v8::Object> scopeobject = ep->v8engine()->qmlScope(ctxt, scope);
+ v8::Handle<v8::Script> script = ep->v8engine()->qmlModeCompile(code, codeLength, filename, line);
if (tc.HasCaught()) {
QQmlError error;
error.setDescription(QLatin1String("Exception occurred during function compilation"));
error.setLine(line);
error.setUrl(QUrl::fromLocalFile(filename));
- v8::Local<v8::Message> message = tc.Message();
+ v8::Handle<v8::Message> message = tc.Message();
if (!message.IsEmpty())
QQmlExpressionPrivate::exceptionToError(message, error);
ep->warning(error);
return v8::Persistent<v8::Function>();
}
- v8::Local<v8::Value> result = script->Run(scopeobject);
+ v8::Handle<v8::Value> result = script->Run(scopeobject);
if (tc.HasCaught()) {
QQmlError error;
error.setDescription(QLatin1String("Exception occurred during function evaluation"));
error.setLine(line);
error.setUrl(QUrl::fromLocalFile(filename));
- v8::Local<v8::Message> message = tc.Message();
+ v8::Handle<v8::Message> message = tc.Message();
if (!message.IsEmpty())
QQmlExpressionPrivate::exceptionToError(message, error);
ep->warning(error);
return v8::Persistent<v8::Function>();
}
if (qmlscope) *qmlscope = qPersistentNew<v8::Object>(scopeobject);
- return qPersistentNew<v8::Function>(v8::Local<v8::Function>::Cast(result));
+ return qPersistentNew<v8::Function>(v8::Handle<v8::Function>::Cast(result));
}
// Callee owns the persistent handle
QQmlEnginePrivate *ep = QQmlEnginePrivate::get(engine);
v8::TryCatch tc;
- v8::Local<v8::Object> scopeobject = ep->v8engine()->qmlScope(ctxt, scope);
- v8::Local<v8::Script> script = ep->v8engine()->qmlModeCompile(code, filename, line);
+ v8::Handle<v8::Object> scopeobject = ep->v8engine()->qmlScope(ctxt, scope);
+ v8::Handle<v8::Script> script = ep->v8engine()->qmlModeCompile(code, filename, line);
if (tc.HasCaught()) {
QQmlError error;
error.setDescription(QLatin1String("Exception occurred during function compilation"));
error.setLine(line);
error.setUrl(QUrl::fromLocalFile(filename));
- v8::Local<v8::Message> message = tc.Message();
+ v8::Handle<v8::Message> message = tc.Message();
if (!message.IsEmpty())
QQmlExpressionPrivate::exceptionToError(message, error);
ep->warning(error);
return v8::Persistent<v8::Function>();
}
- v8::Local<v8::Value> result = script->Run(scopeobject);
+ v8::Handle<v8::Value> result = script->Run(scopeobject);
if (tc.HasCaught()) {
QQmlError error;
error.setDescription(QLatin1String("Exception occurred during function evaluation"));
error.setLine(line);
error.setUrl(QUrl::fromLocalFile(filename));
- v8::Local<v8::Message> message = tc.Message();
+ v8::Handle<v8::Message> message = tc.Message();
if (!message.IsEmpty())
QQmlExpressionPrivate::exceptionToError(message, error);
ep->warning(error);
return v8::Persistent<v8::Function>();
}
if (qmlscope) *qmlscope = qPersistentNew<v8::Object>(scopeobject);
- return qPersistentNew<v8::Function>(v8::Local<v8::Function>::Cast(result));
+ return qPersistentNew<v8::Function>(v8::Handle<v8::Function>::Cast(result));
}
void QQmlJavaScriptExpression::clearGuards()
QQmlJavaScriptExpression(VTable *vtable);
- v8::Local<v8::Value> evaluate(QQmlContextData *, v8::Handle<v8::Function>,
+ v8::Handle<v8::Value> evaluate(QQmlContextData *, v8::Handle<v8::Function>,
bool *isUndefined);
- v8::Local<v8::Value> evaluate(QQmlContextData *, v8::Handle<v8::Function>,
+ v8::Handle<v8::Value> evaluate(QQmlContextData *, v8::Handle<v8::Function>,
int argc, v8::Handle<v8::Value> args[],
bool *isUndefined);
static void registerFunction(QV8Engine *engine, const char *script, v8::InvocationCallback func)
{
- v8::Local<v8::Script> registerScript = v8::Script::New(v8::String::New(script), 0, 0, v8::Handle<v8::String>(), v8::Script::NativeMode);
- v8::Local<v8::Value> result = registerScript->Run();
+ v8::Handle<v8::Script> registerScript = v8::Script::New(v8::String::New(script), 0, 0, v8::Handle<v8::String>(), v8::Script::NativeMode);
+ v8::Handle<v8::Value> result = registerScript->Run();
Q_ASSERT(result->IsFunction());
- v8::Local<v8::Function> registerFunc = v8::Local<v8::Function>::Cast(result);
+ v8::Handle<v8::Function> registerFunc = v8::Handle<v8::Function>::Cast(result);
v8::Handle<v8::Value> args = V8FUNCTION(func, engine);
- registerFunc->Call(v8::Local<v8::Object>::Cast(registerFunc), 1, &args);
+ registerFunc->Call(v8::Handle<v8::Object>::Cast(registerFunc), 1, &args);
}
void QQmlDateExtension::registerExtension(QV8Engine *engine)
if (args.Length() > 1) {
if (!args[1]->IsString())
V8THROW_ERROR("Locale: Number.toLocaleString(): Invalid arguments");
- v8::Local<v8::String> fs = args[1]->ToString();
+ v8::Handle<v8::String> fs = args[1]->ToString();
if (!fs.IsEmpty() && fs->Length()) {
v8::String::Value value(fs);
Q_ASSERT(*value != NULL);
numberIdx = 1;
}
- v8::Local<v8::String> ns = args[numberIdx]->ToString();
+ v8::Handle<v8::String> ns = args[numberIdx]->ToString();
if (ns.IsEmpty() || ns->Length() == 0)
return v8::Number::New(Q_QNAN);
//--------------
// Locale object
-static v8::Handle<v8::Value> locale_get_firstDayOfWeek(v8::Local<v8::String>, const v8::AccessorInfo &info)
+static v8::Handle<v8::Value> locale_get_firstDayOfWeek(v8::Handle<v8::String>, const v8::AccessorInfo &info)
{
GET_LOCALE_DATA_RESOURCE(info.This());
int fdow = int(r->locale.firstDayOfWeek());
return v8::Integer::New(fdow);
}
-static v8::Handle<v8::Value> locale_get_measurementSystem(v8::Local<v8::String>, const v8::AccessorInfo &info)
+static v8::Handle<v8::Value> locale_get_measurementSystem(v8::Handle<v8::String>, const v8::AccessorInfo &info)
{
GET_LOCALE_DATA_RESOURCE(info.This());
return v8::Integer::New(r->locale.measurementSystem());
}
-static v8::Handle<v8::Value> locale_get_textDirection(v8::Local<v8::String>, const v8::AccessorInfo &info)
+static v8::Handle<v8::Value> locale_get_textDirection(v8::Handle<v8::String>, const v8::AccessorInfo &info)
{
GET_LOCALE_DATA_RESOURCE(info.This());
return v8::Integer::New(r->locale.textDirection());
}
-static v8::Handle<v8::Value> locale_get_weekDays(v8::Local<v8::String>, const v8::AccessorInfo &info)
+static v8::Handle<v8::Value> locale_get_weekDays(v8::Handle<v8::String>, const v8::AccessorInfo &info)
{
GET_LOCALE_DATA_RESOURCE(info.This());
return result;
}
-static v8::Handle<v8::Value> locale_get_uiLanguages(v8::Local<v8::String>, const v8::AccessorInfo &info)
+static v8::Handle<v8::Value> locale_get_uiLanguages(v8::Handle<v8::String>, const v8::AccessorInfo &info)
{
GET_LOCALE_DATA_RESOURCE(info.This());
LOCALE_FORMATTED_DAYNAME(dayName)
LOCALE_FORMATTED_DAYNAME(standaloneDayName)
-#define LOCALE_STRING_PROPERTY(VARIABLE) static v8::Handle<v8::Value> locale_get_ ## VARIABLE (v8::Local<v8::String>, const v8::AccessorInfo &info) \
+#define LOCALE_STRING_PROPERTY(VARIABLE) static v8::Handle<v8::Value> locale_get_ ## VARIABLE (v8::Handle<v8::String>, const v8::AccessorInfo &info) \
{ \
GET_LOCALE_DATA_RESOURCE(info.This()); \
return r->engine->toString(r->locale. VARIABLE());\
QV8LocaleDataDeletable::QV8LocaleDataDeletable(QV8Engine *engine)
{
- v8::Local<v8::FunctionTemplate> ft = v8::FunctionTemplate::New();
+ v8::Handle<v8::FunctionTemplate> ft = v8::FunctionTemplate::New();
ft->InstanceTemplate()->SetHasExternalResource(true);
LOCALE_REGISTER_STRING_ACCESSOR(ft, name);
v8::Handle<v8::Value> QQmlLocale::locale(QV8Engine *v8engine, const QString &locale)
{
QV8LocaleDataDeletable *d = localeV8Data(v8engine);
- v8::Local<v8::Object> v8Value = d->constructor->NewInstance();
+ v8::Handle<v8::Object> v8Value = d->constructor->NewInstance();
QV8LocaleDataResource *r = new QV8LocaleDataResource(v8engine);
if (locale.isEmpty())
r->locale = QLocale();
QQmlPropertyData::Flag signalFlags = QQmlPropertyData::NoFlags);
// Implemented in v8/qv8qobjectwrapper.cpp
- v8::Local<v8::Object> newQObject(QObject *, QV8Engine *);
+ v8::Handle<v8::Object> newQObject(QObject *, QV8Engine *);
QQmlPropertyCacheMethodArguments *createArgumentsObject(int count,
const QList<QByteArray> &names = QList<QByteArray>());
QV8Engine *v8engine = ep->v8engine();
// If compilation throws an error, a surrounding v8::TryCatch will record it.
- v8::Local<v8::Script> program = v8engine->qmlModeCompile(m_programSource.constData(),
+ v8::Handle<v8::Script> program = v8engine->qmlModeCompile(m_programSource.constData(),
m_programSource.length(), urlString, 1);
if (program.IsEmpty())
return;
if (!script->isInitialized())
script->initialize(parentCtxt->engine);
- v8::Local<v8::Object> qmlglobal = v8engine->qmlScope(ctxt, 0);
+ v8::Handle<v8::Object> qmlglobal = v8engine->qmlScope(ctxt, 0);
v8engine->contextWrapper()->takeContextOwnership(qmlglobal);
if (!script->m_program.IsEmpty()) {
}
if (try_catch.HasCaught()) {
- v8::Local<v8::Message> message = try_catch.Message();
+ v8::Handle<v8::Message> message = try_catch.Message();
if (!message.IsEmpty()) {
QQmlError error;
QQmlExpressionPrivate::exceptionToError(message, error);
v8::TryCatch try_catch;
- v8::Local<v8::Value> result = function->Call(v8::Value::fromV4Value(ep->v8engine()->global()), data->parameterCount, args);
+ v8::Handle<v8::Value> result = function->Call(v8::Value::fromV4Value(ep->v8engine()->global()), data->parameterCount, args);
QVariant rv;
if (try_catch.HasCaught()) {
// Importantly, if the current value is a scarce resource, we need to ensure that it
// gets automatically released by the engine if no other references to it exist.
- v8::Local<v8::Value> oldv = varProperties->Get(id - firstVarPropertyIndex);
+ v8::Handle<v8::Value> oldv = varProperties->Get(id - firstVarPropertyIndex);
if (oldv->IsObject()) {
QV8VariantResource *r = v8_resource_cast<QV8VariantResource>(v8::Handle<v8::Object>::Cast(oldv));
if (r) {
// Importantly, if the current value is a scarce resource, we need to ensure that it
// gets automatically released by the engine if no other references to it exist.
- v8::Local<v8::Value> oldv = varProperties->Get(id - firstVarPropertyIndex);
+ v8::Handle<v8::Value> oldv = varProperties->Get(id - firstVarPropertyIndex);
if (oldv->IsObject()) {
QV8VariantResource *r = v8_resource_cast<QV8VariantResource>(v8::Handle<v8::Object>::Cast(oldv));
if (r) {
v8::Persistent<v8::Object> cdataPrototype;
v8::Persistent<v8::Object> documentPrototype;
- v8::Local<v8::Object> newNode();
+ v8::Handle<v8::Object> newNode();
};
static inline QQmlXMLHttpRequestData *xhrdata(QV8Engine *engine)
return (QQmlXMLHttpRequestData *)engine->xmlHttpRequestData();
}
-static v8::Local<v8::Object> constructMeObject(v8::Handle<v8::Object> thisObj, QV8Engine *e)
+static v8::Handle<v8::Object> constructMeObject(v8::Handle<v8::Object> thisObj, QV8Engine *e)
{
- v8::Local<v8::Object> meObj = v8::Object::New();
+ v8::Handle<v8::Object> meObj = v8::Object::New();
meObj->Set(v8::String::New("ThisObject"), thisObj);
meObj->Set(v8::String::New("ActivationObject"), e->qmlScope(e->callingContext(), 0));
return meObj;
qPersistentDispose(documentPrototype);
}
-v8::Local<v8::Object> QQmlXMLHttpRequestData::newNode()
+v8::Handle<v8::Object> QQmlXMLHttpRequestData::newNode()
{
if (nodeFunction.IsEmpty()) {
- v8::Local<v8::FunctionTemplate> ft = v8::FunctionTemplate::New();
+ v8::Handle<v8::FunctionTemplate> ft = v8::FunctionTemplate::New();
ft->InstanceTemplate()->SetHasExternalResource(true);
nodeFunction = qPersistentNew<v8::Function>(ft->GetFunction());
}
{
public:
// JS API
- static v8::Handle<v8::Value> length(v8::Local<v8::String>, const v8::AccessorInfo& args);
+ static v8::Handle<v8::Value> length(v8::Handle<v8::String>, const v8::AccessorInfo& args);
static v8::Handle<v8::Value> indexed(uint32_t index, const v8::AccessorInfo& info);
- static v8::Handle<v8::Value> named(v8::Local<v8::String> property, const v8::AccessorInfo& args);
+ static v8::Handle<v8::Value> named(v8::Handle<v8::String> property, const v8::AccessorInfo& args);
// C++ API
static v8::Handle<v8::Object> prototype(QV8Engine *);
{
public:
// JS API
- static v8::Handle<v8::Value> length(v8::Local<v8::String>, const v8::AccessorInfo& args);
+ static v8::Handle<v8::Value> length(v8::Handle<v8::String>, const v8::AccessorInfo& args);
static v8::Handle<v8::Value> indexed(uint32_t index, const v8::AccessorInfo& info);
// C++ API
{
public:
// JS API
- static v8::Handle<v8::Value> nodeName(v8::Local<v8::String>, const v8::AccessorInfo& args);
- static v8::Handle<v8::Value> nodeValue(v8::Local<v8::String>, const v8::AccessorInfo& args);
- static v8::Handle<v8::Value> nodeType(v8::Local<v8::String>, const v8::AccessorInfo& args);
-
- static v8::Handle<v8::Value> parentNode(v8::Local<v8::String>, const v8::AccessorInfo& args);
- static v8::Handle<v8::Value> childNodes(v8::Local<v8::String>, const v8::AccessorInfo& args);
- static v8::Handle<v8::Value> firstChild(v8::Local<v8::String>, const v8::AccessorInfo& args);
- static v8::Handle<v8::Value> lastChild(v8::Local<v8::String>, const v8::AccessorInfo& args);
- static v8::Handle<v8::Value> previousSibling(v8::Local<v8::String>, const v8::AccessorInfo& args);
- static v8::Handle<v8::Value> nextSibling(v8::Local<v8::String>, const v8::AccessorInfo& args);
- static v8::Handle<v8::Value> attributes(v8::Local<v8::String>, const v8::AccessorInfo& args);
+ static v8::Handle<v8::Value> nodeName(v8::Handle<v8::String>, const v8::AccessorInfo& args);
+ static v8::Handle<v8::Value> nodeValue(v8::Handle<v8::String>, const v8::AccessorInfo& args);
+ static v8::Handle<v8::Value> nodeType(v8::Handle<v8::String>, const v8::AccessorInfo& args);
+
+ static v8::Handle<v8::Value> parentNode(v8::Handle<v8::String>, const v8::AccessorInfo& args);
+ static v8::Handle<v8::Value> childNodes(v8::Handle<v8::String>, const v8::AccessorInfo& args);
+ static v8::Handle<v8::Value> firstChild(v8::Handle<v8::String>, const v8::AccessorInfo& args);
+ static v8::Handle<v8::Value> lastChild(v8::Handle<v8::String>, const v8::AccessorInfo& args);
+ static v8::Handle<v8::Value> previousSibling(v8::Handle<v8::String>, const v8::AccessorInfo& args);
+ static v8::Handle<v8::Value> nextSibling(v8::Handle<v8::String>, const v8::AccessorInfo& args);
+ static v8::Handle<v8::Value> attributes(v8::Handle<v8::String>, const v8::AccessorInfo& args);
//static v8::Handle<v8::Value> ownerDocument(v8::Local<v8::String>, const v8::AccessorInfo& args);
//static v8::Handle<v8::Value> namespaceURI(v8::Local<v8::String>, const v8::AccessorInfo& args);
{
public:
// JS API
- static v8::Handle<v8::Value> name(v8::Local<v8::String>, const v8::AccessorInfo& args);
- static v8::Handle<v8::Value> specified(v8::Local<v8::String>, const v8::AccessorInfo& args);
- static v8::Handle<v8::Value> value(v8::Local<v8::String>, const v8::AccessorInfo& args);
- static v8::Handle<v8::Value> ownerElement(v8::Local<v8::String>, const v8::AccessorInfo& args);
- static v8::Handle<v8::Value> schemaTypeInfo(v8::Local<v8::String>, const v8::AccessorInfo& args);
- static v8::Handle<v8::Value> isId(v8::Local<v8::String>, const v8::AccessorInfo& args);
+ static v8::Handle<v8::Value> name(v8::Handle<v8::String>, const v8::AccessorInfo& args);
+ static v8::Handle<v8::Value> specified(v8::Handle<v8::String>, const v8::AccessorInfo& args);
+ static v8::Handle<v8::Value> value(v8::Handle<v8::String>, const v8::AccessorInfo& args);
+ static v8::Handle<v8::Value> ownerElement(v8::Handle<v8::String>, const v8::AccessorInfo& args);
+ static v8::Handle<v8::Value> schemaTypeInfo(v8::Handle<v8::String>, const v8::AccessorInfo& args);
+ static v8::Handle<v8::Value> isId(v8::Handle<v8::String>, const v8::AccessorInfo& args);
// C++ API
static v8::Handle<v8::Object> prototype(QV8Engine *);
{
public:
// JS API
- static v8::Handle<v8::Value> length(v8::Local<v8::String>, const v8::AccessorInfo& args);
+ static v8::Handle<v8::Value> length(v8::Handle<v8::String>, const v8::AccessorInfo& args);
// C++ API
static v8::Handle<v8::Object> prototype(QV8Engine *);
{
public:
// JS API
- static v8::Handle<v8::Value> isElementContentWhitespace(v8::Local<v8::String>, const v8::AccessorInfo& args);
- static v8::Handle<v8::Value> wholeText(v8::Local<v8::String>, const v8::AccessorInfo& args);
+ static v8::Handle<v8::Value> isElementContentWhitespace(v8::Handle<v8::String>, const v8::AccessorInfo& args);
+ static v8::Handle<v8::Value> wholeText(v8::Handle<v8::String>, const v8::AccessorInfo& args);
// C++ API
static v8::Handle<v8::Object> prototype(QV8Engine *);
{
public:
// JS API
- static v8::Handle<v8::Value> xmlVersion(v8::Local<v8::String>, const v8::AccessorInfo& args);
- static v8::Handle<v8::Value> xmlEncoding(v8::Local<v8::String>, const v8::AccessorInfo& args);
- static v8::Handle<v8::Value> xmlStandalone(v8::Local<v8::String>, const v8::AccessorInfo& args);
- static v8::Handle<v8::Value> documentElement(v8::Local<v8::String>, const v8::AccessorInfo& args);
+ static v8::Handle<v8::Value> xmlVersion(v8::Handle<v8::String>, const v8::AccessorInfo& args);
+ static v8::Handle<v8::Value> xmlEncoding(v8::Handle<v8::String>, const v8::AccessorInfo& args);
+ static v8::Handle<v8::Value> xmlStandalone(v8::Handle<v8::String>, const v8::AccessorInfo& args);
+ static v8::Handle<v8::Value> documentElement(v8::Handle<v8::String>, const v8::AccessorInfo& args);
// C++ API
static v8::Handle<v8::Object> prototype(QV8Engine *);
D(document);
}
-v8::Handle<v8::Value> Node::nodeName(v8::Local<v8::String>, const v8::AccessorInfo &args)
+v8::Handle<v8::Value> Node::nodeName(v8::Handle<v8::String>, const v8::AccessorInfo &args)
{
QQmlDOMNodeResource *r = v8_resource_cast<QQmlDOMNodeResource>(args.This());
if (!r) return v8::Undefined();
}
}
-v8::Handle<v8::Value> Node::nodeValue(v8::Local<v8::String>, const v8::AccessorInfo &args)
+v8::Handle<v8::Value> Node::nodeValue(v8::Handle<v8::String>, const v8::AccessorInfo &args)
{
QQmlDOMNodeResource *r = v8_resource_cast<QQmlDOMNodeResource>(args.This());
if (!r) return v8::Undefined();
return engine->toString(r->d->data);
}
-v8::Handle<v8::Value> Node::nodeType(v8::Local<v8::String>, const v8::AccessorInfo &args)
+v8::Handle<v8::Value> Node::nodeType(v8::Handle<v8::String>, const v8::AccessorInfo &args)
{
QQmlDOMNodeResource *r = v8_resource_cast<QQmlDOMNodeResource>(args.This());
if (!r) return v8::Undefined();
return v8::Integer::New(r->d->type);
}
-v8::Handle<v8::Value> Node::parentNode(v8::Local<v8::String>, const v8::AccessorInfo &args)
+v8::Handle<v8::Value> Node::parentNode(v8::Handle<v8::String>, const v8::AccessorInfo &args)
{
QQmlDOMNodeResource *r = v8_resource_cast<QQmlDOMNodeResource>(args.This());
if (!r) return v8::Undefined();
else return v8::Null();
}
-v8::Handle<v8::Value> Node::childNodes(v8::Local<v8::String>, const v8::AccessorInfo &args)
+v8::Handle<v8::Value> Node::childNodes(v8::Handle<v8::String>, const v8::AccessorInfo &args)
{
QQmlDOMNodeResource *r = v8_resource_cast<QQmlDOMNodeResource>(args.This());
if (!r) return v8::Undefined();
return NodeList::create(engine, r->d);
}
-v8::Handle<v8::Value> Node::firstChild(v8::Local<v8::String>, const v8::AccessorInfo &args)
+v8::Handle<v8::Value> Node::firstChild(v8::Handle<v8::String>, const v8::AccessorInfo &args)
{
QQmlDOMNodeResource *r = v8_resource_cast<QQmlDOMNodeResource>(args.This());
if (!r) return v8::Undefined();
else return Node::create(engine, r->d->children.first());
}
-v8::Handle<v8::Value> Node::lastChild(v8::Local<v8::String>, const v8::AccessorInfo &args)
+v8::Handle<v8::Value> Node::lastChild(v8::Handle<v8::String>, const v8::AccessorInfo &args)
{
QQmlDOMNodeResource *r = v8_resource_cast<QQmlDOMNodeResource>(args.This());
if (!r) return v8::Undefined();
else return Node::create(engine, r->d->children.last());
}
-v8::Handle<v8::Value> Node::previousSibling(v8::Local<v8::String>, const v8::AccessorInfo &args)
+v8::Handle<v8::Value> Node::previousSibling(v8::Handle<v8::String>, const v8::AccessorInfo &args)
{
QQmlDOMNodeResource *r = v8_resource_cast<QQmlDOMNodeResource>(args.This());
if (!r) return v8::Undefined();
return v8::Null();
}
-v8::Handle<v8::Value> Node::nextSibling(v8::Local<v8::String>, const v8::AccessorInfo &args)
+v8::Handle<v8::Value> Node::nextSibling(v8::Handle<v8::String>, const v8::AccessorInfo &args)
{
QQmlDOMNodeResource *r = v8_resource_cast<QQmlDOMNodeResource>(args.This());
if (!r) return v8::Undefined();
return v8::Null();
}
-v8::Handle<v8::Value> Node::attributes(v8::Local<v8::String>, const v8::AccessorInfo &args)
+v8::Handle<v8::Value> Node::attributes(v8::Handle<v8::String>, const v8::AccessorInfo &args)
{
QQmlDOMNodeResource *r = v8_resource_cast<QQmlDOMNodeResource>(args.This());
if (!r) return v8::Undefined();
v8::Handle<v8::Value> Node::create(QV8Engine *engine, NodeImpl *data)
{
QQmlXMLHttpRequestData *d = xhrdata(engine);
- v8::Local<v8::Object> instance = d->newNode();
+ v8::Handle<v8::Object> instance = d->newNode();
switch (data->type) {
case NodeImpl::Attr:
return d->attrPrototype;
}
-v8::Handle<v8::Value> Attr::name(v8::Local<v8::String>, const v8::AccessorInfo &args)
+v8::Handle<v8::Value> Attr::name(v8::Handle<v8::String>, const v8::AccessorInfo &args)
{
QQmlDOMNodeResource *r = v8_resource_cast<QQmlDOMNodeResource>(args.This());
if (!r) return v8::Undefined();
return engine->toString(r->d->name);
}
-v8::Handle<v8::Value> Attr::value(v8::Local<v8::String>, const v8::AccessorInfo &args)
+v8::Handle<v8::Value> Attr::value(v8::Handle<v8::String>, const v8::AccessorInfo &args)
{
QQmlDOMNodeResource *r = v8_resource_cast<QQmlDOMNodeResource>(args.This());
if (!r) return v8::Undefined();
return engine->toString(r->d->data);
}
-v8::Handle<v8::Value> Attr::ownerElement(v8::Local<v8::String>, const v8::AccessorInfo &args)
+v8::Handle<v8::Value> Attr::ownerElement(v8::Handle<v8::String>, const v8::AccessorInfo &args)
{
QQmlDOMNodeResource *r = v8_resource_cast<QQmlDOMNodeResource>(args.This());
if (!r) return v8::Undefined();
return Node::create(engine, r->d->parent);
}
-v8::Handle<v8::Value> CharacterData::length(v8::Local<v8::String>, const v8::AccessorInfo &args)
+v8::Handle<v8::Value> CharacterData::length(v8::Handle<v8::String>, const v8::AccessorInfo &args)
{
QQmlDOMNodeResource *r = v8_resource_cast<QQmlDOMNodeResource>(args.This());
if (!r) return v8::Undefined();
return d->characterDataPrototype;
}
-v8::Handle<v8::Value> Text::isElementContentWhitespace(v8::Local<v8::String>, const v8::AccessorInfo &args)
+v8::Handle<v8::Value> Text::isElementContentWhitespace(v8::Handle<v8::String>, const v8::AccessorInfo &args)
{
QQmlDOMNodeResource *r = v8_resource_cast<QQmlDOMNodeResource>(args.This());
if (!r) return v8::Undefined();
return v8::Boolean::New(r->d->data.trimmed().isEmpty());
}
-v8::Handle<v8::Value> Text::wholeText(v8::Local<v8::String>, const v8::AccessorInfo &args)
+v8::Handle<v8::Value> Text::wholeText(v8::Handle<v8::String>, const v8::AccessorInfo &args)
{
QQmlDOMNodeResource *r = v8_resource_cast<QQmlDOMNodeResource>(args.This());
if (!r) return v8::Undefined();
return v8::Null();
}
- v8::Local<v8::Object> instance = xhrdata(engine)->newNode();
+ v8::Handle<v8::Object> instance = xhrdata(engine)->newNode();
QQmlDOMNodeResource *r = new QQmlDOMNodeResource(engine);
r->d = document;
instance->SetExternalResource(r);
return d == 0;
}
-v8::Handle<v8::Value> NamedNodeMap::length(v8::Local<v8::String>, const v8::AccessorInfo &args)
+v8::Handle<v8::Value> NamedNodeMap::length(v8::Handle<v8::String>, const v8::AccessorInfo &args)
{
QQmlDOMNodeResource *r = v8_resource_cast<QQmlDOMNodeResource>(args.This());
if (!r) return v8::Undefined();
}
}
-v8::Handle<v8::Value> NamedNodeMap::named(v8::Local<v8::String> property, const v8::AccessorInfo& args)
+v8::Handle<v8::Value> NamedNodeMap::named(v8::Handle<v8::String> property, const v8::AccessorInfo& args)
{
QQmlDOMNodeResource *r = v8_resource_cast<QQmlDOMNodeResource>(args.This());
if (!r || !r->list) return v8::Undefined();
{
QQmlXMLHttpRequestData *d = xhrdata(engine);
if (d->namedNodeMapPrototype.IsEmpty()) {
- v8::Local<v8::ObjectTemplate> ot = v8::ObjectTemplate::New();
+ v8::Handle<v8::ObjectTemplate> ot = v8::ObjectTemplate::New();
ot->SetAccessor(v8::String::New("length"), length, 0, v8::External::New(engine));
ot->SetIndexedPropertyHandler(indexed, 0, 0, 0, 0, v8::External::New(engine));
ot->SetFallbackPropertyHandler(named, 0, 0, 0, 0, v8::External::New(engine));
v8::Handle<v8::Value> NamedNodeMap::create(QV8Engine *engine, NodeImpl *data, QList<NodeImpl *> *list)
{
QQmlXMLHttpRequestData *d = xhrdata(engine);
- v8::Local<v8::Object> instance = d->newNode();
+ v8::Handle<v8::Object> instance = d->newNode();
instance->SetPrototype(NamedNodeMap::prototype(engine));
QQmlDOMNodeResource *r = new QQmlDOMNodeResource(engine);
r->d = data;
}
}
-v8::Handle<v8::Value> NodeList::length(v8::Local<v8::String>, const v8::AccessorInfo& args)
+v8::Handle<v8::Value> NodeList::length(v8::Handle<v8::String>, const v8::AccessorInfo& args)
{
QQmlDOMNodeResource *r = v8_resource_cast<QQmlDOMNodeResource>(args.This());
if (!r) return v8::Undefined();
{
QQmlXMLHttpRequestData *d = xhrdata(engine);
if (d->nodeListPrototype.IsEmpty()) {
- v8::Local<v8::ObjectTemplate> ot = v8::ObjectTemplate::New();
+ v8::Handle<v8::ObjectTemplate> ot = v8::ObjectTemplate::New();
ot->SetAccessor(v8::String::New("length"), length, 0, v8::External::New(engine));
ot->SetIndexedPropertyHandler(indexed, 0, 0, 0, 0, v8::External::New(engine));
d->nodeListPrototype = qPersistentNew<v8::Object>(ot->NewInstance());
v8::Handle<v8::Value> NodeList::create(QV8Engine *engine, NodeImpl *data)
{
QQmlXMLHttpRequestData *d = xhrdata(engine);
- v8::Local<v8::Object> instance = d->newNode();
+ v8::Handle<v8::Object> instance = d->newNode();
instance->SetPrototype(NodeList::prototype(engine));
QQmlDOMNodeResource *r = new QQmlDOMNodeResource(engine);
r->d = data;
return instance;
}
-v8::Handle<v8::Value> Document::documentElement(v8::Local<v8::String>, const v8::AccessorInfo& args)
+v8::Handle<v8::Value> Document::documentElement(v8::Handle<v8::String>, const v8::AccessorInfo& args)
{
QQmlDOMNodeResource *r = v8_resource_cast<QQmlDOMNodeResource>(args.This());
if (!r || r->d->type != NodeImpl::Document) return v8::Undefined();
return Node::create(engine, static_cast<DocumentImpl *>(r->d)->root);
}
-v8::Handle<v8::Value> Document::xmlStandalone(v8::Local<v8::String>, const v8::AccessorInfo& args)
+v8::Handle<v8::Value> Document::xmlStandalone(v8::Handle<v8::String>, const v8::AccessorInfo& args)
{
QQmlDOMNodeResource *r = v8_resource_cast<QQmlDOMNodeResource>(args.This());
if (!r || r->d->type != NodeImpl::Document) return v8::Undefined();
return v8::Boolean::New(static_cast<DocumentImpl *>(r->d)->isStandalone);
}
-v8::Handle<v8::Value> Document::xmlVersion(v8::Local<v8::String>, const v8::AccessorInfo& args)
+v8::Handle<v8::Value> Document::xmlVersion(v8::Handle<v8::String>, const v8::AccessorInfo& args)
{
QQmlDOMNodeResource *r = v8_resource_cast<QQmlDOMNodeResource>(args.This());
if (!r || r->d->type != NodeImpl::Document) return v8::Undefined();
return engine->toString(static_cast<DocumentImpl *>(r->d)->version);
}
-v8::Handle<v8::Value> Document::xmlEncoding(v8::Local<v8::String>, const v8::AccessorInfo& args)
+v8::Handle<v8::Value> Document::xmlEncoding(v8::Handle<v8::String>, const v8::AccessorInfo& args)
{
QQmlDOMNodeResource *r = v8_resource_cast<QQmlDOMNodeResource>(args.This());
if (!r || r->d->type != NodeImpl::Document) return v8::Undefined();
return;
}
- v8::Local<v8::Object> thisObj = me->Get(v8::String::New("ThisObject"))->ToObject();
- v8::Local<v8::Value> callback = thisObj->Get(v8::String::New("onreadystatechange"));
+ v8::Handle<v8::Object> thisObj = me->Get(v8::String::New("ThisObject"))->ToObject();
+ v8::Handle<v8::Value> callback = thisObj->Get(v8::String::New("onreadystatechange"));
if (!callback->IsFunction()) {
// not an error, but no onreadystatechange function to call.
return;
return;
}
- v8::Local<v8::Object> activationObject = me->Get(v8::String::New("ActivationObject"))->ToObject();
+ v8::Handle<v8::Object> activationObject = me->Get(v8::String::New("ActivationObject"))->ToObject();
QQmlContextData *callingContext = engine->contextWrapper()->context(activationObject);
if (callingContext) {
- v8::Local<v8::Function> f = v8::Local<v8::Function>::Cast(callback);
+ v8::Handle<v8::Function> f = v8::Handle<v8::Function>::Cast(callback);
f->Call(activationObject, 0, 0); // valid activation object.
}
}
// XMLHttpRequest properties
-static v8::Handle<v8::Value> qmlxmlhttprequest_readyState(v8::Local<v8::String> /* property */,
+static v8::Handle<v8::Value> qmlxmlhttprequest_readyState(v8::Handle<v8::String> /* property */,
const v8::AccessorInfo& info)
{
QQmlXMLHttpRequest *r = v8_resource_cast<QQmlXMLHttpRequest>(info.This());
return v8::Integer::NewFromUnsigned(r->readyState());
}
-static v8::Handle<v8::Value> qmlxmlhttprequest_status(v8::Local<v8::String> /* property */,
+static v8::Handle<v8::Value> qmlxmlhttprequest_status(v8::Handle<v8::String> /* property */,
const v8::AccessorInfo& info)
{
QQmlXMLHttpRequest *r = v8_resource_cast<QQmlXMLHttpRequest>(info.This());
return v8::Integer::New(r->replyStatus());
}
-static v8::Handle<v8::Value> qmlxmlhttprequest_statusText(v8::Local<v8::String> /* property */,
+static v8::Handle<v8::Value> qmlxmlhttprequest_statusText(v8::Handle<v8::String> /* property */,
const v8::AccessorInfo& info)
{
QQmlXMLHttpRequest *r = v8_resource_cast<QQmlXMLHttpRequest>(info.This());
return engine->toString(r->replyStatusText());
}
-static v8::Handle<v8::Value> qmlxmlhttprequest_responseText(v8::Local<v8::String> /* property */,
+static v8::Handle<v8::Value> qmlxmlhttprequest_responseText(v8::Handle<v8::String> /* property */,
const v8::AccessorInfo& info)
{
QQmlXMLHttpRequest *r = v8_resource_cast<QQmlXMLHttpRequest>(info.This());
return engine->toString(r->responseBody());
}
-static v8::Handle<v8::Value> qmlxmlhttprequest_responseXML(v8::Local<v8::String> /* property */,
+static v8::Handle<v8::Value> qmlxmlhttprequest_responseXML(v8::Handle<v8::String> /* property */,
const v8::AccessorInfo& info)
{
QQmlXMLHttpRequest *r = v8_resource_cast<QQmlXMLHttpRequest>(info.This());
v8::PropertyAttribute attributes = (v8::PropertyAttribute)(v8::ReadOnly | v8::DontEnum | v8::DontDelete);
// XMLHttpRequest
- v8::Local<v8::FunctionTemplate> xmlhttprequest = v8::FunctionTemplate::New(qmlxmlhttprequest_new,
+ v8::Handle<v8::FunctionTemplate> xmlhttprequest = v8::FunctionTemplate::New(qmlxmlhttprequest_new,
v8::External::New(engine));
xmlhttprequest->InstanceTemplate()->SetHasExternalResource(true);
xmlhttprequest->Set(v8::String::New("HEADERS_RECEIVED"), v8::Integer::New(2), attributes);
xmlhttprequest->Set(v8::String::New("LOADING"), v8::Integer::New(3), attributes);
xmlhttprequest->Set(v8::String::New("DONE"), v8::Integer::New(4), attributes);
- v8::Local<v8::Object>::New(v8::Value::fromV4Value(engine->global()))->Set(v8::String::New("XMLHttpRequest"), xmlhttprequest->GetFunction());
+ v8::Handle<v8::Object>(engine->global())->Set(v8::String::New("XMLHttpRequest"), xmlhttprequest->GetFunction());
QQmlXMLHttpRequestData *data = new QQmlXMLHttpRequestData;
return data;
AccessorInfo info(thisObject, getter->data);
QV4::Value result = QV4::Value::undefinedValue();
try {
- result = getter->getter(Local<String>::New(getter->name), info)->v4Value();
+ result = getter->getter(getter->name, info)->v4Value();
} catch (QV4::Exception &e) {
Isolate::GetCurrent()->setException(e.value());
e.accept(context);
V8AccessorSetter *setter = static_cast<V8AccessorSetter*>(that);
AccessorInfo info(thisObject, setter->data);
try {
- setter->setter(Local<String>::New(setter->name), Local<Value>::New(Value::fromV4Value(args[0])), info);
+ setter->setter(setter->name, args[0], info);
} catch (QV4::Exception &e) {
Isolate::GetCurrent()->setException(e.value());
e.accept(context);
}
-Local<Script> Script::New(Handle<String> source,
+Handle<Script> Script::New(Handle<String> source,
ScriptOrigin* origin,
ScriptData* pre_data,
Handle<String> script_data,
if (origin)
s->m_origin = *origin;
s->m_flags = flags;
- return Local<Script>::New(Handle<Script>(s));
+ return Handle<Script>(s);
}
-Local<Script> Script::New(Handle<String> source,
+Handle<Script> Script::New(Handle<String> source,
Handle<Value> file_name,
CompileFlags flags)
{
return New(source, &origin, 0, Handle<String>(), flags);
}
-Local<Script> Script::Compile(Handle<String> source, ScriptOrigin *origin, ScriptData *pre_data, Handle<String> script_data, Script::CompileFlags flags)
+Handle<Script> Script::Compile(Handle<String> source, ScriptOrigin *origin, ScriptData *pre_data, Handle<String> script_data, Script::CompileFlags flags)
{
Script *s = new Script;
s->m_script = source->ToString()->asQString();
if (origin)
s->m_origin = *origin;
s->m_flags = flags;
- return Local<Script>::New(Handle<Script>(s));
+ return Handle<Script>(s);
}
-Local<Script> Script::Compile(Handle<String> source,
+Handle<Script> Script::Compile(Handle<String> source,
Handle<Value> file_name,
Handle<String> script_data,
CompileFlags flags)
return Compile(source, &origin, 0, script_data, flags);
}
-Local<Value> Script::Run()
+Handle<Value> Script::Run()
{
QV4::ExecutionEngine *engine = Isolate::GetCurrent()->GetEngine();
QV4::ExecutionContext *ctx = engine->current;
} catch (QV4::Exception &e) {
Isolate::GetCurrent()->setException(e.value());
e.accept(ctx);
- return Local<Value>();
+ return Handle<Value>();
}
- return Local<Value>::New(Value::fromV4Value(result));
+ return result;
}
-Local<Value> Script::Run(Handle<Object> qml)
+Handle<Value> Script::Run(Handle<Object> qml)
{
QV4::ExecutionEngine *engine = Isolate::GetCurrent()->GetEngine();
QV4::ExecutionContext *ctx = engine->current;
} catch (QV4::Exception &e) {
Isolate::GetCurrent()->setException(e.value());
e.accept(ctx);
- return Local<Value>();
+ return Handle<Value>();
}
- return Local<Value>::New(Value::fromV4Value(result));
+ return result;
}
-Local<Value> Script::Id()
+Handle<Value> Script::Id()
{
Q_UNIMPLEMENTED();
Q_UNREACHABLE();
}
-Local<String> Message::Get() const
+Handle<String> Message::Get() const
{
- return Local<String>::New(Value::fromV4Value(QV4::Value::fromString(currentEngine()->current, m_message)));
+ return QV4::Value::fromString(currentEngine()->current, m_message);
}
Handle<Value> Message::GetScriptResourceName() const
}
-Local<StackFrame> StackTrace::GetFrame(uint32_t index) const
+Handle<StackFrame> StackTrace::GetFrame(uint32_t index) const
{
if (index >= (uint)frames.size())
- return Local<StackFrame>();
+ return Handle<StackFrame>();
return frames.at(index);
}
return frames.size();
}
-
Local<Array> StackTrace::AsArray()
+
Handle<Array> StackTrace::AsArray()
{
Q_UNIMPLEMENTED();
+ return
Handle<Array>();
}
-Local<StackTrace> StackTrace::CurrentStackTrace(int frame_limit, StackTrace::StackTraceOptions options)
+Handle<StackTrace> StackTrace::CurrentStackTrace(int frame_limit, StackTrace::StackTraceOptions options)
{
StackTrace *trace = new StackTrace;
QV4::ExecutionEngine *engine = currentEngine();
StackFrame *frame = new StackFrame(Value::fromV4Value(QV4::Value::fromString(engine->id_null)),
Value::fromV4Value(QV4::Value::fromString(c->function->name)),
0, 0);
- trace->frames.append(frame);
+ trace->frames.append(v8::Handle<v8::StackFrame>(frame));
--frame_limit;
}
current = current->parent;
}
- return Local<StackTrace>::New(Handle<StackTrace>(trace));
+ return Handle<StackTrace>(trace);
}
return m_columnNumber;
}
-Local<String> StackFrame::GetScriptName() const
+Handle<String> StackFrame::GetScriptName() const
{
- return Local<String>::New(m_scriptName);
+ return m_scriptName;
}
-Local<String> StackFrame::GetScriptNameOrSourceURL() const
+Handle<String> StackFrame::GetScriptNameOrSourceURL() const
{
- return Local<String>::New(m_scriptName);
+ return m_scriptName;
}
-Local<String> StackFrame::GetFunctionName() const
+Handle<String> StackFrame::GetFunctionName() const
{
- return Local<String>::New(m_functionName);
+ return m_functionName;
}
StackFrame::StackFrame(Handle<String> script, Handle<String> function, int line, int column)
return ConstValuePtr(this)->asErrorObject();
}
-Local<Boolean> Value::ToBoolean() const
+Handle<Boolean> Value::ToBoolean() const
{
- return Local<Boolean>::New(Value::fromV4Value(QV4::Value::fromBoolean(ConstValuePtr(this)->toBoolean())));
+ return QV4::Value::fromBoolean(ConstValuePtr(this)->toBoolean());
}
-Local<Number> Value::ToNumber() const
+Handle<Number> Value::ToNumber() const
{
- return Local<Number>::New(Value::fromV4Value(QV4::Value::fromDouble(ConstValuePtr(this)->toNumber())));
+ return QV4::Value::fromDouble(ConstValuePtr(this)->toNumber());
}
-Local<String> Value::ToString() const
+Handle<String> Value::ToString() const
{
- return Local<String>::New(Value::fromV4Value(QV4::Value::fromString(ConstValuePtr(this)->toString(currentEngine()->current))));
+ return QV4::Value::fromString(ConstValuePtr(this)->toString(currentEngine()->current));
}
-Local<Object> Value::ToObject() const
+Handle<Object> Value::ToObject() const
{
- return Local<Object>::New(Value::fromV4Value(QV4::Value::fromObject(ConstValuePtr(this)->toObject(currentEngine()->current))));
+ return QV4::Value::fromObject(ConstValuePtr(this)->toObject(currentEngine()->current));
}
-Local<Integer> Value::ToInteger() const
+Handle<Integer> Value::ToInteger() const
{
- return Local<Integer>::New(Value::fromV4Value(QV4::Value::fromDouble(ConstValuePtr(this)->toInteger())));
+ return QV4::Value::fromDouble(ConstValuePtr(this)->toInteger());
}
-Local<Uint32> Value::ToUint32() const
+Handle<Uint32> Value::ToUint32() const
{
- return Local<Uint32>::New(Value::fromV4Value(QV4::Value::fromUInt32(ConstValuePtr(this)->toUInt32())));
+ return QV4::Value::fromUInt32(ConstValuePtr(this)->toUInt32());
}
-Local<Int32> Value::ToInt32() const
+Handle<Int32> Value::ToInt32() const
{
- return Local<Int32>::New(Value::fromV4Value(QV4::Value::fromInt32(ConstValuePtr(this)->toInt32())));
+ return QV4::Value::fromInt32(ConstValuePtr(this)->toInt32());
}
-Local<Uint32> Value::ToArrayIndex() const
+Handle<Uint32> Value::ToArrayIndex() const
{
- return Local<Uint32>::New(Value::fromV4Value(QV4::Value::fromUInt32(ConstValuePtr(this)->asArrayIndex())));
+ return QV4::Value::fromUInt32(ConstValuePtr(this)->asArrayIndex());
}
bool Value::BooleanValue() const
}
-Local<String> String::New(const char *data, int length)
+Handle<String> String::New(const char *data, int length)
{
QV4::Value v = QV4::Value::fromString(currentEngine()->current, QString::fromLatin1(data, length));
- return Local<String>::New(v8::Value::fromV4Value(v));
+ return v;
}
-Local<String> String::New(const uint16_t *data, int length)
+Handle<String> String::New(const uint16_t *data, int length)
{
QV4::Value v = QV4::Value::fromString(currentEngine()->current, QString((const QChar *)data, length));
- return Local<String>::New(v8::Value::fromV4Value(v));
+ return v;
}
-Local<String> String::NewSymbol(const char *data, int length)
+Handle<String> String::NewSymbol(const char *data, int length)
{
QString str = QString::fromLatin1(data, length);
QV4::String *vmString = currentEngine()->newIdentifier(str);
return New(vmString);
}
-Local<String> String::New(QV4::String *s)
+Handle<String> String::New(QV4::String *s)
{
- return Local<String>::New(v8::Value::fromV4Value(QV4::Value::fromString(s)));
+ return QV4::Value::fromString(s);
}
-Local<String> String::NewExternal(String::ExternalStringResource *resource)
+Handle<String> String::NewExternal(String::ExternalStringResource *resource)
{
Q_UNIMPLEMENTED();
Q_UNREACHABLE();
return v->asDouble();
}
-Local<Number> Number::New(double value)
+Handle<Number> Number::New(double value)
{
- return Local<Number>::New(Value::fromV4Value(QV4::Value::fromDouble(value)));
+ return QV4::Value::fromDouble(value);
}
Number *Number::Cast(v8::Value *obj)
return static_cast<Number *>(obj);
}
-Local<Integer> Integer::New(int32_t value)
+Handle<Integer> Integer::New(int32_t value)
{
- return Local<Integer>::New(Value::fromV4Value(QV4::Value::fromInt32(value)));
+ return QV4::Value::fromInt32(value);
}
-Local<Integer> Integer::NewFromUnsigned(uint32_t value)
+Handle<Integer> Integer::NewFromUnsigned(uint32_t value)
{
- return Local<Integer>::New(Value::fromV4Value(QV4::Value::fromUInt32(value)));
+ return QV4::Value::fromUInt32(value);
}
int64_t Integer::Value() const
return result;
}
-Local<Value> Object::Get(Handle<Value> key)
+Handle<Value> Object::Get(Handle<Value> key)
{
QV4::Object *o = ConstValuePtr(this)->asObject();
assert(o);
} catch (QV4::Exception &e) {
Isolate::GetCurrent()->setException(e.value());
e.accept(ctx);
- return Local<Value>();
+ return Handle<Value>();
}
- return Local<Value>::New(Value::fromV4Value(prop));
+ return prop;
}
-Local<Value> Object::Get(uint32_t key)
+Handle<Value> Object::Get(uint32_t key)
{
QV4::Object *o = ConstValuePtr(this)->asObject();
assert(o);
} catch (QV4::Exception &e) {
Isolate::GetCurrent()->setException(e.value());
e.accept(ctx);
- return Local<Value>();
+ return Handle<Value>();
}
- return Local<Value>::New(Value::fromV4Value(prop));
+ return prop;
}
bool Object::Has(Handle<String> key)
return true;
}
-
Local<Array> Object::GetPropertyNames()
+
Handle<Array> Object::GetPropertyNames()
{
QV4::Object *o = ConstValuePtr(this)->asObject();
assert(o);
break;
array->push_back(v);
}
- return Local<Array>::New(Value::fromV4Value(QV4::Value::fromObject(array)));
+ return QV4::Value::fromObject(array);
}
-
Local<Array> Object::GetOwnPropertyNames()
+
Handle<Array> Object::GetOwnPropertyNames()
{
QV4::Object *o = ConstValuePtr(this)->asObject();
assert(o);
break;
array->push_back(v);
}
- return Local<Array>::New(Value::fromV4Value(QV4::Value::fromObject(array)));
+ return QV4::Value::fromObject(array);
}
-Local<Value> Object::GetPrototype()
+Handle<Value> Object::GetPrototype()
{
- Local<Value> result;
+ Handle<Value> result;
QV4::Object *o = ConstValuePtr(this)->asObject();
if (!o)
- return Local<Value>();
- return Local<Value>::New(Value::fromV4Value(QV4::Value::fromObject(o->prototype)));
+ return Handle<Value>();
+ return QV4::Value::fromObject(o->prototype);
}
bool Object::SetPrototype(Handle<Value> prototype)
return true;
}
-Local<Value> Object::GetInternalField(int index)
+Handle<Value> Object::GetInternalField(int index)
{
Q_UNIMPLEMENTED();
Q_UNREACHABLE();
Q_UNREACHABLE();
}
-Local<Value> Object::GetHiddenValue(Handle<String> key)
+Handle<Value> Object::GetHiddenValue(Handle<String> key)
{
Q_UNIMPLEMENTED();
Q_UNREACHABLE();
}
-Local<Object> Object::Clone()
+Handle<Object> Object::Clone()
{
Q_UNIMPLEMENTED();
Q_UNREACHABLE();
return ConstValuePtr(this)->asFunctionObject();
}
-Local<Value> Object::CallAsFunction(Handle<Object> recv, int argc, Handle<Value> argv[])
+Handle<Value> Object::CallAsFunction(Handle<Object> recv, int argc, Handle<Value> argv[])
{
QV4::FunctionObject *f = ConstValuePtr(this)->asFunctionObject();
if (!f)
- return Local<Value>();
+ return Handle<Value>();
ExecutionContext *context = currentEngine()->current;
try {
QV4::Value retval = f->call(context, recv->v4Value(),
reinterpret_cast<QV4::Value*>(argv),
argc);
- return Local<Value>::New(Value::fromV4Value(retval));
+ return retval;
} catch (QV4::Exception &e) {
Isolate::GetCurrent()->setException(e.value());
e.accept(context);
}
- return Local<Object>();
+ return Handle<Object>();
}
-Local<Value> Object::CallAsConstructor(int argc, Handle<Value> argv[])
+Handle<Value> Object::CallAsConstructor(int argc, Handle<Value> argv[])
{
QV4::FunctionObject *f = ConstValuePtr(this)->asFunctionObject();
if (!f)
- return Local<Value>();
+ return Handle<Value>();
ExecutionContext *context = currentEngine()->current;
try {
QV4::Value retval = f->construct(context,
reinterpret_cast<QV4::Value*>(argv),
argc);
- return Local<Value>::New(Value::fromV4Value(retval));
+ return retval;
} catch (QV4::Exception &e) {
Isolate::GetCurrent()->setException(e.value());
e.accept(context);
}
- return Local<Object>();
+ return Handle<Object>();
}
-Local<Object> Object::New()
+Handle<Object> Object::New()
{
QV4::Object *o = currentEngine()->newObject();
- return Local<Object>::New(Value::fromV4Value(QV4::Value::fromObject(o)));
+ return QV4::Value::fromObject(o);
}
Object *Object::Cast(Value *obj)
return a->arrayLength();
}
-
Local<Array> Array::New(int length)
+
Handle<Array> Array::New(int length)
{
if (length < 0)
length = 0;
if (length < 0x1000)
a->arrayReserve(length);
- return Local<Array>::New(Value::fromV4Value(QV4::Value::fromObject(a)));
+ return QV4::Value::fromObject(a);
}
Array *Array::Cast(Value *obj)
}
-Local<Object> Function::NewInstance() const
+Handle<Object> Function::NewInstance() const
{
QV4::FunctionObject *f = ConstValuePtr(this)->asFunctionObject();
assert(f);
} catch (QV4::Exception &e) {
Isolate::GetCurrent()->setException(e.value());
e.accept(context);
- return Local<Object>();
+ return Handle<Object>();
}
- return Local<Object>::New(Value::fromV4Value(result));
+ return result;
}
-Local<Object> Function::NewInstance(int argc, Handle<Value> argv[]) const
+Handle<Object> Function::NewInstance(int argc, Handle<Value> argv[]) const
{
QV4::FunctionObject *f = ConstValuePtr(this)->asFunctionObject();
assert(f);
} catch (QV4::Exception &e) {
Isolate::GetCurrent()->setException(e.value());
e.accept(context);
- return Local<Object>();
+ return Handle<Object>();
}
- return Local<Object>::New(Value::fromV4Value(result));
+ return result;
}
-Local<Value> Function::Call(Handle<Object> thisObj, int argc, Handle<Value> argv[])
+Handle<Value> Function::Call(Handle<Object> thisObj, int argc, Handle<Value> argv[])
{
QV4::FunctionObject *f = ConstValuePtr(this)->asFunctionObject();
if (!f)
- return Local<Value>();
+ return Handle<Value>();
QV4::ExecutionContext *context = currentEngine()->current;
QV4::Value result = QV4::Value::undefinedValue();
try {
} catch (QV4::Exception &e) {
Isolate::GetCurrent()->setException(e.value());
e.accept(context);
- return Local<Value>();
+ return Handle<Value>();
}
- return Local<Value>::New(Value::fromV4Value(result));
+ return result;
}
Handle<Value> Function::GetName() const
}
-Local<Value> Date::New(double time)
+Handle<Value> Date::New(double time)
{
QV4::Object *o = currentEngine()->newDateObject(QV4::Value::fromDouble(time));
- return Local<Value>::New(Value::fromV4Value(QV4::Value::fromObject(o)));
+ return QV4::Value::fromObject(o);
}
double Date::NumberValue() const
}
-Local<Value> NumberObject::New(double value)
+Handle<Value> NumberObject::New(double value)
{
QV4::Object *o = currentEngine()->newNumberObject(QV4::Value::fromDouble(value));
- return Local<Value>::New(Value::fromV4Value(QV4::Value::fromObject(o)));
+ return QV4::Value::fromObject(o);
}
double NumberObject::NumberValue() const
return static_cast<NumberObject *>(obj);
}
-Local<Value> BooleanObject::New(bool value)
+Handle<Value> BooleanObject::New(bool value)
{
QV4::Object *o = currentEngine()->newBooleanObject(QV4::Value::fromBoolean(value));
- return Local<Value>::New(Value::fromV4Value(QV4::Value::fromObject(o)));
+ return QV4::Value::fromObject(o);
}
bool BooleanObject::BooleanValue() const
return static_cast<BooleanObject *>(obj);
}
-Local<Value> StringObject::New(Handle<String> value)
+Handle<Value> StringObject::New(Handle<String> value)
{
QV4::Object *o = currentEngine()->newStringObject(QV4::Value::fromString(value->v4Value().asString()));
- return Local<Value>::New(Value::fromV4Value(QV4::Value::fromObject(o)));
+ return QV4::Value::fromObject(o);
}
-Local<String> StringObject::StringValue() const
+Handle<String> StringObject::StringValue() const
{
QV4::StringObject *s = ConstValuePtr(this)->asStringObject();
assert(s);
- return Local<String>::New(Value::fromV4Value(s->value));
+ return s->value;
}
StringObject *StringObject::Cast(Value *obj)
return static_cast<StringObject *>(obj);
}
-Local<RegExp> RegExp::New(Handle<String> pattern, RegExp::Flags flags)
+Handle<RegExp> RegExp::New(Handle<String> pattern, RegExp::Flags flags)
{
int f = 0;
if (flags & kGlobal)
if (flags & kMultiline)
f |= V4IR::RegExp::RegExp_Multiline;
QV4::Object *o = currentEngine()->newRegExpObject(pattern->asQString(), f);
- return Local<RegExp>::New(Value::fromV4Value(QV4::Value::fromObject(o)));
+ return QV4::Value::fromObject(o);
}
-Local<String> RegExp::GetSource() const
+Handle<String> RegExp::GetSource() const
{
RegExpObject *re = ConstValuePtr(this)->asRegExpObject();
assert(re);
- return Local<String>::New(Value::fromV4Value(QV4::Value::fromString(currentEngine()->current, re->value->pattern())));
+ return QV4::Value::fromString(currentEngine()->current, re->value->pattern());
}
RegExp::Flags RegExp::GetFlags() const
void *data;
};
-Local<Value> External::Wrap(void *data)
+Handle<Value> External::Wrap(void *data)
{
return New(data);
}
return obj.As<External>()->Value();
}
-Local<External> External::New(void *value)
+Handle<External> External::New(void *value)
{
QV4::Object *o = currentEngine()->newObject();
VoidStarWrapper *wrapper = new VoidStarWrapper;
wrapper->data = value;
o->externalResource = wrapper;
- return Local<v8::External>::New(v8::Value::fromV4Value(QV4::Value::fromObject(o)));
+ return QV4::Value::fromObject(o);
}
External *External::Cast(v8::Value *obj)
return m_args.size();
}
-Local<Value> Arguments::operator [](int i) const
+Handle<Value> Arguments::operator [](int i) const
{
- return Local<Value>::New(m_args.at(i));
+ return m_args.at(i);
}
-Local<Object> Arguments::This() const
+Handle<Object> Arguments::This() const
{
- return Local<Object>::New(m_thisObject);
+ return m_thisObject;
}
-Local<Object> Arguments::Holder() const
+Handle<Object> Arguments::Holder() const
{
// ### FIXME.
- return Local<Object>::New(m_thisObject);
+ return m_thisObject;
}
bool Arguments::IsConstructCall() const
return m_isConstructor;
}
-Local<Value> Arguments::Data() const
+Handle<Value> Arguments::Data() const
{
- return Local<Value>::New(m_data);
+ return m_data;
}
Isolate *Arguments::GetIsolate() const
return Isolate::GetCurrent();
}
-Local<Value> AccessorInfo::Data() const
+Handle<Value> AccessorInfo::Data() const
{
- return Local<Value>::New(m_data);
+ return m_data;
}
-Local<Object> AccessorInfo::This() const
+Handle<Object> AccessorInfo::This() const
{
- return Local<Object>::New(m_this);
+ return m_this;
}
-Local<Object> AccessorInfo::Holder() const
+Handle<Object> AccessorInfo::Holder() const
{
// ### FIXME
- return Local<Object>::New(m_this);
+ return m_this;
}
template <typename BaseClass>
static void put(QV4::Managed *m, ExecutionContext *ctx, QV4::String *name, const QV4::Value &value)
{
- Local<Value> v8Value = Local<Value>::New(Value::fromV4Value(value));
+ Handle<Value> v8Value = value;
V4V8Object *that = static_cast<V4V8Object*>(m);
if (that->m_template->m_namedPropertySetter) {
Handle<Value> result = that->m_template->m_namedPropertySetter(String::New(name), v8Value, that->namedAccessorInfo());
{
V4V8Object *that = static_cast<V4V8Object*>(m);
if (that->m_template->m_indexedPropertySetter) {
- Handle<Value> result = that->m_template->m_indexedPropertySetter(index, Local<Value>::New(Value::fromV4Value(value)), that->indexedAccessorInfo());
+ Handle<Value> result = that->m_template->m_indexedPropertySetter(index, value, that->indexedAccessorInfo());
if (!result.IsEmpty())
return;
}
FunctionTemplate::FunctionTemplate(InvocationCallback callback, Handle<Value> data)
: m_callback(callback)
{
- m_instanceTemplate = Local<ObjectTemplate>();
- m_prototypeTemplate = Local<ObjectTemplate>();
+ m_instanceTemplate = Handle<ObjectTemplate>();
+ m_prototypeTemplate = Handle<ObjectTemplate>();
m_data = Persistent<Value>::New(data);
}
-Local<FunctionTemplate> FunctionTemplate::New(InvocationCallback callback, Handle<Value> data)
+Handle<FunctionTemplate> FunctionTemplate::New(InvocationCallback callback, Handle<Value> data)
{
FunctionTemplate *ft = new FunctionTemplate(callback, data);
- return Local<FunctionTemplate>::New(Handle<FunctionTemplate>(ft));
+ return Handle<FunctionTemplate>(ft);
}
-Local<Function> FunctionTemplate::GetFunction()
+Handle<Function> FunctionTemplate::GetFunction()
{
QV4::ExecutionEngine *engine = currentEngine();
QV4::Object *o = new (engine->memoryManager) V4V8Function(engine, this);
QV4::Object *proto = new (engine->memoryManager) V4V8Object<QV4::FunctionPrototype>(engine, m_prototypeTemplate.get());
o->put(engine->current, engine->id_prototype, QV4::Value::fromObject(proto));
- return Local<Function>::New(Value::fromV4Value(QV4::Value::fromObject(o)));
+ return QV4::Value::fromObject(o);
}
-Local<ObjectTemplate> FunctionTemplate::InstanceTemplate()
+Handle<ObjectTemplate> FunctionTemplate::InstanceTemplate()
{
if (m_instanceTemplate.IsEmpty())
m_instanceTemplate = ObjectTemplate::New();
return m_instanceTemplate;
}
-Local<ObjectTemplate> FunctionTemplate::PrototypeTemplate()
+Handle<ObjectTemplate> FunctionTemplate::PrototypeTemplate()
{
if (m_prototypeTemplate.IsEmpty())
m_prototypeTemplate = ObjectTemplate::New();
}
-Local<ObjectTemplate> ObjectTemplate::New()
+Handle<ObjectTemplate> ObjectTemplate::New()
{
ObjectTemplate *ot = new ObjectTemplate;
- return Local<ObjectTemplate>::New(Handle<ObjectTemplate>(ot));
+ return Handle<ObjectTemplate>(ot);
}
-Local<Object> ObjectTemplate::NewInstance()
+Handle<Object> ObjectTemplate::NewInstance()
{
QV4::ExecutionEngine *engine = currentEngine();
QV4::Object *o = new (engine->memoryManager) V4V8Object<QV4::Object>(engine, this);
o->prototype = engine->objectPrototype;
o->externalComparison = m_useUserComparison;
- return Local<Object>::New(Value::fromV4Value(QV4::Value::fromObject(o)));
+ return QV4::Value::fromObject(o);
}
void ObjectTemplate::SetAccessor(Handle<String> name, AccessorGetter getter, AccessorSetter setter, Handle<Value> data, AccessControl settings, PropertyAttribute attribute)
}
-Local<Value> Exception::ReferenceError(Handle<String> message)
+Handle<Value> Exception::ReferenceError(Handle<String> message)
{
Q_UNUSED(message);
QV4::Object *o = currentEngine()->newReferenceErrorObject(message->ToString()->asQString());
- return Local<Value>::New(Value::fromV4Value(QV4::Value::fromObject(o)));
+ return QV4::Value::fromObject(o);
}
-Local<Value> Exception::SyntaxError(Handle<String> message)
+Handle<Value> Exception::SyntaxError(Handle<String> message)
{
Q_UNUSED(message);
QV4::Object *o = currentEngine()->newSyntaxErrorObject(currentEngine()->current, 0);
- return Local<Value>::New(Value::fromV4Value(QV4::Value::fromObject(o)));
+ return QV4::Value::fromObject(o);
}
-Local<Value> Exception::TypeError(Handle<String> message)
+Handle<Value> Exception::TypeError(Handle<String> message)
{
Q_UNUSED(message);
QV4::Object *o = currentEngine()->newTypeErrorObject(message->ToString()->asQString());
- return Local<Value>::New(Value::fromV4Value(QV4::Value::fromObject(o)));
+ return QV4::Value::fromObject(o);
}
-Local<Value> Exception::Error(Handle<String> message)
+Handle<Value> Exception::Error(Handle<String> message)
{
Q_UNUSED(message);
QV4::Object *o = currentEngine()->newErrorObject(QV4::Value::fromString(currentEngine()->current, message->ToString()->asQString()));
- return Local<Value>::New(Value::fromV4Value(QV4::Value::fromObject(o)));
+ return QV4::Value::fromObject(o);
}
{
if (tryCatch) {
tryCatch->hasCaughtException = true;
- tryCatch->exception = Local<Value>::New(Value::fromV4Value(ex));
+ tryCatch->exception = ex;
}
}
{
if (!userObjectComparisonCallback)
return false;
- Local<Object> la = Local<Object>::New(Value::fromV4Value(a));
- Local<Object> lb = Local<Object>::New(Value::fromV4Value(b));
+ Handle<Object> la = a;
+ Handle<Object> lb = b;
return userObjectComparisonCallback(la, lb);
}
Q_UNREACHABLE();
}
-Local<Value> TryCatch::Exception() const
+Handle<Value> TryCatch::Exception() const
{
return exception;
}
-Local<Message> TryCatch::Message() const
+Handle<Message> TryCatch::Message() const
{
Q_UNIMPLEMENTED();
- return Local<v8::Message>::New(Handle<v8::Message>(new v8::Message(QString(), QString(), 0)));
+ return Handle<v8::Message>(new v8::Message(QString(), QString(), 0));
}
void TryCatch::Reset()
}
-Local<Value> Context::GetCallingScriptData()
+Handle<Value> Context::GetCallingScriptData()
{
Q_UNIMPLEMENTED();
Q_UNREACHABLE();
class Signature;
class AccessorSignature;
template <class T> struct Handle;
-template <class T> class Local;
+template <class T> class Handle;
template <class T> class Persistent;
class FunctionTemplate;
class ObjectTemplate;
/**
- * A light-weight stack-allocated object handle. All operations
- * that return objects from within v8 return them in local handles. They
- * are created within HandleScopes, and all local handles allocated within a
- * handle scope are destroyed when the handle scope is destroyed. Hence it
- * is not necessary to explicitly deallocate local handles.
- */
-template <class T> class Local : public Handle<T> {
- public:
- Local() {}
- template <class S> Local(Local<S> that)
- : Handle<T>(Handle<T>::Cast(that)) {
- /**
- * This check fails when trying to convert between incompatible
- * handles. For example, converting from a Handle<String> to a
- * Handle<Number>.
- */
- TYPE_CHECK(T, S);
- }
- template <class S> Local(S* that) : Handle<T>(that) { }
- template <class S> static Local<T> Cast(Local<S> that) {
-#ifdef V8_ENABLE_CHECKS
- // If we're going to perform the type check then we have to check
- // that the handle isn't empty before doing the checked cast.
- if (that.IsEmpty()) return Local<T>();
-#endif
- return Local<T>::New(Handle<T>::Cast(that));
- }
-
- template <class S> Local<S> As() {
- return Local<S>::Cast(*this);
- }
-
- /** Create a local handle for the content of another handle.
- * The referee is kept alive by the local handle even when
- * the original handle is destroyed/disposed.
- */
- static Local<T> New(Handle<T> that)
- {
- Local<T> result;
- result.Handle<T>::operator =(that);
- return result;
- }
-};
-
-
-/**
* An object reference that is independent of any handle scope. Where
* a Local handle only lives as long as the HandleScope in which it was
* allocated, a Persistent handle remains valid until it is explicitly
* \return Compiled script object (context independent; when run it
* will use the currently entered context).
*/
- static Local<Script> New(Handle<String> source,
+ static Handle<Script> New(Handle<String> source,
ScriptOrigin* origin = NULL,
ScriptData* pre_data = NULL,
Handle<String> script_data = Handle<String>(),
* \return Compiled script object (context independent; when run it
* will use the currently entered context).
*/
- static Local<Script> New(Handle<String> source,
+ static Handle<Script> New(Handle<String> source,
Handle<Value> file_name,
CompileFlags = Default);
* when this function was called. When run it will always use this
* context.
*/
- static Local<Script> Compile(Handle<String> source,
+ static Handle<Script> Compile(Handle<String> source,
ScriptOrigin* origin = NULL,
ScriptData* pre_data = NULL,
Handle<String> script_data = Handle<String>(),
* when this function was called. When run it will always use this
* context.
*/
- static Local<Script> Compile(Handle<String> source,
+ static Handle<Script> Compile(Handle<String> source,
Handle<Value> file_name,
Handle<String> script_data = Handle<String>(),
CompileFlags = Default);
* using ::Compile) it will be run in the context in which it was
* compiled.
*/
- Local<Value> Run();
- Local<Value> Run(Handle<Object> qml);
+ Handle<Value> Run();
+ Handle<Value> Run(Handle<Object> qml);
/**
* Returns the script id value.
*/
- Local<Value> Id();
+ Handle<Value> Id();
/**
* Associate an additional data object with the script. This is mainly used
Message(const QString &message, const QString &resourceName, int lineNumber)
: m_message(message), m_resourceName(resourceName), m_lineNumber(lineNumber) {}
- Local<String> Get() const;
+ Handle<String> Get() const;
/**
* Returns the resource name for the script from where the function causing
* the error originates.
/**
* Returns a StackFrame at a particular index.
*/
- Local<StackFrame> GetFrame(uint32_t index) const;
+ Handle<StackFrame> GetFrame(uint32_t index) const;
/**
* Returns the number of StackFrames.
/**
* Returns StackTrace as a v8::Array that contains StackFrame objects.
*/
-
Local<Array> AsArray();
+
Handle<Array> AsArray();
/**
* Grab a snapshot of the current JavaScript execution stack.
* \param options Enumerates the set of things we will capture for each
* StackFrame.
*/
- static Local<StackTrace> CurrentStackTrace(
+ static Handle<StackTrace> CurrentStackTrace(
int frame_limit,
StackTraceOptions options = kOverview);
private:
- QVector<Local<StackFrame> > frames;
+ QVector<Handle<StackFrame> > frames;
};
DEFINE_REFCOUNTED_HANDLE_OPERATIONS(StackTrace)
* Returns the name of the resource that contains the script for the
* function for this StackFrame.
*/
- Local<String> GetScriptName() const;
+ Handle<String> GetScriptName() const;
/**
* Returns the name of the resource that contains the script for the
* function for this StackFrame or sourceURL value if the script name
* is undefined and its source ends with //@ sourceURL=... string.
*/
- Local<String> GetScriptNameOrSourceURL() const;
+ Handle<String> GetScriptNameOrSourceURL() const;
/**
* Returns the name of the function associated with this stack frame.
*/
- Local<String> GetFunctionName() const;
+ Handle<String> GetFunctionName() const;
private:
friend class StackTrace;
*/
bool IsError() const;
- Local<Boolean> ToBoolean() const;
- Local<Number> ToNumber() const;
- Local<String> ToString() const;
- Local<Object> ToObject() const;
- Local<Integer> ToInteger() const;
- Local<Uint32> ToUint32() const;
- Local<Int32> ToInt32() const;
+ Handle<Boolean> ToBoolean() const;
+ Handle<Number> ToNumber() const;
+ Handle<String> ToString() const;
+ Handle<Object> ToObject() const;
+ Handle<Integer> ToInteger() const;
+ Handle<Uint32> ToUint32() const;
+ Handle<Int32> ToInt32() const;
/**
* Attempts to convert a string to an array index.
* Returns an empty handle if the conversion fails.
*/
- Local<Uint32> ToArrayIndex() const;
+ Handle<Uint32> ToArrayIndex() const;
bool BooleanValue() const;
double NumberValue() const;
* 'strlen' to determine the buffer length, it might be
* wrong if 'data' contains a null character.
*/
- static Local<String> New(const char* data, int length = -1);
+ static Handle<String> New(const char* data, int length = -1);
/** Allocates a new string from 16-bit character codes.*/
- static Local<String> New(const uint16_t* data, int length = -1);
+ static Handle<String> New(const uint16_t* data, int length = -1);
/** Creates a symbol. Returns one if it exists already.*/
- static Local<String> NewSymbol(const char* data, int length = -1);
+ static Handle<String> NewSymbol(const char* data, int length = -1);
- static Local<String> New(QV4::String *s);
+ static Handle<String> New(QV4::String *s);
/**
* Creates a new external string using the data defined in the given
* should the underlying buffer be deallocated or modified except through the
* destructor of the external string resource.
*/
- static Local<String> NewExternal(ExternalStringResource* resource);
+ static Handle<String> NewExternal(ExternalStringResource* resource);
/**
* Converts an object to an ASCII string.
class V8EXPORT Number : public Primitive {
public:
double Value() const;
- static Local<Number> New(double value);
+ static Handle<Number> New(double value);
static Number* Cast(v8::Value* obj);
};
*/
class V8EXPORT Integer : public Number {
public:
- static Local<Integer> New(int32_t value);
- static Local<Integer> NewFromUnsigned(uint32_t value);
+ static Handle<Integer> New(int32_t value);
+ static Handle<Integer> NewFromUnsigned(uint32_t value);
int64_t Value() const;
static Integer* Cast(v8::Value* obj);
};
* setting|getting a particular property. See Object and ObjectTemplate's
* method SetAccessor.
*/
-typedef Handle<Value> (*AccessorGetter)(Local<String> property,
+typedef Handle<Value> (*AccessorGetter)(Handle<String> property,
const AccessorInfo& info);
-typedef void (*AccessorSetter)(Local<String> property,
- Local<Value> value,
+typedef void (*AccessorSetter)(Handle<String> property,
+ Handle<Value> value,
const AccessorInfo& info);
bool Set(uint32_t index,
Handle<Value> value);
- Local<Value> Get(Handle<Value> key);
+ Handle<Value> Get(Handle<Value> key);
- Local<Value> Get(uint32_t index);
+ Handle<Value> Get(uint32_t index);
// TODO(1245389): Replace the type-specific versions of these
// functions with generic ones that accept a Handle<Value> key.
* array returned by this method contains the same values as would
* be enumerated by a for-in statement over this object.
*/
-
Local<Array> GetPropertyNames();
+
Handle<Array> GetPropertyNames();
/**
* This function has the same functionality as GetPropertyNames but
* the returned array doesn't contain the names of properties from
* prototype objects.
*/
-
Local<Array> GetOwnPropertyNames();
+
Handle<Array> GetOwnPropertyNames();
/**
* Get the prototype object. This does not skip objects marked to
* be skipped by __proto__ and it does not consult the security
* handler.
*/
- Local<Value> GetPrototype();
+ Handle<Value> GetPrototype();
/**
* Set the prototype object. This does not skip objects marked to
bool SetPrototype(Handle<Value> prototype);
/** Gets the value in an internal field. */
- Local<Value> GetInternalField(int index);
+ Handle<Value> GetInternalField(int index);
/** Sets the value in an internal field. */
void SetInternalField(int index, Handle<Value> value);
* identity hash) are prefixed with "v8::".
*/
bool SetHiddenValue(Handle<String> key, Handle<Value> value);
- Local<Value> GetHiddenValue(Handle<String> key);
+ Handle<Value> GetHiddenValue(Handle<String> key);
/**
* Clone this object with a fast but shallow copy. Values will point
* to the same values as the original object.
*/
- Local<Object> Clone();
+ Handle<Object> Clone();
/**
* Call an Object as a function if a callback is set by the
* ObjectTemplate::SetCallAsFunctionHandler method.
*/
- Local<Value> CallAsFunction(Handle<Object> recv,
+ Handle<Value> CallAsFunction(Handle<Object> recv,
int argc,
Handle<Value> argv[]);
* ObjectTemplate::SetCallAsFunctionHandler method.
* Note: This method behaves like the Function::NewInstance method.
*/
- Local<Value> CallAsConstructor(int argc,
+ Handle<Value> CallAsConstructor(int argc,
Handle<Value> argv[]);
- static Local<Object> New();
+ static Handle<Object> New();
static Object* Cast(Value* obj);
};
* Creates a JavaScript array with the given length. If the length
* is negative the returned array will have length 0.
*/
- static
Local<Array> New(int length = 0);
+ static
Handle<Array> New(int length = 0);
static Array* Cast(Value* obj);
};
*/
class V8EXPORT Function : public Object {
public:
- Local<Object> NewInstance() const;
- Local<Object> NewInstance(int argc, Handle<Value> argv[]) const;
- Local<Value> Call(Handle<Object> recv,
+ Handle<Object> NewInstance() const;
+ Handle<Object> NewInstance(int argc, Handle<Value> argv[]) const;
+ Handle<Value> Call(Handle<Object> recv,
int argc,
Handle<Value> argv[]);
Handle<Value> GetName() const;
*/
class V8EXPORT Date : public Object {
public:
- static Local<Value> New(double time);
+ static Handle<Value> New(double time);
/**
* A specialization of Value::NumberValue that is more efficient
*/
class V8EXPORT NumberObject : public Object {
public:
- static Local<Value> New(double value);
+ static Handle<Value> New(double value);
/**
* Returns the Number held by the object.
*/
class V8EXPORT BooleanObject : public Object {
public:
- static Local<Value> New(bool value);
+ static Handle<Value> New(bool value);
/**
* Returns the Boolean held by the object.
*/
class V8EXPORT StringObject : public Object {
public:
- static Local<Value> New(Handle<String> value);
+ static Handle<Value> New(Handle<String> value);
/**
* Returns the String held by the object.
*/
- Local<String> StringValue() const;
+ Handle<String> StringValue() const;
static StringObject* Cast(v8::Value* obj);
* static_cast<RegExp::Flags>(kGlobal | kMultiline))
* is equivalent to evaluating "/foo/gm".
*/
- static Local<RegExp> New(Handle<String> pattern,
+ static Handle<RegExp> New(Handle<String> pattern,
Flags flags);
/**
* Returns the value of the source property: a string representing
* the regular expression.
*/
- Local<String> GetSource() const;
+ Handle<String> GetSource() const;
/**
* Returns the flags bit field.
*/
class V8EXPORT External : public Value {
public:
- static Local<Value> Wrap(void* data);
+ static Handle<Value> Wrap(void* data);
static void* Unwrap(Handle<Value> obj);
- static Local<External> New(void* value);
+ static Handle<External> New(void* value);
static External* Cast(Value* obj);
void* Value() const;
};
Arguments(const QV4::Value *args, int argc, const QV4::Value &thisObject, bool isConstructor,
const Persistent<Value> &data);
int Length() const;
- Local<Value> operator[](int i) const;
- Local<Object> This() const;
- Local<Object> Holder() const;
+ Handle<Value> operator[](int i) const;
+ Handle<Object> This() const;
+ Handle<Object> Holder() const;
bool IsConstructCall() const;
- Local<Value> Data() const;
+ Handle<Value> Data() const;
Isolate* GetIsolate() const;
private:
public:
AccessorInfo(const QV4::Value &thisObject, const Persistent<Value> &data);
Isolate* GetIsolate() const;
- Local<Value> Data() const;
- Local<Object> This() const;
- Local<Object> Holder() const;
+ Handle<Value> Data() const;
+ Handle<Object> This() const;
+ Handle<Object> Holder() const;
private:
Persistent<Value> m_this;
Persistent<Value> m_data;
* NamedProperty[Getter|Setter] are used as interceptors on object.
* See ObjectTemplate::SetNamedPropertyHandler.
*/
-typedef Handle<Value> (*NamedPropertyGetter)(Local<String> property,
+typedef Handle<Value> (*NamedPropertyGetter)(Handle<String> property,
const AccessorInfo& info);
* Returns the value if the setter intercepts the request.
* Otherwise, returns an empty handle.
*/
-typedef Handle<Value> (*NamedPropertySetter)(Local<String> property,
- Local<Value> value,
+typedef Handle<Value> (*NamedPropertySetter)(Handle<String> property,
+ Handle<Value> value,
const AccessorInfo& info);
/**
* The result is an integer encoding property attributes (like v8::None,
* v8::DontEnum, etc.)
*/
-typedef Handle<Integer> (*NamedPropertyQuery)(Local<String> property,
+typedef Handle<Integer> (*NamedPropertyQuery)(Handle<String> property,
const AccessorInfo& info);
* The return value is true if the property could be deleted and false
* otherwise.
*/
-typedef Handle<Boolean> (*NamedPropertyDeleter)(Local<String> property,
+typedef Handle<Boolean> (*NamedPropertyDeleter)(Handle<String> property,
const AccessorInfo& info);
/**
* Otherwise, returns an empty handle.
*/
typedef Handle<Value> (*IndexedPropertySetter)(uint32_t index,
- Local<Value> value,
+ Handle<Value> value,
const AccessorInfo& info);
class V8EXPORT FunctionTemplate : public Template {
public:
/** Creates a function template.*/
- static Local<FunctionTemplate> New(
+ static Handle<FunctionTemplate> New(
InvocationCallback callback = 0,
Handle<Value> data = Handle<Value>());
/** Returns the unique function instance in the current execution context.*/
- Local<Function> GetFunction();
+ Handle<Function> GetFunction();
/** Get the InstanceTemplate. */
- Local<ObjectTemplate> InstanceTemplate();
+ Handle<ObjectTemplate> InstanceTemplate();
/**
* A PrototypeTemplate is the template used to create the prototype object
* of the function created by this template.
*/
- Local<ObjectTemplate> PrototypeTemplate();
+ Handle<ObjectTemplate> PrototypeTemplate();
private:
FunctionTemplate(InvocationCallback callback, Handle<Value> data);
friend class V4V8Function;
InvocationCallback m_callback;
Persistent<Value> m_data;
- Local<ObjectTemplate> m_instanceTemplate;
- Local<ObjectTemplate> m_prototypeTemplate;
+ Handle<ObjectTemplate> m_instanceTemplate;
+ Handle<ObjectTemplate> m_prototypeTemplate;
};
DEFINE_REFCOUNTED_HANDLE_OPERATIONS(FunctionTemplate)
class V8EXPORT ObjectTemplate : public Template {
public:
/** Creates an ObjectTemplate. */
- static Local<ObjectTemplate> New();
+ static Handle<ObjectTemplate> New();
/** Creates a new instance of this template.*/
- Local<Object> NewInstance();
+ Handle<Object> NewInstance();
/**
* Sets an accessor on the object template.
*/
class V8EXPORT Exception {
public:
- static Local<Value> ReferenceError(Handle<String> message);
- static Local<Value> SyntaxError(Handle<String> message);
- static Local<Value> TypeError(Handle<String> message);
- static Local<Value> Error(Handle<String> message);
+ static Handle<Value> ReferenceError(Handle<String> message);
+ static Handle<Value> SyntaxError(Handle<String> message);
+ static Handle<Value> TypeError(Handle<String> message);
+ static Handle<Value> Error(Handle<String> message);
};
// --- User Object Comparison Callback ---
-typedef bool (*UserObjectComparisonCallback)(Local<Object> lhs,
- Local<Object> rhs);
+typedef bool (*UserObjectComparisonCallback)(Handle<Object> lhs,
+ Handle<Object> rhs);
// --- Garbage Collection Callbacks ---
*
* The returned handle is valid until this TryCatch block has been destroyed.
*/
- Local<Value> Exception() const;
+ Handle<Value> Exception() const;
/**
* Returns the message associated with this exception. If there is
* The returned handle is valid until this TryCatch block has been
* destroyed.
*/
- Local<v8::Message> Message() const;
+ Handle<v8::Message> Message() const;
/**
* Clears any exceptions that may have been caught by this try/catch block.
friend class Isolate;
TryCatch *parent;
bool hasCaughtException;
- Local<Value> exception;
+ Handle<Value> exception;
};
* context of the top-most JavaScript frame. If there are no
* JavaScript frames an empty handle is returned.
*/
- static Local<Value> GetCallingScriptData();
+ static Handle<Value> GetCallingScriptData();
private:
Context() {}
};
static void jsContext(v8::Handle<v8::Value> *file, int *line, v8::Handle<v8::Value> *function) {
- v8::Local<v8::StackTrace> stackTrace = v8::StackTrace::CurrentStackTrace(1);
+ v8::Handle<v8::StackTrace> stackTrace = v8::StackTrace::CurrentStackTrace(1);
if (stackTrace->GetFrameCount()) {
- v8::Local<v8::StackFrame> frame = stackTrace->GetFrame(0);
+ v8::Handle<v8::StackFrame> frame = stackTrace->GetFrame(0);
*file = frame->GetScriptName();
*line = frame->GetLineNumber();
*function = frame->GetFunctionName();
int stackCount = stackTrace->GetFrameCount();
for (int i = 0; i < stackCount; i++) {
- v8::Local<v8::StackFrame> frame = stackTrace->GetFrame(i);
+ v8::Handle<v8::StackFrame> frame = stackTrace->GetFrame(i);
v8::Handle<v8::String> function(frame->GetFunctionName());
v8::Handle<v8::String> script(frame->GetScriptName());
int lineNumber = frame->GetLineNumber();
if (i != 0)
result.append(QLatin1Char(' '));
- v8::Local<v8::Value> value = args[i];
+ v8::Handle<v8::Value> value = args[i];
v8::TryCatch tryCatch;
- v8::Local<v8::String> toString = value->ToString();
+ v8::Handle<v8::String> toString = value->ToString();
if (tryCatch.HasCaught()) {
// toString() threw Exception
// Is it possible for value to be anything other than Object?
v8::StackTrace::CurrentStackTrace(1, v8::StackTrace::kOverview);
if (stackTrace->GetFrameCount()) {
- v8::Local<v8::StackFrame> frame = stackTrace->GetFrame(0);
+ v8::Handle<v8::StackFrame> frame = stackTrace->GetFrame(0);
QString scriptName = frame->GetScriptName()->v4Value().toQString();
QString functionName = frame->GetFunctionName()->v4Value().toQString();
if (i != 1)
message.append(QLatin1Char(' '));
- v8::Local<v8::Value> value = args[i];
+ v8::Handle<v8::Value> value = args[i];
message.append(value->v4Value().toQString());
}
V8THROW_ERROR("Qt.createQmlObject(): Invalid arguments");
struct Error {
- static v8::Local<v8::Value> create(QV8Engine *engine, const QList<QQmlError> &errors) {
+ static v8::Handle<v8::Value> create(QV8Engine *engine, const QList<QQmlError> &errors) {
QString errorstr = QLatin1String("Qt.createQmlObject(): failed to create object: ");
- v8::Local<v8::Array> qmlerrors = v8::Array::New(errors.count());
+ v8::Handle<v8::Array> qmlerrors = v8::Array::New(errors.count());
for (int ii = 0; ii < errors.count(); ++ii) {
const QQmlError &error = errors.at(ii);
errorstr += QLatin1String("\n ") + error.toString();
- v8::Local<v8::Object> qmlerror = v8::Object::New();
+ v8::Handle<v8::Object> qmlerror = v8::Object::New();
qmlerror->Set(v8::String::New("lineNumber"), v8::Integer::New(error.line()));
qmlerror->Set(v8::String::New("columnNumber"), v8::Integer::New(error.column()));
qmlerror->Set(v8::String::New("fileName"), engine->toString(error.url().toString()));
qmlerrors->Set(ii, qmlerror);
}
- v8::Local<v8::Value> error = v8::Exception::Error(engine->toString(errorstr));
- v8::Local<v8::Object> errorObject = error->ToObject();
+ v8::Handle<v8::Value> error = v8::Exception::Error(engine->toString(errorstr));
+ v8::Handle<v8::Object> errorObject = error->ToObject();
errorObject->Set(v8::String::New("qmlErrors"), qmlerrors);
return error;
}
int consumedCount = 1;
if (args.Length() > 1) {
- const v8::Local<v8::Value> &lastArg = args[args.Length()-1];
+ const v8::Handle<v8::Value> &lastArg = args[args.Length()-1];
// The second argument could be the mode enum
if (args[1]->IsInt32()) {
#define DOMEXCEPTION_TYPE_MISMATCH_ERR 17
#define V8THROW_DOM(error, string) { \
- v8::Local<v8::Value> v = v8::Exception::Error(v8::String::New(string)); \
+ v8::Handle<v8::Value> v = v8::Exception::Error(v8::String::New(string)); \
v->ToObject()->Set(v8::String::New("code"), v8::Integer::New(error)); \
v8::ThrowException(v); \
return v8::Handle<v8::Value>(); \
ep->referenceScarceResources();
QV4::ArrayObject *f = parent->functions();
- v8::Local<v8::Value> result = f ?
+ v8::Handle<v8::Value> result = f ?
evaluate(context,
f->getIndexed(f->internalClass->engine->current, instruction->value),
&isUndefined)
- : v8::Local<v8::Value>::New(QV4::Value::undefinedValue());
+ : v8::Handle<v8::Value>(QV4::Value::undefinedValue());
trace.event("writing V8 result");
bool needsErrorLocationData = false;
QV8Engine *engine = QQmlEnginePrivate::getV8Engine(context->engine);
if (program->bindings->isDeleted()) {
- v8::Local<v8::Script> script;
+ v8::Handle<v8::Script> script;
bool compileFailed = false;
{
v8::TryCatch try_catch;
compileFailed = true;
QQmlError error;
error.setDescription(QString(QLatin1String("Exception occurred during compilation of binding at line: %1")).arg(line));
- v8::Local<v8::Message> message = try_catch.Message();
+ v8::Handle<v8::Message> message = try_catch.Message();
if (!message.IsEmpty())
QQmlExpressionPrivate::exceptionToError(message, error);
QQmlEnginePrivate::get(engine->engine())->warning(error);
}
if (!compileFailed) {
- v8::Local<v8::Value> result = script->Run(engine->contextWrapper()->sharedContext());
+ v8::Handle<v8::Value> result = script->Run(engine->contextWrapper()->sharedContext());
if (result->IsArray()) {
program->bindings = result->v4Value();
program->program.clear(); // We don't need the source anymore
if (!hasSubContexts)
return context;
- v8::Local<v8::Value> callingdata = v8::Context::GetCallingScriptData();
+ v8::Handle<v8::Value> callingdata = v8::Context::GetCallingScriptData();
if (callingdata.IsEmpty() || !callingdata->IsString())
return context;
- v8::Local<v8::String> callingstring = callingdata->ToString();
+ v8::Handle<v8::String> callingstring = callingdata->ToString();
Q_ASSERT(callingstring->IsExternal());
Q_ASSERT(callingstring->GetExternalStringResource());
{
m_engine = engine;
{
- v8::Local<v8::FunctionTemplate> ft = v8::FunctionTemplate::New();
+ v8::Handle<v8::FunctionTemplate> ft = v8::FunctionTemplate::New();
ft->InstanceTemplate()->SetHasExternalResource(true);
ft->InstanceTemplate()->SetFallbackPropertyHandler(Getter, Setter);
m_constructor = qPersistentNew<v8::Function>(ft->GetFunction());
}
{
- v8::Local<v8::FunctionTemplate> ft = v8::FunctionTemplate::New();
+ v8::Handle<v8::FunctionTemplate> ft = v8::FunctionTemplate::New();
ft->InstanceTemplate()->SetHasExternalResource(true);
ft->InstanceTemplate()->SetFallbackPropertyHandler(NullGetter, NullSetter);
m_urlConstructor = qPersistentNew<v8::Function>(ft->GetFunction());
}
{
- v8::Local<v8::Object> sharedContext = m_constructor->NewInstance();
+ v8::Handle<v8::Object> sharedContext = m_constructor->NewInstance();
QV8ContextResource *r = new QV8ContextResource(engine, 0, 0);
r->isSharedContext = true;
sharedContext->SetExternalResource(r);
}
}
-v8::Local<v8::Object> QV8ContextWrapper::qmlScope(QQmlContextData *ctxt, QObject *scope)
+v8::Handle<v8::Object> QV8ContextWrapper::qmlScope(QQmlContextData *ctxt, QObject *scope)
{
// XXX NewInstance() should be optimized
- v8::Local<v8::Object> rv = m_constructor->NewInstance();
+ v8::Handle<v8::Object> rv = m_constructor->NewInstance();
QV8ContextResource *r = new QV8ContextResource(m_engine, ctxt, scope);
rv->SetExternalResource(r);
return rv;
}
-v8::Local<v8::Object> QV8ContextWrapper::urlScope(const QUrl &url)
+v8::Handle<v8::Object> QV8ContextWrapper::urlScope(const QUrl &url)
{
QQmlContextData *context = new QQmlContextData;
context->url = url;
context->isJSContext = true;
// XXX NewInstance() should be optimized
- v8::Local<v8::Object> rv = m_urlConstructor->NewInstance();
+ v8::Handle<v8::Object> rv = m_urlConstructor->NewInstance();
QV8ContextResource *r = new QV8ContextResource(m_engine, context, 0, true);
rv->SetExternalResource(r);
return rv;
r->ownsContext = true;
}
-v8::Handle<v8::Value> QV8ContextWrapper::NullGetter(v8::Local<v8::String>,
+v8::Handle<v8::Value> QV8ContextWrapper::NullGetter(v8::Handle<v8::String>,
const v8::AccessorInfo &)
{
// V8 will throw a ReferenceError if appropriate ("typeof" should not throw)
return v8::Handle<v8::Value>();
}
-v8::Handle<v8::Value> QV8ContextWrapper::Getter(v8::Local<v8::String> property,
+v8::Handle<v8::Value> QV8ContextWrapper::Getter(v8::Handle<v8::String> property,
const v8::AccessorInfo &info)
{
QV8ContextResource *resource = v8_resource_check<QV8ContextResource>(info.This());
return v8::Handle<v8::Value>();
}
-v8::Handle<v8::Value> QV8ContextWrapper::NullSetter(v8::Local<v8::String> property,
- v8::Local<v8::Value>,
+v8::Handle<v8::Value> QV8ContextWrapper::NullSetter(v8::Handle<v8::String> property,
+ v8::Handle<v8::Value>,
const v8::AccessorInfo &info)
{
QV8ContextResource *resource = v8_resource_check<QV8ContextResource>(info.This());
}
}
-v8::Handle<v8::Value> QV8ContextWrapper::Setter(v8::Local<v8::String> property,
- v8::Local<v8::Value> value,
+v8::Handle<v8::Value> QV8ContextWrapper::Setter(v8::Handle<v8::String> property,
+ v8::Handle<v8::Value> value,
const v8::AccessorInfo &info)
{
QV8ContextResource *resource = v8_resource_check<QV8ContextResource>(info.This());
void init(QV8Engine *);
void destroy();
- v8::Local<v8::Object> qmlScope(QQmlContextData *ctxt, QObject *scope);
- v8::Local<v8::Object> urlScope(const QUrl &);
+ v8::Handle<v8::Object> qmlScope(QQmlContextData *ctxt, QObject *scope);
+ v8::Handle<v8::Object> urlScope(const QUrl &);
void setReadOnly(v8::Handle<v8::Object>, bool);
void takeContextOwnership(v8::Handle<v8::Object> qmlglobal);
private:
- static v8::Handle<v8::Value> NullGetter(v8::Local<v8::String> property,
+ static v8::Handle<v8::Value> NullGetter(v8::Handle<v8::String> property,
const v8::AccessorInfo &info);
- static v8::Handle<v8::Value> NullSetter(v8::Local<v8::String> property,
- v8::Local<v8::Value> value,
+ static v8::Handle<v8::Value> NullSetter(v8::Handle<v8::String> property,
+ v8::Handle<v8::Value> value,
const v8::AccessorInfo &info);
- static v8::Handle<v8::Value> Getter(v8::Local<v8::String> property,
+ static v8::Handle<v8::Value> Getter(v8::Handle<v8::String> property,
const v8::AccessorInfo &info);
- static v8::Handle<v8::Value> Setter(v8::Local<v8::String> property,
- v8::Local<v8::Value> value,
+ static v8::Handle<v8::Value> Setter(v8::Handle<v8::String> property,
+ v8::Handle<v8::Value> value,
const v8::AccessorInfo &info);
QV8Engine *m_engine;
// QQmlEngine is not available
QT_BEGIN_NAMESPACE
-static bool ObjectComparisonCallback(v8::Local<v8::Object> lhs, v8::Local<v8::Object> rhs)
+static bool ObjectComparisonCallback(v8::Handle<v8::Object> lhs, v8::Handle<v8::Object> rhs)
{
if (lhs == rhs)
return true;
}
// A handle scope and context must be entered
-v8::Local<v8::Script> QV8Engine::qmlModeCompile(const QString &source,
+v8::Handle<v8::Script> QV8Engine::qmlModeCompile(const QString &source,
const QString &fileName,
quint16 lineNumber)
{
v8::ScriptOrigin origin(v8fileName, v8::Integer::New(lineNumber - 1));
- v8::Local<v8::Script> script = v8::Script::Compile(v8source, &origin, 0, v8::Handle<v8::String>(),
+ v8::Handle<v8::Script> script = v8::Script::Compile(v8source, &origin, 0, v8::Handle<v8::String>(),
v8::Script::QmlMode);
return script;
// A handle scope and context must be entered.
// source can be either ascii or utf8.
-v8::Local<v8::Script> QV8Engine::qmlModeCompile(const char *source, int sourceLength,
+v8::Handle<v8::Script> QV8Engine::qmlModeCompile(const char *source, int sourceLength,
const QString &fileName,
quint16 lineNumber)
{
v8::ScriptOrigin origin(v8fileName, v8::Integer::New(lineNumber - 1));
- v8::Local<v8::Script> script = v8::Script::Compile(v8source, &origin, 0, v8::Handle<v8::String>(),
+ v8::Handle<v8::Script> script = v8::Script::Compile(v8source, &origin, 0, v8::Handle<v8::String>(),
v8::Script::QmlMode);
return script;
{
using namespace QQmlBuiltinFunctions;
- v8::Local<v8::Object> console = v8::Object::New();
- v8::Local<v8::Function> consoleLogFn = V8FUNCTION(consoleLog, this);
+ v8::Handle<v8::Object> console = v8::Object::New();
+ v8::Handle<v8::Function> consoleLogFn = V8FUNCTION(consoleLog, this);
console->Set(v8::String::New("debug"), consoleLogFn);
console->Set(v8::String::New("log"), consoleLogFn);
console->Set(v8::String::New("trace"), V8FUNCTION(consoleTrace, this));
console->Set(v8::String::New("exception"), V8FUNCTION(consoleException, this));
- v8::Local<v8::Object> qt = v8::Object::New();
+ v8::Handle<v8::Object> qt = v8::Object::New();
// Set all the enums from the "Qt" namespace
const QMetaObject *qtMetaObject = StaticQtMetaObject::get();
" })"\
"})"
- v8::Local<v8::Script> registerArg = v8::Script::New(v8::String::New(STRING_ARG), 0, 0, v8::Handle<v8::String>(), v8::Script::NativeMode);
- v8::Local<v8::Value> result = registerArg->Run();
+ v8::Handle<v8::Script> registerArg = v8::Script::New(v8::String::New(STRING_ARG), 0, 0, v8::Handle<v8::String>(), v8::Script::NativeMode);
+ v8::Handle<v8::Value> result = registerArg->Run();
Q_ASSERT(result->IsFunction());
- v8::Local<v8::Function> registerArgFunc = v8::Local<v8::Function>::Cast(result);
+ v8::Handle<v8::Function> registerArgFunc = v8::Handle<v8::Function>::Cast(result);
v8::Handle<v8::Value> args = V8FUNCTION(stringArg, this);
- registerArgFunc->Call(v8::Local<v8::Object>::Cast(registerArgFunc), 1, &args);
+ registerArgFunc->Call(v8::Handle<v8::Object>::Cast(registerArgFunc), 1, &args);
#undef STRING_ARG
}
return number;
}
-v8::Handle<v8::Value> QV8Engine::getPlatform(v8::Local<v8::String>, const v8::AccessorInfo &info)
+v8::Handle<v8::Value> QV8Engine::getPlatform(v8::Handle<v8::String>, const v8::AccessorInfo &info)
{
QV8Engine *engine = reinterpret_cast<QV8Engine*>(v8::External::Cast(info.Data().get())->Value());
if (!engine->m_platform) {
return engine->newQObject(engine->m_platform);
}
-v8::Handle<v8::Value> QV8Engine::getApplication(v8::Local<v8::String>, const v8::AccessorInfo &info)
+v8::Handle<v8::Value> QV8Engine::getApplication(v8::Handle<v8::String>, const v8::AccessorInfo &info)
{
QV8Engine *engine = reinterpret_cast<QV8Engine*>(v8::External::Cast(info.Data().get())->Value());
if (!engine->m_application) {
}
#ifndef QT_NO_IM
-v8::Handle<v8::Value> QV8Engine::getInputMethod(v8::Local<v8::String>, const v8::AccessorInfo &info)
+v8::Handle<v8::Value> QV8Engine::getInputMethod(v8::Handle<v8::String>, const v8::AccessorInfo &info)
{
QV8Engine *engine = reinterpret_cast<QV8Engine*>(v8::External::Cast(info.Data().get())->Value());
return engine->newQObject(QQml_guiProvider()->inputMethod(), CppOwnership);
{
public:
int Length() const { return _ac; }
- v8::Local<v8::Value> operator[](int idx) { return (*_a)->Get(idx); }
+ v8::Handle<v8::Value> operator[](int idx) { return (*_a)->Get(idx); }
QQmlContextData *context() { return _c; }
v8::Handle<v8::Object> qmlGlobal() { return *_g; }
void returnValue(v8::Handle<v8::Value> rv) { *_r = rv; }
inline bool isVariant(const QV4::Value &);
// Compile \a source (from \a fileName at \a lineNumber) in QML mode
- v8::Local<v8::Script> qmlModeCompile(const QString &source,
+ v8::Handle<v8::Script> qmlModeCompile(const QString &source,
const QString &fileName = QString(),
quint16 lineNumber = 1);
- v8::Local<v8::Script> qmlModeCompile(const char *source, int sourceLength = -1,
+ v8::Handle<v8::Script> qmlModeCompile(const char *source, int sourceLength = -1,
const QString &fileName = QString(),
quint16 lineNumber = 1);
// Return the QML global "scope" object for the \a ctxt context and \a scope object.
- inline v8::Local<v8::Object> qmlScope(QQmlContextData *ctxt, QObject *scope);
+ inline v8::Handle<v8::Object> qmlScope(QQmlContextData *ctxt, QObject *scope);
// Return a JS wrapper for the given QObject \a object
inline QV4::Value newQObject(QObject *object);
void addRelationshipForGC(QObject *object, v8::Persistent<v8::Value> handle);
void addRelationshipForGC(QObject *object, QObject *other);
- static v8::Handle<v8::Value> getPlatform(v8::Local<v8::String> property, const v8::AccessorInfo &info);
- static v8::Handle<v8::Value> getApplication(v8::Local<v8::String> property, const v8::AccessorInfo &info);
+ static v8::Handle<v8::Value> getPlatform(v8::Handle<v8::String> property, const v8::AccessorInfo &info);
+ static v8::Handle<v8::Value> getApplication(v8::Handle<v8::String> property, const v8::AccessorInfo &info);
#ifndef QT_NO_IM
- static v8::Handle<v8::Value> getInputMethod(v8::Local<v8::String> property, const v8::AccessorInfo &info);
+ static v8::Handle<v8::Value> getInputMethod(v8::Handle<v8::String> property, const v8::AccessorInfo &info);
#endif
struct ThreadData {
return m_variantWrapper.isVariant(value);
}
-v8::Local<v8::Object> QV8Engine::qmlScope(QQmlContextData *ctxt, QObject *scope)
+v8::Handle<v8::Object> QV8Engine::qmlScope(QQmlContextData *ctxt, QObject *scope)
{
return m_contextWrapper.qmlScope(ctxt, scope);
}
qPersistentDispose(m_resultObject);
}
-v8::Local<v8::Object> QV8Include::resultValue(Status status)
+v8::Handle<v8::Object> QV8Include::resultValue(Status status)
{
// XXX It seems inefficient to create this object from scratch each time.
- v8::Local<v8::Object> result = v8::Object::New();
+ v8::Handle<v8::Object> result = v8::Object::New();
result->Set(v8::String::New("OK"), v8::Integer::New(Ok));
result->Set(v8::String::New("LOADING"), v8::Integer::New(Loading));
result->Set(v8::String::New("NETWORK_ERROR"), v8::Integer::New(NetworkError));
v8::TryCatch try_catch;
- v8::Local<v8::Script> script = m_engine->qmlModeCompile(code, m_url.toString());
+ v8::Handle<v8::Script> script = m_engine->qmlModeCompile(code, m_url.toString());
if (!try_catch.HasCaught()) {
m_engine->contextWrapper()->addSubContext(m_qmlglobal, script, importContext);
QUrl url(context->resolvedUrl(QUrl(args[0]->v4Value().toQString())));
- v8::Local<v8::Function> callbackFunction;
+ v8::Handle<v8::Function> callbackFunction;
if (args.Length() >= 2 && args[1]->IsFunction())
- callbackFunction = v8::Local<v8::Function>::Cast(args[1]);
+ callbackFunction = v8::Handle<v8::Function>::Cast(args[1]);
QString localFile = QQmlFile::urlToLocalFileOrQrc(url);
- v8::Local<v8::Object> result;
+ v8::Handle<v8::Object> result;
if (localFile.isEmpty()) {
QV8Include *i = new QV8Include(url, engine, context,
QV4::Value::fromObject(args.GetIsolate()->GetEngine()->qmlContextObject()),
callbackFunction);
- result = v8::Local<v8::Object>::New(i->result());
+ result = i->result();
} else {
v8::TryCatch try_catch;
- v8::Local<v8::Script> script = engine->qmlModeCompile(code, url.toString());
+ v8::Handle<v8::Script> script = engine->qmlModeCompile(code, url.toString());
if (!try_catch.HasCaught()) {
v8::Handle<v8::Object> qmlglobal = QV4::Value::fromObject(args.GetIsolate()->GetEngine()->qmlContextObject());
v8::Handle<v8::Object> result();
- static v8::Local<v8::Object> resultValue(Status status = Loading);
+ static v8::Handle<v8::Object> resultValue(Status status = Loading);
static void callback(QV8Engine *engine, v8::Handle<v8::Function> callback, v8::Handle<v8::Object> status);
QV8Engine *m_engine;
void QV8ListWrapper::init(QV8Engine *engine)
{
m_engine = engine;
- v8::Local<v8::FunctionTemplate> ft = v8::FunctionTemplate::New();
+ v8::Handle<v8::FunctionTemplate> ft = v8::FunctionTemplate::New();
ft->InstanceTemplate()->SetFallbackPropertyHandler(Getter, Setter, 0, 0, Enumerator);
ft->InstanceTemplate()->SetIndexedPropertyHandler(IndexedGetter);
ft->InstanceTemplate()->SetAccessor(v8::String::New("length"), LengthGetter, 0,
return v8::Null();
// XXX NewInstance() should be optimized
- v8::Local<v8::Object> rv = m_constructor->NewInstance();
+ v8::Handle<v8::Object> rv = m_constructor->NewInstance();
QV8ListResource *r = new QV8ListResource(m_engine);
r->object = object;
r->propertyType = propType;
v8::Handle<v8::Value> QV8ListWrapper::newList(const QQmlListProperty<QObject> &prop, int propType)
{
// XXX NewInstance() should be optimized
- v8::Local<v8::Object> rv = m_constructor->NewInstance();
+ v8::Handle<v8::Object> rv = m_constructor->NewInstance();
QV8ListResource *r = new QV8ListResource(m_engine);
r->object = prop.object;
r->property = prop;
m_engine->engine()));
}
-v8::Handle<v8::Value> QV8ListWrapper::Getter(v8::Local<v8::String> property,
+v8::Handle<v8::Value> QV8ListWrapper::Getter(v8::Handle<v8::String> property,
const v8::AccessorInfo &info)
{
Q_UNUSED(property);
return v8::Handle<v8::Value>();
}
-v8::Handle<v8::Value> QV8ListWrapper::Setter(v8::Local<v8::String> property,
- v8::Local<v8::Value> value,
+v8::Handle<v8::Value> QV8ListWrapper::Setter(v8::Handle<v8::String> property,
+ v8::Handle<v8::Value> value,
const v8::AccessorInfo &info)
{
Q_UNUSED(property);
}
}
-v8::Handle<v8::Value> QV8ListWrapper::LengthGetter(v8::Local<v8::String> property,
+v8::Handle<v8::Value> QV8ListWrapper::LengthGetter(v8::Handle<v8::String> property,
const v8::AccessorInfo &info)
{
Q_UNUSED(property);
quint32 count = resource->property.count?resource->property.count(&resource->property):0;
- v8::Local<v8::Array> rv = v8::Array::New(count);
+ v8::Handle<v8::Array> rv = v8::Array::New(count);
for (uint ii = 0; ii < count; ++ii)
rv->Set(ii, v8::Number::New(ii));
QVariant toVariant(QV8ObjectResource *);
private:
- static v8::Handle<v8::Value> Getter(v8::Local<v8::String> property,
+ static v8::Handle<v8::Value> Getter(v8::Handle<v8::String> property,
const v8::AccessorInfo &info);
- static v8::Handle<v8::Value> Setter(v8::Local<v8::String> property,
- v8::Local<v8::Value> value,
+ static v8::Handle<v8::Value> Setter(v8::Handle<v8::String> property,
+ v8::Handle<v8::Value> value,
const v8::AccessorInfo &info);
static v8::Handle<v8::Value> IndexedGetter(uint32_t index,
const v8::AccessorInfo &info);
- static v8::Handle<v8::Value> LengthGetter(v8::Local<v8::String> property,
+ static v8::Handle<v8::Value> LengthGetter(v8::Handle<v8::String> property,
const v8::AccessorInfo &info);
static v8::Handle<v8::Array> Enumerator(const v8::AccessorInfo &info);
template<typename T, void (*ReadFunction)(QObject *, const QQmlPropertyData &,
void *, QQmlNotifier **)>
-static v8::Handle<v8::Value> GenericValueGetter(v8::Local<v8::String>, const v8::AccessorInfo &info)
+static v8::Handle<v8::Value> GenericValueGetter(v8::Handle<v8::String>, const v8::AccessorInfo &info)
{
v8::Handle<v8::Object> This = info.This();
QV8QObjectResource *resource = v8_resource_check<QV8QObjectResource>(This);
destroyHash = m_destroyString.hash();
{
- v8::Local<v8::FunctionTemplate> ft = v8::FunctionTemplate::New();
+ v8::Handle<v8::FunctionTemplate> ft = v8::FunctionTemplate::New();
ft->InstanceTemplate()->SetFallbackPropertyHandler(Getter, Setter, Query, 0, Enumerator);
ft->InstanceTemplate()->SetHasExternalResource(true);
m_constructor = qPersistentNew<v8::Function>(ft->GetFunction());
"});"\
"});"\
"})"
- v8::Local<v8::Script> script = v8::Script::New(v8::String::New(CREATE_FUNCTION_SOURCE), &origin, 0,
+ v8::Handle<v8::Script> script = v8::Script::New(v8::String::New(CREATE_FUNCTION_SOURCE), &origin, 0,
v8::Handle<v8::String>(), v8::Script::NativeMode);
#undef CREATE_FUNCTION_SOURCE
- v8::Local<v8::Function> fn = v8::Local<v8::Function>::Cast(script->Run());
+ v8::Handle<v8::Function> fn = v8::Handle<v8::Function>::Cast(script->Run());
v8::Handle<v8::Value> invokeFn = v8::FunctionTemplate::New(Invoke)->GetFunction();
v8::Handle<v8::Value> args[] = { invokeFn };
- v8::Local<v8::Function> createFn = v8::Local<v8::Function>::Cast(fn->Call(v8::Value::fromV4Value(engine->global()), 1, args));
+ v8::Handle<v8::Function> createFn = v8::Handle<v8::Function>::Cast(fn->Call(v8::Value::fromV4Value(engine->global()), 1, args));
m_methodConstructor = qPersistentNew<v8::Function>(createFn);
}
- v8::Local<v8::Function> connect = V8FUNCTION(Connect, engine);
- v8::Local<v8::Function> disconnect = V8FUNCTION(Disconnect, engine);
+ v8::Handle<v8::Function> connect = V8FUNCTION(Connect, engine);
+ v8::Handle<v8::Function> disconnect = V8FUNCTION(Disconnect, engine);
{
- v8::Local<v8::FunctionTemplate> ft = v8::FunctionTemplate::New();
+ v8::Handle<v8::FunctionTemplate> ft = v8::FunctionTemplate::New();
ft->InstanceTemplate()->SetHasExternalResource(true);
ft->PrototypeTemplate()->Set(v8::String::New("connect"), connect, v8::DontEnum);
ft->PrototypeTemplate()->Set(v8::String::New("disconnect"), disconnect, v8::DontEnum);
}
{
- v8::Local<v8::Object> prototype = v8::Local<v8::Object>::New(v8::Value::fromV4Value(engine->global()))
+ v8::Handle<v8::Object> prototype = v8::Handle<v8::Object>(engine->global())
->Get(v8::String::New("Function"))->ToObject()->Get(v8::String::New("prototype"))->ToObject();
prototype->Set(v8::String::New("connect"), connect, v8::DontEnum);
prototype->Set(v8::String::New("disconnect"), disconnect, v8::DontEnum);
} else if (result->isV8Function()) {
return MethodClosure::createWithGlobal(engine, object, objectHandle, result->coreIndex);
} else if (result->isSignalHandler()) {
- v8::Local<v8::Object> handler = engine->qobjectWrapper()->m_signalHandlerConstructor->NewInstance();
+ v8::Handle<v8::Object> handler = engine->qobjectWrapper()->m_signalHandlerConstructor->NewInstance();
QV8SignalHandlerResource *r = new QV8SignalHandlerResource(engine, object, result->coreIndex);
handler->SetExternalResource(r);
return handler;
QQmlContextData *context = engine->callingContext();
v8::Handle<v8::Function> function = v8::Handle<v8::Function>::Cast(value);
- v8::Local<v8::StackTrace> trace =
+ v8::Handle<v8::StackTrace> trace =
v8::StackTrace::CurrentStackTrace(1, (v8::StackTrace::StackTraceOptions)(v8::StackTrace::kLineNumber |
v8::StackTrace::kScriptName));
- v8::Local<v8::StackFrame> frame = trace->GetFrame(0);
+ v8::Handle<v8::StackFrame> frame = trace->GetFrame(0);
int lineNumber = frame->GetLineNumber();
int columnNumber = frame->GetColumn();
QString url = frame->GetScriptName()->v4Value().toQString();
return true;
}
-v8::Handle<v8::Value> QV8QObjectWrapper::Getter(v8::Local<v8::String> property,
+v8::Handle<v8::Value> QV8QObjectWrapper::Getter(v8::Handle<v8::String> property,
const v8::AccessorInfo &info)
{
QV8QObjectResource *resource = v8_resource_check<QV8QObjectResource>(info.This());
return v8::Handle<v8::Value>();
}
-v8::Handle<v8::Value> QV8QObjectWrapper::Setter(v8::Local<v8::String> property,
- v8::Local<v8::Value> value,
+v8::Handle<v8::Value> QV8QObjectWrapper::Setter(v8::Handle<v8::String> property,
+ v8::Handle<v8::Value> value,
const v8::AccessorInfo &info)
{
QV8QObjectResource *resource = v8_resource_check<QV8QObjectResource>(info.This());
return value;
}
-v8::Handle<v8::Integer> QV8QObjectWrapper::Query(v8::Local<v8::String> property,
+v8::Handle<v8::Integer> QV8QObjectWrapper::Query(v8::Handle<v8::String> property,
const v8::AccessorInfo &info)
{
QV8QObjectResource *resource = v8_resource_check<QV8QObjectResource>(info.This());
result = cache->propertyNames();
}
- v8::Local<v8::Array> rv = v8::Array::New(result.count());
+ v8::Handle<v8::Array> rv = v8::Array::New(result.count());
for (int ii = 0; ii < result.count(); ++ii)
rv->Set(ii, resource->engine->toString(result.at(ii)));
return rv;
}
-static void FastValueSetter(v8::Local<v8::String>, v8::Local<v8::Value> value,
+static void FastValueSetter(v8::Handle<v8::String>, v8::Handle<v8::Value> value,
const v8::AccessorInfo& info)
{
QV8QObjectResource *resource = v8_resource_check<QV8QObjectResource>(info.This());
StoreProperty(resource->engine, object, pdata, value);
}
-static void FastValueSetterReadOnly(v8::Local<v8::String> property, v8::Local<v8::Value>,
+static void FastValueSetterReadOnly(v8::Handle<v8::String> property, v8::Handle<v8::Value>,
const v8::AccessorInfo& info)
{
QV8QObjectResource *resource = v8_resource_check<QV8QObjectResource>(info.This());
qPersistentDispose(handle);
}
-v8::Local<v8::Object> QQmlPropertyCache::newQObject(QObject *object, QV8Engine *engine)
+v8::Handle<v8::Object> QQmlPropertyCache::newQObject(QObject *object, QV8Engine *engine)
{
Q_ASSERT(object);
Q_ASSERT(this->engine);
// Setup constructor
if (constructor->isDeleted()) {
- v8::Local<v8::FunctionTemplate> ft;
+ v8::Handle<v8::FunctionTemplate> ft;
const QHashedString toString(QStringLiteral("toString"));
const QHashedString destroy(QStringLiteral("destroy"));
QQmlCleanup::addToEngine(this->engine);
}
- v8::Local<v8::Object> result = v8::Local<v8::Object>::New(constructor->asFunctionObject()->newInstance());
+ v8::Handle<v8::Object> result = constructor->asFunctionObject()->newInstance();
QV8QObjectResource *r = new QV8QObjectResource(engine, object);
result->SetExternalResource(r);
return result;
}
-v8::Local<v8::Object> QV8QObjectWrapper::newQObject(QObject *object, QQmlData *ddata, QV8Engine *engine)
+v8::Handle<v8::Object> QV8QObjectWrapper::newQObject(QObject *object, QQmlData *ddata, QV8Engine *engine)
{
- v8::Local<v8::Object> rv;
+ v8::Handle<v8::Object> rv;
if (!ddata->propertyCache && engine->engine()) {
ddata->propertyCache = QQmlEnginePrivate::get(engine->engine())->cache(object);
if (ddata->v8objectid == m_id && !ddata->v8object.IsEmpty()) {
// We own the v8object
- return v8::Local<v8::Object>::New(ddata->v8object);
+ return ddata->v8object;
} else if (ddata->v8object.IsEmpty() &&
(ddata->v8objectid == m_id || // We own the QObject
ddata->v8objectid == 0 || // No one owns the QObject
!ddata->hasTaintedV8Object)) { // Someone else has used the QObject, but it isn't tainted
- v8::Local<v8::Object> rv = newQObject(object, ddata, m_engine);
+ v8::Handle<v8::Object> rv = newQObject(object, ddata, m_engine);
ddata->v8object = qPersistentNew<v8::Object>(rv);
ddata->v8object.MakeWeak(this, WeakQObjectReferenceCallback);
ddata->v8objectid = m_id;
// If our tainted handle doesn't exist or has been collected, and there isn't
// a handle in the ddata, we can assume ownership of the ddata->v8object
if ((!found || (*iter)->v8object.IsEmpty()) && ddata->v8object.IsEmpty()) {
- v8::Local<v8::Object> rv = newQObject(object, ddata, m_engine);
+ v8::Handle<v8::Object> rv = newQObject(object, ddata, m_engine);
ddata->v8object = qPersistentNew<v8::Object>(rv);
ddata->v8object.MakeWeak(this, WeakQObjectReferenceCallback);
ddata->v8objectid = m_id;
}
if ((*iter)->v8object.IsEmpty()) {
- v8::Local<v8::Object> rv = newQObject(object, ddata, m_engine);
+ v8::Handle<v8::Object> rv = newQObject(object, ddata, m_engine);
(*iter)->v8object = qPersistentNew<v8::Object>(rv);
(*iter)->v8object.MakeWeak((*iter), WeakQObjectInstanceCallback);
}
- return v8::Local<v8::Object>::New((*iter)->v8object);
+ return (*iter)->v8object;
}
}
// This is one of our special QObject method wrappers
v8::Handle<v8::Value> args[] = { engine->qobjectWrapper()->m_hiddenObject };
- v8::Local<v8::Value> data = function->Call(v8::Value::fromV4Value(engine->global()), 1, args);
+ v8::Handle<v8::Value> data = function->Call(v8::Value::fromV4Value(engine->global()), 1, args);
if (data->IsArray()) {
- v8::Local<v8::Array> array = v8::Local<v8::Array>::Cast(data);
+ v8::Handle<v8::Array> array = v8::Handle<v8::Array>::Cast(data);
return qMakePair(engine->toQObject(array->Get(0)->v4Value()), array->Get(1)->Int32Value());
}
if (try_catch.HasCaught()) {
QQmlError error;
error.setDescription(QString(QLatin1String("Unknown exception occurred during evaluation of connected function: %1")).arg(connection.function->GetName()->v4Value().toQString()));
- v8::Local<v8::Message> message = try_catch.Message();
+ v8::Handle<v8::Message> message = try_catch.Message();
if (!message.IsEmpty())
QQmlExpressionPrivate::exceptionToError(message, error);
QQmlEnginePrivate::get(engine->engine())->warning(error);
if (signalObject->metaObject()->method(signalIndex).methodType() != QMetaMethod::Signal)
V8THROW_ERROR("Function.prototype.connect: this object is not a signal");
- v8::Local<v8::Value> functionValue;
- v8::Local<v8::Value> functionThisValue;
+ v8::Handle<v8::Value> functionValue;
+ v8::Handle<v8::Value> functionThisValue;
if (args.Length() == 1) {
functionValue = args[0];
if (signalIndex < 0 || signalObject->metaObject()->method(signalIndex).methodType() != QMetaMethod::Signal)
V8THROW_ERROR("Function.prototype.disconnect: this object is not a signal");
- v8::Local<v8::Value> functionValue;
- v8::Local<v8::Value> functionThisValue;
+ v8::Handle<v8::Value> functionValue;
+ v8::Handle<v8::Value> functionThisValue;
if (args.Length() == 1) {
functionValue = args[0];
QV8QObjectConnectionList::ConnectionList &connections = *slotIter;
- v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast(functionValue);
+ v8::Handle<v8::Function> function = v8::Handle<v8::Function>::Cast(functionValue);
QPair<QObject *, int> functionData = ExtractQtMethod(engine, function);
if (functionData.second != -1) {
{
CallArgs(int length, v8::Handle<v8::Object> *args) : _length(length), _args(args) {}
int Length() const { return _length; }
- v8::Local<v8::Value> operator[](int idx) { return (*_args)->Get(idx); }
+ v8::Handle<v8::Value> operator[](int idx) { return (*_args)->Get(idx); }
private:
int _length;
// Special hack to return info about this closure.
if (argCount == 1 && arguments->Get(0)->StrictEquals(resource->engine->qobjectWrapper()->m_hiddenObject)) {
- v8::Local<v8::Array> data = v8::Array::New(2);
+ v8::Handle<v8::Array> data = v8::Array::New(2);
data->Set(0, args[0]);
data->Set(1, args[1]);
return data;
// XXX Can this be made more by using Array as a prototype and implementing
// directly against QList<QObject*>?
QList<QObject *> &list = *qlistPtr;
- v8::Local<v8::Array> array = v8::Array::New(list.count());
+ v8::Handle<v8::Array> array = v8::Array::New(list.count());
for (int ii = 0; ii < list.count(); ++ii)
array->Set(ii, engine->newQObject(list.at(ii)));
return array;
friend class QV8QObjectConnectionList;
friend class QV8QObjectInstance;
- v8::Local<v8::Object> newQObject(QObject *, QQmlData *, QV8Engine *);
+ v8::Handle<v8::Object> newQObject(QObject *, QQmlData *, QV8Engine *);
bool deleteWeakQObject(QV8QObjectResource *resource, bool calledFromEngineDtor = false);
static v8::Handle<v8::Value> GetProperty(QV8Engine *, QObject *, v8::Handle<v8::Value> *,
const QHashedV8String &, QQmlContextData *, QV8QObjectWrapper::RevisionMode);
static bool SetProperty(QV8Engine *, QObject *, const QHashedV8String &, QQmlContextData *,
v8::Handle<v8::Value>, QV8QObjectWrapper::RevisionMode);
- static v8::Handle<v8::Value> Getter(v8::Local<v8::String> property,
+ static v8::Handle<v8::Value> Getter(v8::Handle<v8::String> property,
const v8::AccessorInfo &info);
- static v8::Handle<v8::Value> Setter(v8::Local<v8::String> property,
- v8::Local<v8::Value> value,
+ static v8::Handle<v8::Value> Setter(v8::Handle<v8::String> property,
+ v8::Handle<v8::Value> value,
const v8::AccessorInfo &info);
- static v8::Handle<v8::Integer> Query(v8::Local<v8::String> property,
+ static v8::Handle<v8::Integer> Query(v8::Handle<v8::String> property,
const v8::AccessorInfo &info);
static v8::Handle<v8::Array> Enumerator(const v8::AccessorInfo &info);
static v8::Handle<v8::Value> Connect(const v8::Arguments &args);
m_sort = qPersistentNew<v8::Function>(v8::FunctionTemplate::New(Sort)->GetFunction());
m_arrayPrototype = qPersistentNew<v8::Value>(v8::Array::New(1)->GetPrototype());
- v8::Local<v8::Script> defaultSortCompareScript = v8::Script::Compile(engine->toString(defaultSortString));
+ v8::Handle<v8::Script> defaultSortCompareScript = v8::Script::Compile(engine->toString(defaultSortString));
m_defaultSortComparer = qPersistentNew<v8::Function>(v8::Handle<v8::Function>(v8::Function::Cast(defaultSortCompareScript->Run().get())));
- v8::Local<v8::FunctionTemplate> ft = v8::FunctionTemplate::New();
+ v8::Handle<v8::FunctionTemplate> ft = v8::FunctionTemplate::New();
ft->InstanceTemplate()->SetFallbackPropertyHandler(Getter, Setter);
ft->InstanceTemplate()->SetIndexedPropertyHandler(IndexedGetter, IndexedSetter, 0, IndexedDeleter, IndexedEnumerator);
ft->InstanceTemplate()->SetAccessor(v8::String::New("length"), LengthGetter, LengthSetter,
r = new QV8##ElementTypeName##SequenceResource(m_engine, object, propertyIndex); \
} else
-v8::Local<v8::Object> QV8SequenceWrapper::newSequence(int sequenceType, QObject *object, int propertyIndex, bool *succeeded)
+v8::Handle<v8::Object> QV8SequenceWrapper::newSequence(int sequenceType, QObject *object, int propertyIndex, bool *succeeded)
{
// This function is called when the property is a QObject Q_PROPERTY of
// the given sequence type. Internally we store a typed-sequence
// and so access/mutate avoids variant conversion.
*succeeded = true;
QV8SequenceResource *r = 0;
- FOREACH_QML_SEQUENCE_TYPE(NEW_REFERENCE_SEQUENCE) { /* else */ *succeeded = false; return v8::Local<v8::Object>(); }
+ FOREACH_QML_SEQUENCE_TYPE(NEW_REFERENCE_SEQUENCE) { /* else */ *succeeded = false; return v8::Handle<v8::Object>(); }
- v8::Local<v8::Object> rv = m_constructor->NewInstance();
+ v8::Handle<v8::Object> rv = m_constructor->NewInstance();
rv->SetExternalResource(r);
rv->SetPrototype(m_arrayPrototype);
return rv;
r = new QV8##ElementTypeName##SequenceResource(m_engine, v.value<SequenceType>()); \
} else
-v8::Local<v8::Object> QV8SequenceWrapper::fromVariant(const QVariant& v, bool *succeeded)
+v8::Handle<v8::Object> QV8SequenceWrapper::fromVariant(const QVariant& v, bool *succeeded)
{
// This function is called when assigning a sequence value to a normal JS var
// in a JS block. Internally, we store a sequence of the specified type.
int sequenceType = v.userType();
*succeeded = true;
QV8SequenceResource *r = 0;
- FOREACH_QML_SEQUENCE_TYPE(NEW_COPY_SEQUENCE) { /* else */ *succeeded = false; return v8::Local<v8::Object>(); }
+ FOREACH_QML_SEQUENCE_TYPE(NEW_COPY_SEQUENCE) { /* else */ *succeeded = false; return v8::Handle<v8::Object>(); }
- v8::Local<v8::Object> rv = m_constructor->NewInstance();
+ v8::Handle<v8::Object> rv = m_constructor->NewInstance();
rv->SetExternalResource(r);
rv->SetPrototype(m_arrayPrototype);
return rv;
}
#undef SEQUENCE_TO_VARIANT
-v8::Handle<v8::Value> QV8SequenceWrapper::IndexedSetter(quint32 index, v8::Local<v8::Value> value, const v8::AccessorInfo &info)
+v8::Handle<v8::Value> QV8SequenceWrapper::IndexedSetter(quint32 index, v8::Handle<v8::Value> value, const v8::AccessorInfo &info)
{
QV8SequenceResource *sr = v8_resource_cast<QV8SequenceResource>(info.This());
Q_ASSERT(sr);
return sr->indexedEnumerator();
}
-v8::Handle<v8::Value> QV8SequenceWrapper::LengthGetter(v8::Local<v8::String> property, const v8::AccessorInfo &info)
+v8::Handle<v8::Value> QV8SequenceWrapper::LengthGetter(v8::Handle<v8::String> property, const v8::AccessorInfo &info)
{
Q_UNUSED(property);
QV8SequenceResource *sr = v8_resource_cast<QV8SequenceResource>(info.This());
return v8::Integer::NewFromUnsigned(sr->lengthGetter());
}
-void QV8SequenceWrapper::LengthSetter(v8::Local<v8::String> property, v8::Local<v8::Value> value, const v8::AccessorInfo &info)
+void QV8SequenceWrapper::LengthSetter(v8::Handle<v8::String> property, v8::Handle<v8::Value> value, const v8::AccessorInfo &info)
{
Q_UNUSED(property);
QV8SequenceResource *sr = v8_resource_cast<QV8SequenceResource>(info.This());
sr->lengthSetter(value);
}
-v8::Handle<v8::Value> QV8SequenceWrapper::ToStringGetter(v8::Local<v8::String> property, const v8::AccessorInfo &info)
+v8::Handle<v8::Value> QV8SequenceWrapper::ToStringGetter(v8::Handle<v8::String> property, const v8::AccessorInfo &info)
{
Q_UNUSED(property);
return info.Data();
}
-v8::Handle<v8::Value> QV8SequenceWrapper::ValueOfGetter(v8::Local<v8::String> property,
+v8::Handle<v8::Value> QV8SequenceWrapper::ValueOfGetter(v8::Handle<v8::String> property,
const v8::AccessorInfo &info)
{
Q_UNUSED(property);
return info.Data();
}
-v8::Handle<v8::Value> QV8SequenceWrapper::SortGetter(v8::Local<v8::String> property, const v8::AccessorInfo &info)
+v8::Handle<v8::Value> QV8SequenceWrapper::SortGetter(v8::Handle<v8::String> property, const v8::AccessorInfo &info)
{
Q_UNUSED(property);
return info.Data();
return v8::Integer::NewFromUnsigned(sr->lengthGetter());
}
-v8::Handle<v8::Value> QV8SequenceWrapper::Getter(v8::Local<v8::String> property,
+v8::Handle<v8::Value> QV8SequenceWrapper::Getter(v8::Handle<v8::String> property,
const v8::AccessorInfo &info)
{
Q_UNUSED(property);
return v8::Handle<v8::Value>();
}
-v8::Handle<v8::Value> QV8SequenceWrapper::Setter(v8::Local<v8::String> property,
- v8::Local<v8::Value> value,
+v8::Handle<v8::Value> QV8SequenceWrapper::Setter(v8::Handle<v8::String> property,
+ v8::Handle<v8::Value> value,
const v8::AccessorInfo &info)
{
Q_UNUSED(property);
bool isEqual(QV8ObjectResource *lhs, QV8ObjectResource *rhs);
quint32 sequenceLength(QV8ObjectResource *);
- v8::Local<v8::Object> newSequence(int sequenceTypeId, QObject *object, int propertyIndex, bool *succeeded);
- v8::Local<v8::Object> fromVariant(const QVariant& v, bool *succeeded);
+ v8::Handle<v8::Object> newSequence(int sequenceTypeId, QObject *object, int propertyIndex, bool *succeeded);
+ v8::Handle<v8::Object> fromVariant(const QVariant& v, bool *succeeded);
QVariant toVariant(QV8ObjectResource *);
QVariant toVariant(v8::Handle<v8::Array> array, int typeHint, bool *succeeded);
v8::Persistent<v8::Function> m_defaultSortComparer;
static v8::Handle<v8::Value> IndexedGetter(quint32 index, const v8::AccessorInfo &info);
- static v8::Handle<v8::Value> IndexedSetter(quint32 index, v8::Local<v8::Value> value, const v8::AccessorInfo &info);
+ static v8::Handle<v8::Value> IndexedSetter(quint32 index, v8::Handle<v8::Value> value, const v8::AccessorInfo &info);
static v8::Handle<v8::Boolean> IndexedDeleter(quint32 index, const v8::AccessorInfo &info);
static v8::Handle<v8::Array> IndexedEnumerator(const v8::AccessorInfo &info);
- static v8::Handle<v8::Value> LengthGetter(v8::Local<v8::String> property, const v8::AccessorInfo &info);
- static void LengthSetter(v8::Local<v8::String> property, v8::Local<v8::Value> value, const v8::AccessorInfo &info);
- static v8::Handle<v8::Value> ToStringGetter(v8::Local<v8::String> property, const v8::AccessorInfo &info);
+ static v8::Handle<v8::Value> LengthGetter(v8::Handle<v8::String> property, const v8::AccessorInfo &info);
+ static void LengthSetter(v8::Handle<v8::String> property, v8::Handle<v8::Value> value, const v8::AccessorInfo &info);
+ static v8::Handle<v8::Value> ToStringGetter(v8::Handle<v8::String> property, const v8::AccessorInfo &info);
static v8::Handle<v8::Value> ToString(const v8::Arguments &args);
- static v8::Handle<v8::Value> ValueOfGetter(v8::Local<v8::String> property, const v8::AccessorInfo &info);
- static v8::Handle<v8::Value> SortGetter(v8::Local<v8::String> property, const v8::AccessorInfo &info);
+ static v8::Handle<v8::Value> ValueOfGetter(v8::Handle<v8::String> property, const v8::AccessorInfo &info);
+ static v8::Handle<v8::Value> SortGetter(v8::Handle<v8::String> property, const v8::AccessorInfo &info);
static v8::Handle<v8::Value> ValueOf(const v8::Arguments &args);
- static v8::Handle<v8::Value> Getter(v8::Local<v8::String> property, const v8::AccessorInfo &info);
- static v8::Handle<v8::Value> Setter(v8::Local<v8::String> property, v8::Local<v8::Value> value, const v8::AccessorInfo &info);
+ static v8::Handle<v8::Value> Getter(v8::Handle<v8::String> property, const v8::AccessorInfo &info);
+ static v8::Handle<v8::Value> Setter(v8::Handle<v8::String> property, v8::Handle<v8::Value> value, const v8::AccessorInfo &info);
static v8::Handle<v8::Value> Sort(const v8::Arguments &args);
};
{
if (!engine)
return;
- v8::Local<v8::StackTrace> currStack = v8::StackTrace::CurrentStackTrace(1);
+ v8::Handle<v8::StackTrace> currStack = v8::StackTrace::CurrentStackTrace(1);
if (currStack.IsEmpty())
return;
- v8::Local<v8::StackFrame> currFrame = currStack->GetFrame(0);
+ v8::Handle<v8::StackFrame> currFrame = currStack->GetFrame(0);
if (currFrame.IsEmpty())
return;
loadReference(); \
} \
qint32 count = c.count(); \
- v8::Local<v8::Array> retn = v8::Array::New(count); \
+ v8::Handle<v8::Array> retn = v8::Array::New(count); \
for (qint32 i = 0; i < count; ++i) { \
retn->Set(static_cast<quint32>(i), v8::Integer::NewFromUnsigned(static_cast<quint32>(i))); \
} \
void QV8TypeWrapper::init(QV8Engine *engine)
{
m_engine = engine;
- v8::Local<v8::FunctionTemplate> ft = v8::FunctionTemplate::New();
+ v8::Handle<v8::FunctionTemplate> ft = v8::FunctionTemplate::New();
ft->InstanceTemplate()->SetNamedPropertyHandler(Getter, Setter);
ft->InstanceTemplate()->SetHasExternalResource(true);
m_constructor = qPersistentNew<v8::Function>(ft->GetFunction());
}
// Returns a type wrapper for type t on o. This allows access of enums, and attached properties.
-v8::Local<v8::Object> QV8TypeWrapper::newObject(QObject *o, QQmlType *t, TypeNameMode mode)
+v8::Handle<v8::Object> QV8TypeWrapper::newObject(QObject *o, QQmlType *t, TypeNameMode mode)
{
Q_ASSERT(t);
// XXX NewInstance() should be optimized
- v8::Local<v8::Object> rv = m_constructor->NewInstance();
+ v8::Handle<v8::Object> rv = m_constructor->NewInstance();
QV8TypeResource *r = new QV8TypeResource(m_engine);
r->mode = mode; r->object = o; r->type = t;
rv->SetExternalResource(r);
// Returns a type wrapper for importNamespace (of t) on o. This allows nested resolution of a type in a
// namespace.
-v8::Local<v8::Object> QV8TypeWrapper::newObject(QObject *o, QQmlTypeNameCache *t,
+v8::Handle<v8::Object> QV8TypeWrapper::newObject(QObject *o, QQmlTypeNameCache *t,
const void *importNamespace, TypeNameMode mode)
{
Q_ASSERT(t);
Q_ASSERT(importNamespace);
// XXX NewInstance() should be optimized
- v8::Local<v8::Object> rv = m_constructor->NewInstance();
+ v8::Handle<v8::Object> rv = m_constructor->NewInstance();
QV8TypeResource *r = new QV8TypeResource(m_engine);
t->addref();
r->mode = mode; r->object = o; r->typeNamespace = t; r->importNamespace = importNamespace;
return QVariant();
}
-v8::Handle<v8::Value> QV8TypeWrapper::Getter(v8::Local<v8::String> property,
+v8::Handle<v8::Value> QV8TypeWrapper::Getter(v8::Handle<v8::String> property,
const v8::AccessorInfo &info)
{
QV8TypeResource *resource = v8_resource_cast<QV8TypeResource>(info.This());
return v8::Handle<v8::Value>();
}
-v8::Handle<v8::Value> QV8TypeWrapper::Setter(v8::Local<v8::String> property,
- v8::Local<v8::Value> value,
+v8::Handle<v8::Value> QV8TypeWrapper::Setter(v8::Handle<v8::String> property,
+ v8::Handle<v8::Value> value,
const v8::AccessorInfo &info)
{
QV8TypeResource *resource = v8_resource_cast<QV8TypeResource>(info.This());
void destroy();
enum TypeNameMode { IncludeEnums, ExcludeEnums };
- v8::Local<v8::Object> newObject(QObject *, QQmlType *, TypeNameMode = IncludeEnums);
- v8::Local<v8::Object> newObject(QObject *, QQmlTypeNameCache *, const void *,
+ v8::Handle<v8::Object> newObject(QObject *, QQmlType *, TypeNameMode = IncludeEnums);
+ v8::Handle<v8::Object> newObject(QObject *, QQmlTypeNameCache *, const void *,
TypeNameMode = IncludeEnums);
QVariant toVariant(QV8ObjectResource *);
private:
- static v8::Handle<v8::Value> Getter(v8::Local<v8::String> property,
+ static v8::Handle<v8::Value> Getter(v8::Handle<v8::String> property,
const v8::AccessorInfo &info);
- static v8::Handle<v8::Value> Setter(v8::Local<v8::String> property,
- v8::Local<v8::Value> value,
+ static v8::Handle<v8::Value> Setter(v8::Handle<v8::String> property,
+ v8::Handle<v8::Value> value,
const v8::AccessorInfo &info);
QV8Engine *m_engine;
{
m_engine = engine;
m_toString = qPersistentNew<v8::Function>(v8::FunctionTemplate::New(ToString)->GetFunction());
- v8::Local<v8::FunctionTemplate> ft = v8::FunctionTemplate::New();
+ v8::Handle<v8::FunctionTemplate> ft = v8::FunctionTemplate::New();
ft->InstanceTemplate()->SetNamedPropertyHandler(Getter, Setter);
ft->InstanceTemplate()->SetHasExternalResource(true);
ft->InstanceTemplate()->MarkAsUseUserObjectComparison();
toStringHash = m_toStringString.hash();
}
-v8::Local<v8::Object> QV8ValueTypeWrapper::newValueType(QObject *object, int property, QQmlValueType *type)
+v8::Handle<v8::Object> QV8ValueTypeWrapper::newValueType(QObject *object, int property, QQmlValueType *type)
{
// XXX NewInstance() should be optimized
- v8::Local<v8::Object> rv = m_constructor->NewInstance();
+ v8::Handle<v8::Object> rv = m_constructor->NewInstance();
QV8ValueTypeReferenceResource *r = new QV8ValueTypeReferenceResource(m_engine);
r->type = type; r->object = object; r->property = property;
rv->SetExternalResource(r);
return rv;
}
-v8::Local<v8::Object> QV8ValueTypeWrapper::newValueType(const QVariant &value, QQmlValueType *type)
+v8::Handle<v8::Object> QV8ValueTypeWrapper::newValueType(const QVariant &value, QQmlValueType *type)
{
// XXX NewInstance() should be optimized
- v8::Local<v8::Object> rv = m_constructor->NewInstance();
+ v8::Handle<v8::Object> rv = m_constructor->NewInstance();
QV8ValueTypeCopyResource *r = new QV8ValueTypeCopyResource(m_engine);
r->type = type; r->value = value;
rv->SetExternalResource(r);
}
}
-v8::Handle<v8::Value> QV8ValueTypeWrapper::ToStringGetter(v8::Local<v8::String> property,
+v8::Handle<v8::Value> QV8ValueTypeWrapper::ToStringGetter(v8::Handle<v8::String> property,
const v8::AccessorInfo &info)
{
Q_UNUSED(property);
}
}
-v8::Handle<v8::Value> QV8ValueTypeWrapper::Getter(v8::Local<v8::String> property,
+v8::Handle<v8::Value> QV8ValueTypeWrapper::Getter(v8::Handle<v8::String> property,
const v8::AccessorInfo &info)
{
QV8ValueTypeResource *r = v8_resource_cast<QV8ValueTypeResource>(info.This());
#undef VALUE_TYPE_ACCESSOR
}
-v8::Handle<v8::Value> QV8ValueTypeWrapper::Setter(v8::Local<v8::String> property,
- v8::Local<v8::Value> value,
+v8::Handle<v8::Value> QV8ValueTypeWrapper::Setter(v8::Handle<v8::String> property,
+ v8::Handle<v8::Value> value,
const v8::AccessorInfo &info)
{
QV8ValueTypeResource *r = v8_resource_cast<QV8ValueTypeResource>(info.This());
cacheData.valueTypeCoreIndex = index;
cacheData.valueTypePropType = p.userType();
- v8::Local<v8::StackTrace> trace =
+ v8::Handle<v8::StackTrace> trace =
v8::StackTrace::CurrentStackTrace(1,
(v8::StackTrace::StackTraceOptions)(v8::StackTrace::kLineNumber |
v8::StackTrace::kScriptName));
- v8::Local<v8::StackFrame> frame = trace->GetFrame(0);
+ v8::Handle<v8::StackFrame> frame = trace->GetFrame(0);
int lineNumber = frame->GetLineNumber();
int columnNumber = frame->GetColumn();
QString url = frame->GetScriptName()->v4Value().toQString();
void init(QV8Engine *);
void destroy();
- v8::Local<v8::Object> newValueType(QObject *, int, QQmlValueType *);
- v8::Local<v8::Object> newValueType(const QVariant &, QQmlValueType *);
+ v8::Handle<v8::Object> newValueType(QObject *, int, QQmlValueType *);
+ v8::Handle<v8::Object> newValueType(const QVariant &, QQmlValueType *);
bool isValueType(v8::Handle<v8::Object>) const;
static bool isEqual(QV8ObjectResource *, const QVariant& value);
private:
- static v8::Handle<v8::Value> ToStringGetter(v8::Local<v8::String> property,
+ static v8::Handle<v8::Value> ToStringGetter(v8::Handle<v8::String> property,
const v8::AccessorInfo &info);
static v8::Handle<v8::Value> ToString(const v8::Arguments &args);
- static v8::Handle<v8::Value> Getter(v8::Local<v8::String> property,
+ static v8::Handle<v8::Value> Getter(v8::Handle<v8::String> property,
const v8::AccessorInfo &info);
- static v8::Handle<v8::Value> Setter(v8::Local<v8::String> property,
- v8::Local<v8::Value> value,
+ static v8::Handle<v8::Value> Setter(v8::Handle<v8::String> property,
+ v8::Handle<v8::Value> value,
const v8::AccessorInfo &info);
QV8Engine *m_engine;
m_valueOf = qPersistentNew<v8::Function>(v8::FunctionTemplate::New(ValueOf)->GetFunction());
{
- v8::Local<v8::FunctionTemplate> ft = v8::FunctionTemplate::New();
+ v8::Handle<v8::FunctionTemplate> ft = v8::FunctionTemplate::New();
ft->InstanceTemplate()->SetFallbackPropertyHandler(Getter, Setter);
ft->InstanceTemplate()->SetHasExternalResource(true);
ft->InstanceTemplate()->MarkAsUseUserObjectComparison();
{
m_preserve = qPersistentNew<v8::Function>(v8::FunctionTemplate::New(Preserve)->GetFunction());
m_destroy = qPersistentNew<v8::Function>(v8::FunctionTemplate::New(Destroy)->GetFunction());
- v8::Local<v8::FunctionTemplate> ft = v8::FunctionTemplate::New();
+ v8::Handle<v8::FunctionTemplate> ft = v8::FunctionTemplate::New();
ft->InstanceTemplate()->SetFallbackPropertyHandler(Getter, Setter);
ft->InstanceTemplate()->SetHasExternalResource(true);
ft->InstanceTemplate()->MarkAsUseUserObjectComparison();
qPersistentDispose(m_constructor);
}
-v8::Local<v8::Object> QV8VariantWrapper::newVariant(const QVariant &value)
+v8::Handle<v8::Object> QV8VariantWrapper::newVariant(const QVariant &value)
{
bool scarceResource = value.type() == QVariant::Pixmap ||
value.type() == QVariant::Image;
// XXX NewInstance() should be optimized
- v8::Local<v8::Object> rv;
+ v8::Handle<v8::Object> rv;
QV8VariantResource *r = new QV8VariantResource(m_engine, value);
if (scarceResource) {
return static_cast<QV8VariantResource *>(r)->data;
}
-v8::Handle<v8::Value> QV8VariantWrapper::Getter(v8::Local<v8::String> /* property */,
+v8::Handle<v8::Value> QV8VariantWrapper::Getter(v8::Handle<v8::String> /* property */,
const v8::AccessorInfo & /* info */)
{
return v8::Handle<v8::Value>();
}
-v8::Handle<v8::Value> QV8VariantWrapper::Setter(v8::Local<v8::String> /* property */,
- v8::Local<v8::Value> value,
+v8::Handle<v8::Value> QV8VariantWrapper::Setter(v8::Handle<v8::String> /* property */,
+ v8::Handle<v8::Value> value,
const v8::AccessorInfo & /* info */)
{
return value;
}
-v8::Handle<v8::Value> QV8VariantWrapper::PreserveGetter(v8::Local<v8::String> property,
+v8::Handle<v8::Value> QV8VariantWrapper::PreserveGetter(v8::Handle<v8::String> property,
const v8::AccessorInfo &info)
{
Q_UNUSED(property);
return info.Data();
}
-v8::Handle<v8::Value> QV8VariantWrapper::DestroyGetter(v8::Local<v8::String> property,
+v8::Handle<v8::Value> QV8VariantWrapper::DestroyGetter(v8::Handle<v8::String> property,
const v8::AccessorInfo &info)
{
Q_UNUSED(property);
return info.Data();
}
-v8::Handle<v8::Value> QV8VariantWrapper::ToStringGetter(v8::Local<v8::String> property,
+v8::Handle<v8::Value> QV8VariantWrapper::ToStringGetter(v8::Handle<v8::String> property,
const v8::AccessorInfo &info)
{
Q_UNUSED(property);
return info.Data();
}
-v8::Handle<v8::Value> QV8VariantWrapper::ValueOfGetter(v8::Local<v8::String> property,
+v8::Handle<v8::Value> QV8VariantWrapper::ValueOfGetter(v8::Handle<v8::String> property,
const v8::AccessorInfo &info)
{
Q_UNUSED(property);
void init(QV8Engine *);
void destroy();
- v8::Local<v8::Object> newVariant(const QVariant &);
+ v8::Handle<v8::Object> newVariant(const QVariant &);
bool isVariant(v8::Handle<v8::Value>);
static QVariant toVariant(v8::Handle<v8::Object>);
static QVariant toVariant(QV8ObjectResource *);
QVariant &variantValue(v8::Handle<v8::Value>);
private:
- static v8::Handle<v8::Value> Getter(v8::Local<v8::String> property,
+ static v8::Handle<v8::Value> Getter(v8::Handle<v8::String> property,
const v8::AccessorInfo &info);
- static v8::Handle<v8::Value> Setter(v8::Local<v8::String> property,
- v8::Local<v8::Value> value,
+ static v8::Handle<v8::Value> Setter(v8::Handle<v8::String> property,
+ v8::Handle<v8::Value> value,
const v8::AccessorInfo &info);
- static v8::Handle<v8::Value> PreserveGetter(v8::Local<v8::String> property,
+ static v8::Handle<v8::Value> PreserveGetter(v8::Handle<v8::String> property,
const v8::AccessorInfo &info);
- static v8::Handle<v8::Value> DestroyGetter(v8::Local<v8::String> property,
+ static v8::Handle<v8::Value> DestroyGetter(v8::Handle<v8::String> property,
const v8::AccessorInfo &info);
- static v8::Handle<v8::Value> ToStringGetter(v8::Local<v8::String> property,
+ static v8::Handle<v8::Value> ToStringGetter(v8::Handle<v8::String> property,
const v8::AccessorInfo &info);
- static v8::Handle<v8::Value> ValueOfGetter(v8::Local<v8::String> property,
+ static v8::Handle<v8::Value> ValueOfGetter(v8::Handle<v8::String> property,
const v8::AccessorInfo &info);
static v8::Handle<v8::Value> Preserve(const v8::Arguments &args);
static v8::Handle<v8::Value> Destroy(const v8::Arguments &args);
} else if (v->IsRegExp()) {
v8::Handle<v8::RegExp> regexp = v8::Handle<v8::RegExp>::Cast(v);
quint32 flags = regexp->GetFlags();
- v8::Local<v8::String> source = regexp->GetSource();
+ v8::Handle<v8::String> source = regexp->GetSource();
int length = source->Length() + 1;
if (length > 0xFFFFFF) {
source->Write((uint16_t*)buffer);
} else if (v->IsObject() && !v->ToObject()->GetExternalResource()) {
v8::Handle<v8::Object> object = v->ToObject();
- v8::Local<v8::Array> properties = v8::Local<v8::Array>::New(v8::Value::fromV4Value(engine->getOwnPropertyNames(object->v4Value())));
+ v8::Handle<v8::Array> properties = engine->getOwnPropertyNames(object->v4Value());
quint32 length = properties->Length();
if (length > 0xFFFFFF) {
push(data, valueheader(WorkerUndefined));
push(data, valueheader(WorkerObject, length));
v8::TryCatch tc;
for (quint32 ii = 0; ii < length; ++ii) {
- v8::Local<v8::String> str = properties->Get(ii)->ToString();
+ v8::Handle<v8::String> str = properties->Get(ii)->ToString();
serialize(data, str, engine);
- v8::Local<v8::Value> val = object->Get(str);
+ v8::Handle<v8::Value> val = object->Get(str);
if (tc.HasCaught()) {
serialize(data, v8::Undefined(), engine);
tc.Reset();
case WorkerString:
{
quint32 size = headersize(header);
- v8::Local<v8::String> string = v8::String::New((uint16_t*)data, size - 1);
+ v8::Handle<v8::String> string = v8::String::New((uint16_t*)data, size - 1);
data += ALIGN(size * sizeof(uint16_t));
return string;
}
case WorkerArray:
{
quint32 size = headersize(header);
- v8::Local<v8::Array> array = v8::Array::New(size);
+ v8::Handle<v8::Array> array = v8::Array::New(size);
for (quint32 ii = 0; ii < size; ++ii) {
array->Set(ii, deserialize(data, engine));
}
case WorkerObject:
{
quint32 size = headersize(header);
- v8::Local<v8::Object> o = v8::Object::New();
+ v8::Handle<v8::Object> o = v8::Object::New();
for (quint32 ii = 0; ii < size; ++ii) {
v8::Handle<v8::Value> name = deserialize(data, engine);
v8::Handle<v8::Value> value = deserialize(data, engine);
{
quint32 flags = headersize(header);
quint32 length = popUint32(data);
- v8::Local<v8::String> source = v8::String::New((uint16_t*)data, length - 1);
+ v8::Handle<v8::String> source = v8::String::New((uint16_t*)data, length - 1);
data += ALIGN(length * sizeof(uint16_t));
return v8::RegExp::New(source, (v8::RegExp::Flags)flags);
}
quint32 length = headersize(header);
quint32 seqLength = length - 1;
int sequenceType = deserialize(data, engine)->Int32Value();
- v8::Local<v8::Array> array = v8::Array::New(seqLength);
+ v8::Handle<v8::Array> array = v8::Array::New(seqLength);
for (quint32 ii = 0; ii < seqLength; ++ii)
array->Set(ii, deserialize(data, engine));
QVariant seqVariant = engine->sequenceWrapper()->toVariant(array, sequenceType, &succeeded);
QQmlDelegateModelEngineData(QV8Engine *engine);
~QQmlDelegateModelEngineData();
- v8::Local<v8::Object> array(
+ v8::Handle<v8::Object> array(
QV8Engine *engine, const QVector<QQmlChangeSet::Remove> &changes);
- v8::Local<v8::Object> array(
+ v8::Handle<v8::Object> array(
QV8Engine *engine, const QVector<QQmlChangeSet::Insert> &changes);
- v8::Local<v8::Object> array(
+ v8::Handle<v8::Object> array(
QV8Engine *engine, const QVector<QQmlChangeSet::Change> &changes);
- inline v8::Local<v8::String> model() { return strings->Get(Model)->ToString(); }
- inline v8::Local<v8::String> groups() { return strings->Get(Groups)->ToString(); }
- inline v8::Local<v8::String> isUnresolved() { return strings->Get(IsUnresolved)->ToString(); }
- inline v8::Local<v8::String> itemsIndex() { return strings->Get(ItemsIndex)->ToString(); }
- inline v8::Local<v8::String> persistedItemsIndex() { return strings->Get(PersistedItemsIndex)->ToString(); }
- inline v8::Local<v8::String> inItems() { return strings->Get(InItems)->ToString(); }
- inline v8::Local<v8::String> inPersistedItems() { return strings->Get(InPersistedItems)->ToString(); }
+ inline v8::Handle<v8::String> model() { return strings->Get(Model)->ToString(); }
+ inline v8::Handle<v8::String> groups() { return strings->Get(Groups)->ToString(); }
+ inline v8::Handle<v8::String> isUnresolved() { return strings->Get(IsUnresolved)->ToString(); }
+ inline v8::Handle<v8::String> itemsIndex() { return strings->Get(ItemsIndex)->ToString(); }
+ inline v8::Handle<v8::String> persistedItemsIndex() { return strings->Get(PersistedItemsIndex)->ToString(); }
+ inline v8::Handle<v8::String> inItems() { return strings->Get(InItems)->ToString(); }
+ inline v8::Handle<v8::String> inPersistedItems() { return strings->Get(InPersistedItems)->ToString(); }
v8::Persistent<v8::Array> strings;
v8::Persistent<v8::Function> constructorChange;
d->emitChanges();
}
-template <typename T> v8::Local<v8::Array>
+template <typename T> v8::Handle<v8::Array>
QQmlDelegateModelPrivate::buildChangeList(const QVector<T> &changes)
{
- v8::Local<v8::Array> indexes = v8::Array::New(changes.count());
- v8::Local<v8::String> indexKey = v8::String::New("index");
- v8::Local<v8::String> countKey = v8::String::New("count");
- v8::Local<v8::String> moveIdKey = v8::String::New("moveId");
+ v8::Handle<v8::Array> indexes = v8::Array::New(changes.count());
+ v8::Handle<v8::String> indexKey = v8::String::New("index");
+ v8::Handle<v8::String> countKey = v8::String::New("count");
+ v8::Handle<v8::String> moveIdKey = v8::String::New("moveId");
for (int i = 0; i < changes.count(); ++i) {
- v8::Local<v8::Object> object = v8::Object::New();
+ v8::Handle<v8::Object> object = v8::Object::New();
object->Set(indexKey, v8::Integer::New(changes.at(i).index));
object->Set(countKey, v8::Integer::New(changes.at(i).count));
object->Set(moveIdKey, changes.at(i).moveId != -1 ? v8::Integer::New(changes.at(i).count) : v8::Undefined());
}
bool QQmlDelegateModelPrivate::insert(
- Compositor::insert_iterator &before, const v8::Local<v8::Object> &object, int groups)
+ Compositor::insert_iterator &before, const v8::Handle<v8::Object> &object, int groups)
{
if (!m_context->isValid())
return false;
if (!cacheItem)
return false;
- v8::Local<v8::Array> propertyNames = object->GetPropertyNames();
+ v8::Handle<v8::Array> propertyNames = object->GetPropertyNames();
for (uint i = 0; i < propertyNames->Length(); ++i) {
- v8::Local<v8::String> propertyName = propertyNames->Get(i)->ToString();
+ v8::Handle<v8::String> propertyName = propertyNames->Get(i)->ToString();
cacheItem->setValue(
propertyName->v4Value().toQString(),
m_cacheMetaType->v8Engine->toVariant(object->Get(propertyName)->v4Value(), QVariant::Invalid));
return groupFlags;
}
-int QQmlDelegateModelItemMetaType::parseGroups(const v8::Local<v8::Value> &groups) const
+int QQmlDelegateModelItemMetaType::parseGroups(const v8::Handle<v8::Value> &groups) const
{
int groupFlags = 0;
if (groups->IsString()) {
if (index != -1)
groupFlags |= 2 << index;
} else if (groups->IsArray()) {
- v8::Local<v8::Array> array = v8::Local<v8::Array>::Cast(groups);
+ v8::Handle<v8::Array> array = v8::Handle<v8::Array>::Cast(groups);
for (uint i = 0; i < array->Length(); ++i) {
const QString groupName = array->Get(i)->v4Value().toQString();
int index = groupNames.indexOf(groupName);
}
v8::Handle<v8::Value> QQmlDelegateModelItemMetaType::get_model(
- v8::Local<v8::String>, const v8::AccessorInfo &info)
+ v8::Handle<v8::String>, const v8::AccessorInfo &info)
{
QQmlDelegateModelItem *cacheItem = v8_resource_cast<QQmlDelegateModelItem>(info.This());
V8ASSERT_TYPE(cacheItem, "Not a valid VisualData object");
}
v8::Handle<v8::Value> QQmlDelegateModelItemMetaType::get_groups(
- v8::Local<v8::String>, const v8::AccessorInfo &info)
+ v8::Handle<v8::String>, const v8::AccessorInfo &info)
{
QQmlDelegateModelItem *cacheItem = v8_resource_cast<QQmlDelegateModelItem>(info.This());
V8ASSERT_TYPE(cacheItem, "Not a valid VisualData object");
}
void QQmlDelegateModelItemMetaType::set_groups(
- v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)
+ v8::Handle<v8::String>, v8::Handle<v8::Value> value, const v8::AccessorInfo &info)
{
QQmlDelegateModelItem *cacheItem = v8_resource_cast<QQmlDelegateModelItem>(info.This());
V8ASSERT_TYPE_SETTER(cacheItem, "Not a valid VisualData object");
}
v8::Handle<v8::Value> QQmlDelegateModelItemMetaType::get_member(
- v8::Local<v8::String>, const v8::AccessorInfo &info)
+ v8::Handle<v8::String>, const v8::AccessorInfo &info)
{
QQmlDelegateModelItem *cacheItem = v8_resource_cast<QQmlDelegateModelItem>(info.This());
V8ASSERT_TYPE(cacheItem, "Not a valid VisualData object");
}
void QQmlDelegateModelItemMetaType::set_member(
- v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)
+ v8::Handle<v8::String>, v8::Handle<v8::Value> value, const v8::AccessorInfo &info)
{
QQmlDelegateModelItem *cacheItem = v8_resource_cast<QQmlDelegateModelItem>(info.This());
V8ASSERT_TYPE_SETTER(cacheItem, "Not a valid VisualData object");
}
v8::Handle<v8::Value> QQmlDelegateModelItemMetaType::get_index(
- v8::Local<v8::String>, const v8::AccessorInfo &info)
+ v8::Handle<v8::String>, const v8::AccessorInfo &info)
{
QQmlDelegateModelItem *cacheItem = v8_resource_cast<QQmlDelegateModelItem>(info.This());
V8ASSERT_TYPE(cacheItem, "Not a valid VisualData object");
{
Q_Q(QQmlDelegateModelGroup);
if (isChangedConnected() && !changeSet.isEmpty()) {
- v8::Local<v8::Object> removed = engineData(engine)->array(engine, changeSet.removes());
- v8::Local<v8::Object> inserted = engineData(engine)->array(engine, changeSet.inserts());
+ v8::Handle<v8::Object> removed = engineData(engine)->array(engine, changeSet.removes());
+ v8::Handle<v8::Object> inserted = engineData(engine)->array(engine, changeSet.inserts());
emit q->changed(QQmlV4Handle::fromV8Handle(removed), QQmlV4Handle::fromV8Handle(inserted));
}
if (changeSet.difference() != 0)
if (model->m_cacheMetaType->constructor.IsEmpty())
model->m_cacheMetaType->initializeConstructor();
- v8::Local<v8::Object> handle = model->m_cacheMetaType->constructor->NewInstance();
+ v8::Handle<v8::Object> handle = model->m_cacheMetaType->constructor->NewInstance();
handle->SetExternalResource(cacheItem);
++cacheItem->scriptRef;
}
bool QQmlDelegateModelGroupPrivate::parseIndex(
- const v8::Local<v8::Value> &value, int *index, Compositor::Group *group) const
+ const v8::Handle<v8::Value> &value, int *index, Compositor::Group *group) const
{
if (value->IsInt32()) {
*index = value->Int32Value();
return true;
} else if (value->IsObject()) {
- v8::Local<v8::Object> object = value->ToObject();
+ v8::Handle<v8::Object> object = value->ToObject();
QQmlDelegateModelItem * const cacheItem = v8_resource_cast<QQmlDelegateModelItem>(object);
if (QQmlDelegateModelPrivate *model = cacheItem && cacheItem->metaType->model
? QQmlDelegateModelPrivate::get(cacheItem->metaType->model)
return;
int i = 0;
- v8::Local<v8::Value> v = (*args)[i];
+ v8::Handle<v8::Value> v = (*args)[i];
if (d->parseIndex(v, &index, &group)) {
if (index < 0 || index > model->m_compositor.count(group)) {
qmlInfo(this) << tr("insert: index out of range");
Compositor::Group group = d->group;
int i = 0;
- v8::Local<v8::Value> v = (*args)[i];
+ v8::Handle<v8::Value> v = (*args)[i];
if (d->parseIndex(v, &index, &group))
++i;
Compositor::Group fromGroup = d->group;
Compositor::Group toGroup = d->group;
- v8::Local<v8::Value> v = (*args)[0];
+ v8::Handle<v8::Value> v = (*args)[0];
if (d->parseIndex(v, &from, &fromGroup)) {
if (from < 0 || from >= model->m_compositor.count(fromGroup)) {
qmlInfo(this) << tr("resolve: from index out of range");
return;
int i = 0;
- v8::Local<v8::Value> v = (*args)[i];
+ v8::Handle<v8::Value> v = (*args)[i];
if (!d->parseIndex(v, &index, &group)) {
qmlInfo(this) << tr("remove: invalid index");
return;
return false;
int i = 0;
- v8::Local<v8::Value> v = (*args)[i];
+ v8::Handle<v8::Value> v = (*args)[i];
if (!parseIndex(v, index, group))
return false;
}
if (args->Length() > 2) {
- v8::Local<v8::Value> v = (*args)[2];
+ v8::Handle<v8::Value> v = (*args)[2];
if (v->IsInt32())
count = v->Int32Value();
}
//============================================================================
-v8::Handle<v8::Value> get_change_index(v8::Local<v8::String>, const v8::AccessorInfo &info)
+v8::Handle<v8::Value> get_change_index(v8::Handle<v8::String>, const v8::AccessorInfo &info)
{
return info.This()->GetInternalField(0);
}
-v8::Handle<v8::Value> get_change_count(v8::Local<v8::String>, const v8::AccessorInfo &info)
+v8::Handle<v8::Value> get_change_count(v8::Handle<v8::String>, const v8::AccessorInfo &info)
{
return info.This()->GetInternalField(1);
}
-v8::Handle<v8::Value> get_change_moveId(v8::Local<v8::String>, const v8::AccessorInfo &info)
+v8::Handle<v8::Value> get_change_moveId(v8::Handle<v8::String>, const v8::AccessorInfo &info)
{
return info.This()->GetInternalField(2);
}
const QQmlChangeSet::Change &change = array->at(index);
- v8::Local<v8::Object> object = engineData(array->engine)->constructorChange->NewInstance();
+ v8::Handle<v8::Object> object = engineData(array->engine)->constructorChange->NewInstance();
object->SetInternalField(0, v8::Int32::New(change.index));
object->SetInternalField(1, v8::Int32::New(change.count));
if (change.isMove())
return object;
}
- static v8::Handle<v8::Value> get_length(v8::Local<v8::String>, const v8::AccessorInfo &info)
+ static v8::Handle<v8::Value> get_length(v8::Handle<v8::String>, const v8::AccessorInfo &info)
{
QQmlDelegateModelGroupChangeArray *array = v8_resource_cast<QQmlDelegateModelGroupChangeArray>(info.This());
V8ASSERT_TYPE(array, "Not a valid change array");
return v8::Integer::New(array->count());
}
- static v8::Local<v8::Function> constructor()
+ static v8::Handle<v8::Function> constructor()
{
- v8::Local<v8::FunctionTemplate> changeArray = v8::FunctionTemplate::New();
+ v8::Handle<v8::FunctionTemplate> changeArray = v8::FunctionTemplate::New();
changeArray->InstanceTemplate()->SetHasExternalResource(true);
changeArray->InstanceTemplate()->SetIndexedPropertyHandler(get_change);
changeArray->InstanceTemplate()->SetAccessor(v8::String::New("length"), get_length);
strings->Set(InItems, v8::String::New("inItems"));
strings->Set(InPersistedItems, v8::String::New("inPersistedItems"));
- v8::Local<v8::FunctionTemplate> change = v8::FunctionTemplate::New();
+ v8::Handle<v8::FunctionTemplate> change = v8::FunctionTemplate::New();
change->InstanceTemplate()->SetAccessor(v8::String::New("index"), get_change_index);
change->InstanceTemplate()->SetAccessor(v8::String::New("count"), get_change_count);
change->InstanceTemplate()->SetAccessor(v8::String::New("moveId"), get_change_moveId);
qPersistentDispose(constructorChangeArray);
}
-v8::Local<v8::Object> QQmlDelegateModelEngineData::array(
+v8::Handle<v8::Object> QQmlDelegateModelEngineData::array(
QV8Engine *engine, const QVector<QQmlChangeSet::Remove> &changes)
{
- v8::Local<v8::Object> array = constructorChangeArray->NewInstance();
+ v8::Handle<v8::Object> array = constructorChangeArray->NewInstance();
array->SetExternalResource(new QQmlDelegateModelGroupRemoveArray(engine, changes));
return array;
}
-v8::Local<v8::Object> QQmlDelegateModelEngineData::array(
+v8::Handle<v8::Object> QQmlDelegateModelEngineData::array(
QV8Engine *engine, const QVector<QQmlChangeSet::Insert> &changes)
{
- v8::Local<v8::Object> array = constructorChangeArray->NewInstance();
+ v8::Handle<v8::Object> array = constructorChangeArray->NewInstance();
array->SetExternalResource(new QQmlDelegateModelGroupInsertArray(engine, changes));
return array;
}
void initializeConstructor();
int parseGroups(const QStringList &groupNames) const;
- int parseGroups(const v8::Local<v8::Value> &groupNames) const;
+ int parseGroups(const v8::Handle<v8::Value> &groupNames) const;
static void release_index(v8::Persistent<v8::Value> object, void *parameter);
static void release_model(v8::Persistent<v8::Value> object, void *parameter);
- static v8::Handle<v8::Value> get_model(v8::Local<v8::String>, const v8::AccessorInfo &info);
- static v8::Handle<v8::Value> get_groups(v8::Local<v8::String>, const v8::AccessorInfo &info);
+ static v8::Handle<v8::Value> get_model(v8::Handle<v8::String>, const v8::AccessorInfo &info);
+ static v8::Handle<v8::Value> get_groups(v8::Handle<v8::String>, const v8::AccessorInfo &info);
static void set_groups(
- v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info);
- static v8::Handle<v8::Value> get_member(v8::Local<v8::String>, const v8::AccessorInfo &info);
+ v8::Handle<v8::String>, v8::Handle<v8::Value> value, const v8::AccessorInfo &info);
+ static v8::Handle<v8::Value> get_member(v8::Handle<v8::String>, const v8::AccessorInfo &info);
static void set_member(
- v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info);
- static v8::Handle<v8::Value> get_index(v8::Local<v8::String>, const v8::AccessorInfo &info);
+ v8::Handle<v8::String>, v8::Handle<v8::Value> value, const v8::AccessorInfo &info);
+ static v8::Handle<v8::Value> get_index(v8::Handle<v8::String>, const v8::AccessorInfo &info);
QQmlGuard<QQmlDelegateModel> model;
const int groupCount;
void initPackage(int index, QQuickPackage *package);
void destroyingPackage(QQuickPackage *package);
- bool parseIndex(const v8::Local<v8::Value> &value, int *index, Compositor::Group *group) const;
+ bool parseIndex(const v8::Handle<v8::Value> &value, int *index, Compositor::Group *group) const;
bool parseGroupArgs(
QQmlV8Function *args, Compositor::Group *group, int *index, int *count, int *groups) const;
void itemsMoved(
const QVector<Compositor::Remove> &removes, const QVector<Compositor::Insert> &inserts);
void itemsChanged(const QVector<Compositor::Change> &changes);
- template <typename T> static v8::Local<v8::Array> buildChangeList(const QVector<T> &changes);
+ template <typename T> static v8::Handle<v8::Array> buildChangeList(const QVector<T> &changes);
void emitChanges();
void emitModelUpdated(const QQmlChangeSet &changeSet, bool reset);
- bool insert(Compositor::insert_iterator &before, const v8::Local<v8::Object> &object, int groups);
+ bool insert(Compositor::insert_iterator &before, const v8::Handle<v8::Object> &object, int groups);
static void group_append(QQmlListProperty<QQmlDelegateModelGroup> *property, QQmlDelegateModelGroup *group);
static int group_count(QQmlListProperty<QQmlDelegateModelGroup> *property);
{
ListElement *e = elements[elementIndex];
- v8::Local<v8::Array> propertyNames = object->GetPropertyNames();
+ v8::Handle<v8::Array> propertyNames = object->GetPropertyNames();
int propertyCount = propertyNames->Length();
for (int i=0 ; i < propertyCount ; ++i) {
- v8::Local<v8::String> propertyName = propertyNames->Get(i)->ToString();
- v8::Local<v8::Value> propertyValue = object->Get(propertyName);
+ v8::Handle<v8::String> propertyName = propertyNames->Get(i)->ToString();
+ v8::Handle<v8::Value> propertyValue = object->Get(propertyName);
// Check if this key exists yet
int roleIndex = -1;
{
ListElement *e = elements[elementIndex];
- v8::Local<v8::Array> propertyNames = object->GetPropertyNames();
+ v8::Handle<v8::Array> propertyNames = object->GetPropertyNames();
int propertyCount = propertyNames->Length();
for (int i=0 ; i < propertyCount ; ++i) {
- v8::Local<v8::String> propertyName = propertyNames->Get(i)->ToString();
- v8::Local<v8::Value> propertyValue = object->Get(propertyName);
+ v8::Handle<v8::String> propertyName = propertyNames->Get(i)->ToString();
+ v8::Handle<v8::Value> propertyValue = object->Get(propertyName);
// Add the value now
if (propertyValue->IsString()) {
QQuickWorkerScriptEnginePrivate *p;
- v8::Local<v8::Function> sendFunction(int id);
+ v8::Handle<v8::Function> sendFunction(int id);
void callOnMessage(v8::Handle<v8::Object> object, v8::Handle<v8::Value> arg);
private:
v8::Persistent<v8::Function> onmessage;
"})"
{
- v8::Local<v8::Script> onmessagescript = v8::Script::New(v8::String::New(CALL_ONMESSAGE_SCRIPT));
+ v8::Handle<v8::Script> onmessagescript = v8::Script::New(v8::String::New(CALL_ONMESSAGE_SCRIPT));
onmessage = qPersistentNew<v8::Function>(v8::Handle<v8::Function>::Cast(onmessagescript->Run()));
}
{
- v8::Local<v8::Script> createsendscript = v8::Script::New(v8::String::New(SEND_MESSAGE_CREATE_SCRIPT));
- v8::Local<v8::Function> createsendconstructor = v8::Local<v8::Function>::Cast(createsendscript->Run());
+ v8::Handle<v8::Script> createsendscript = v8::Script::New(v8::String::New(SEND_MESSAGE_CREATE_SCRIPT));
+ v8::Handle<v8::Function> createsendconstructor = v8::Handle<v8::Function>::Cast(createsendscript->Run());
v8::Handle<v8::Value> args[] = {
V8FUNCTION(QQuickWorkerScriptEnginePrivate::sendMessage, this)
};
- v8::Local<v8::Value> createsendvalue = createsendconstructor->Call(v8::Value::fromV4Value(global()), 1, args);
+ v8::Handle<v8::Value> createsendvalue = createsendconstructor->Call(v8::Value::fromV4Value(global()), 1, args);
createsend = qPersistentNew<v8::Function>(v8::Handle<v8::Function>::Cast(createsendvalue));
}
}
// Requires handle and context scope
-v8::Local<v8::Function> QQuickWorkerScriptEnginePrivate::WorkerEngine::sendFunction(int id)
+v8::Handle<v8::Function> QQuickWorkerScriptEnginePrivate::WorkerEngine::sendFunction(int id)
{
v8::Handle<v8::Value> args[] = { v8::Integer::New(id) };
- return v8::Local<v8::Function>::Cast(createsend->Call(v8::Value::fromV4Value(global()), 1, args));
+ return v8::Handle<v8::Function>::Cast(createsend->Call(v8::Value::fromV4Value(global()), 1, args));
}
// Requires handle and context scope
workerEngine->contextWrapper()->setReadOnly(script->object, false);
- v8::Local<v8::Object> api = v8::Object::New();
+ v8::Handle<v8::Object> api = v8::Object::New();
api->Set(v8::String::New("sendMessage"), workerEngine->sendFunction(script->id));
script->object->Set(v8::String::New("WorkerScript"), api);
// workerEngine->baseUrl = url;
v8::TryCatch tc;
- v8::Local<v8::Script> program = workerEngine->qmlModeCompile(sourceCode, url.toString());
+ v8::Handle<v8::Script> program = workerEngine->qmlModeCompile(sourceCode, url.toString());
if (!tc.HasCaught())
program->Run(activation);
QQmlAdaptorModelEngineData(QV8Engine *engine);
~QQmlAdaptorModelEngineData();
- v8::Local<v8::String> index() { return strings->Get(Index)->ToString(); }
- v8::Local<v8::String> modelData() { return strings->Get(ModelData)->ToString(); }
- v8::Local<v8::String> hasModelChildren() { return strings->Get(HasModelChildren)->ToString(); }
+ v8::Handle<v8::String> index() { return strings->Get(Index)->ToString(); }
+ v8::Handle<v8::String> modelData() { return strings->Get(ModelData)->ToString(); }
+ v8::Handle<v8::String> hasModelChildren() { return strings->Get(HasModelChildren)->ToString(); }
v8::Persistent<v8::Function> constructorListItem;
v8::Persistent<v8::Array> strings;
V8_DEFINE_EXTENSION(QQmlAdaptorModelEngineData, engineData)
-static v8::Handle<v8::Value> get_index(v8::Local<v8::String>, const v8::AccessorInfo &info)
+static v8::Handle<v8::Value> get_index(v8::Handle<v8::String>, const v8::AccessorInfo &info)
{
QQmlDelegateModelItem *data = v8_resource_cast<QQmlDelegateModelItem>(info.This());
V8ASSERT_TYPE(data, "Not a valid VisualData object");
void setValue(const QString &role, const QVariant &value);
bool resolveIndex(const QQmlAdaptorModel &model, int idx);
- static v8::Handle<v8::Value> get_property(v8::Local<v8::String>, const v8::AccessorInfo &info);
+ static v8::Handle<v8::Value> get_property(v8::Handle<v8::String>, const v8::AccessorInfo &info);
static void set_property(
- v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info);
+ v8::Handle<v8::String>, v8::Handle<v8::Value> value, const v8::AccessorInfo &info);
VDMModelDelegateDataType *type;
QVector<QVariant> cachedData;
}
v8::Handle<v8::Value> QQmlDMCachedModelData::get_property(
- v8::Local<v8::String>, const v8::AccessorInfo &info)
+ v8::Handle<v8::String>, const v8::AccessorInfo &info)
{
QQmlDelegateModelItem *data = v8_resource_cast<QQmlDelegateModelItem>(info.This());
V8ASSERT_TYPE(data, "Not a valid VisualData object");
}
void QQmlDMCachedModelData::set_property(
- v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)
+ v8::Handle<v8::String>, v8::Handle<v8::Value> value, const v8::AccessorInfo &info)
{
QQmlDelegateModelItem *data = v8_resource_cast<QQmlDelegateModelItem>(info.This());
V8ASSERT_TYPE_SETTER(data, "Not a valid VisualData object");
type->initializeConstructor(data);
type->constructor->SetAccessor(data->hasModelChildren(), get_hasModelChildren);
}
- v8::Local<v8::Object> data = type->constructor->NewInstance();
+ v8::Handle<v8::Object> data = type->constructor->NewInstance();
data->SetExternalResource(this);
++scriptRef;
return data;
}
- static v8::Handle<v8::Value> get_hasModelChildren(v8::Local<v8::String>, const v8::AccessorInfo &info)
+ static v8::Handle<v8::Value> get_hasModelChildren(v8::Handle<v8::String>, const v8::AccessorInfo &info)
{
QQmlDelegateModelItem *data = v8_resource_cast<QQmlDelegateModelItem>(info.This());
V8ASSERT_TYPE(data, "Not a valid VisualData object");
}
}
- static v8::Handle<v8::Value> get_modelData(v8::Local<v8::String>, const v8::AccessorInfo &info)
+ static v8::Handle<v8::Value> get_modelData(v8::Handle<v8::String>, const v8::AccessorInfo &info)
{
QQmlDelegateModelItem *data = v8_resource_cast<QQmlDelegateModelItem>(info.This());
V8ASSERT_TYPE(data, "Not a valid VisualData object");
return data->engine->fromVariant(static_cast<QQmlDMListAccessorData *>(data)->cachedData);
}
- static void set_modelData(v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)
+ static void set_modelData(v8::Handle<v8::String>, v8::Handle<v8::Value> value, const v8::AccessorInfo &info)
{
QQmlDelegateModelItem *data = v8_resource_cast<QQmlDelegateModelItem>(info.This());
V8ASSERT_TYPE_SETTER(data, "Not a valid VisualData object");
v8::Handle<v8::Value> get()
{
- v8::Local<v8::Object> data = engineData(engine)->constructorListItem->NewInstance();
+ v8::Handle<v8::Object> data = engineData(engine)->constructorListItem->NewInstance();
data->SetExternalResource(this);
++scriptRef;
return data;
strings->Set(ModelData, v8::String::New("modelData"));
strings->Set(HasModelChildren, v8::String::New("hasModelChildren"));
- v8::Local<v8::FunctionTemplate> listItem = v8::FunctionTemplate::New();
+ v8::Handle<v8::FunctionTemplate> listItem = v8::FunctionTemplate::New();
listItem->InstanceTemplate()->SetHasExternalResource(true);
listItem->InstanceTemplate()->SetAccessor(index(), get_index);
listItem->InstanceTemplate()->SetAccessor(
if (args->Length() < 1)
args->returnValue(v8::Null());
- v8::Local<v8::Value> value = (*args)[0];
+ v8::Handle<v8::Value> value = (*args)[0];
QString result;
QV8Engine *engine = args->engine();
result = QLatin1String("Object");
}
} else {
- v8::Local<v8::String> jsstr = value->ToString();
+ v8::Handle<v8::String> jsstr = value->ToString();
QString tmp = jsstr->v4Value().toQString();
if (value->IsArray())
result.append(QString::fromLatin1("[%1]").arg(tmp));
V8THROW_ERROR_SETTER("Not a Context2D object");
#define qClamp(val, min, max) qMin(qMax(val, min), max)
#define CHECK_RGBA(c) (c == '-' || c == '.' || (c >=0 && c <= 9))
-QColor qt_color_from_string(v8::Local<v8::Value> name)
+QColor qt_color_from_string(v8::Handle<v8::Value> name)
{
v8::String::AsciiValue str(name);
}
-static v8::Local<v8::Object> qt_create_image_data(qreal w, qreal h, QV8Engine* engine, const QImage& image)
+static v8::Handle<v8::Object> qt_create_image_data(qreal w, qreal h, QV8Engine* engine, const QImage& image)
{
QQuickContext2DEngineData *ed = engineData(engine);
- v8::Local<v8::Object> imageData = ed->constructorImageData->NewInstance();
+ v8::Handle<v8::Object> imageData = ed->constructorImageData->NewInstance();
QV8Context2DPixelArrayResource *r = new QV8Context2DPixelArrayResource(engine);
if (image.isNull()) {
r->image = QImage(w, h, QImage::Format_ARGB32);
Q_ASSERT(image.width() == w && image.height() == h);
r->image = image.format() == QImage::Format_ARGB32 ? image : image.convertToFormat(QImage::Format_ARGB32);
}
- v8::Local<v8::Object> pixelData = ed->constructorPixelArray->NewInstance();
+ v8::Handle<v8::Object> pixelData = ed->constructorPixelArray->NewInstance();
pixelData->SetExternalResource(r);
imageData->SetInternalField(0, pixelData);
This property is read only.
*/
-static v8::Handle<v8::Value> ctx2d_canvas(v8::Local<v8::String>, const v8::AccessorInfo &info)
+static v8::Handle<v8::Value> ctx2d_canvas(v8::Handle<v8::String>, const v8::AccessorInfo &info)
{
QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
CHECK_CONTEXT(r)
The value must be in the range from 0.0 (fully transparent) to 1.0 (fully opque).
The default value is 1.0.
*/
-static v8::Handle<v8::Value> ctx2d_globalAlpha(v8::Local<v8::String>, const v8::AccessorInfo &info)
+static v8::Handle<v8::Value> ctx2d_globalAlpha(v8::Handle<v8::String>, const v8::AccessorInfo &info)
{
QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
CHECK_CONTEXT(r)
return v8::Number::New(r->context->state.globalAlpha);
}
-static void ctx2d_globalAlpha_set(v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)
+static void ctx2d_globalAlpha_set(v8::Handle<v8::String>, v8::Handle<v8::Value> value, const v8::AccessorInfo &info)
{
QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
CHECK_CONTEXT_SETTER(r)
extension composition modes are provided as "vendorName-operationName" syntax, for example: QPainter::CompositionMode_Exclusion is provided as
"qt-exclusion".
*/
-static v8::Handle<v8::Value> ctx2d_globalCompositeOperation(v8::Local<v8::String>, const v8::AccessorInfo &info)
+static v8::Handle<v8::Value> ctx2d_globalCompositeOperation(v8::Handle<v8::String>, const v8::AccessorInfo &info)
{
QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
CHECK_CONTEXT(r)
return engine->toString(qt_composite_mode_to_string(r->context->state.globalCompositeOperation));
}
-static void ctx2d_globalCompositeOperation_set(v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)
+static void ctx2d_globalCompositeOperation_set(v8::Handle<v8::String>, v8::Handle<v8::Value> value, const v8::AccessorInfo &info)
{
QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
CHECK_CONTEXT_SETTER(r)
\sa createPattern()
\sa strokeStyle
*/
-static v8::Handle<v8::Value> ctx2d_fillStyle(v8::Local<v8::String>, const v8::AccessorInfo &info)
+static v8::Handle<v8::Value> ctx2d_fillStyle(v8::Handle<v8::String>, const v8::AccessorInfo &info)
{
QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
CHECK_CONTEXT(r)
return r->context->m_fillStyle;
}
-static void ctx2d_fillStyle_set(v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)
+static void ctx2d_fillStyle_set(v8::Handle<v8::String>, v8::Handle<v8::Value> value, const v8::AccessorInfo &info)
{
QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
CHECK_CONTEXT_SETTER(r)
\sa fillStyle
*/
-static v8::Handle<v8::Value> ctx2d_fillRule(v8::Local<v8::String>, const v8::AccessorInfo &info)
+static v8::Handle<v8::Value> ctx2d_fillRule(v8::Handle<v8::String>, const v8::AccessorInfo &info)
{
QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
CHECK_CONTEXT(r)
return engine->fromVariant(r->context->state.fillRule);
}
-static void ctx2d_fillRule_set(v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)
+static void ctx2d_fillRule_set(v8::Handle<v8::String>, v8::Handle<v8::Value> value, const v8::AccessorInfo &info)
{
QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
CHECK_CONTEXT_SETTER(r)
\sa createPattern()
\sa fillStyle
*/
-v8::Handle<v8::Value> ctx2d_strokeStyle(v8::Local<v8::String>, const v8::AccessorInfo &info)
+v8::Handle<v8::Value> ctx2d_strokeStyle(v8::Handle<v8::String>, const v8::AccessorInfo &info)
{
QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
CHECK_CONTEXT(r)
return r->context->m_strokeStyle;
}
-static void ctx2d_strokeStyle_set(v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)
+static void ctx2d_strokeStyle_set(v8::Handle<v8::String>, v8::Handle<v8::Value> value, const v8::AccessorInfo &info)
{
QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
CHECK_CONTEXT_SETTER(r)
if (args.Length() == 4) {
QQuickContext2DEngineData *ed = engineData(engine);
- v8::Local<v8::Object> gradient = ed->constructorGradient->NewInstance();
+ v8::Handle<v8::Object> gradient = ed->constructorGradient->NewInstance();
QV8Context2DStyleResource *r = new QV8Context2DStyleResource(engine);
qreal x0 = args[0]->NumberValue();
qreal y0 = args[1]->NumberValue();
if (args.Length() == 6) {
QQuickContext2DEngineData *ed = engineData(engine);
- v8::Local<v8::Object> gradient = ed->constructorGradient->NewInstance();
+ v8::Handle<v8::Object> gradient = ed->constructorGradient->NewInstance();
QV8Context2DStyleResource *r = new QV8Context2DStyleResource(engine);
qreal x0 = args[0]->NumberValue();
if (args.Length() == 6) {
QQuickContext2DEngineData *ed = engineData(engine);
- v8::Local<v8::Object> gradient = ed->constructorGradient->NewInstance();
+ v8::Handle<v8::Object> gradient = ed->constructorGradient->NewInstance();
QV8Context2DStyleResource *r = new QV8Context2DStyleResource(engine);
qreal x = args[0]->NumberValue();
}
}
- v8::Local<v8::Object> pattern = ed->constructorPattern->NewInstance();
+ v8::Handle<v8::Object> pattern = ed->constructorPattern->NewInstance();
pattern->SetExternalResource(styleResouce);
return pattern;
\endlist
Other values are ignored.
*/
-v8::Handle<v8::Value> ctx2d_lineCap(v8::Local<v8::String>, const v8::AccessorInfo &info)
+v8::Handle<v8::Value> ctx2d_lineCap(v8::Handle<v8::String>, const v8::AccessorInfo &info)
{
QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
CHECK_CONTEXT(r)
return engine->toString(QLatin1String("butt"));;
}
-static void ctx2d_lineCap_set(v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)
+static void ctx2d_lineCap_set(v8::Handle<v8::String>, v8::Handle<v8::Value> value, const v8::AccessorInfo &info)
{
QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
CHECK_CONTEXT_SETTER(r)
\endlist
Other values are ignored.
*/
-v8::Handle<v8::Value> ctx2d_lineJoin(v8::Local<v8::String>, const v8::AccessorInfo &info)
+v8::Handle<v8::Value> ctx2d_lineJoin(v8::Handle<v8::String>, const v8::AccessorInfo &info)
{
QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
CHECK_CONTEXT(r)
return engine->toString(QLatin1String("miter"));
}
-static void ctx2d_lineJoin_set(v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)
+static void ctx2d_lineJoin_set(v8::Handle<v8::String>, v8::Handle<v8::Value> value, const v8::AccessorInfo &info)
{
QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
CHECK_CONTEXT_SETTER(r)
\qmlproperty real QtQuick2::Context2D::lineWidth
Holds the current line width. Values that are not finite values greater than zero are ignored.
*/
-v8::Handle<v8::Value> ctx2d_lineWidth(v8::Local<v8::String>, const v8::AccessorInfo &info)
+v8::Handle<v8::Value> ctx2d_lineWidth(v8::Handle<v8::String>, const v8::AccessorInfo &info)
{
QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
CHECK_CONTEXT(r)
return v8::Number::New(r->context->state.lineWidth);
}
-static void ctx2d_lineWidth_set(v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)
+static void ctx2d_lineWidth_set(v8::Handle<v8::String>, v8::Handle<v8::Value> value, const v8::AccessorInfo &info)
{
QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
CHECK_CONTEXT_SETTER(r)
Holds the current miter limit ratio.
The default miter limit value is 10.0.
*/
-v8::Handle<v8::Value> ctx2d_miterLimit(v8::Local<v8::String>, const v8::AccessorInfo &info)
+v8::Handle<v8::Value> ctx2d_miterLimit(v8::Handle<v8::String>, const v8::AccessorInfo &info)
{
QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
CHECK_CONTEXT(r)
return v8::Number::New(r->context->state.miterLimit);
}
-static void ctx2d_miterLimit_set(v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)
+static void ctx2d_miterLimit_set(v8::Handle<v8::String>, v8::Handle<v8::Value> value, const v8::AccessorInfo &info)
{
QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
CHECK_CONTEXT_SETTER(r)
\qmlproperty real QtQuick2::Context2D::shadowBlur
Holds the current level of blur applied to shadows
*/
-v8::Handle<v8::Value> ctx2d_shadowBlur(v8::Local<v8::String>, const v8::AccessorInfo &info)
+v8::Handle<v8::Value> ctx2d_shadowBlur(v8::Handle<v8::String>, const v8::AccessorInfo &info)
{
QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
CHECK_CONTEXT(r)
return v8::Number::New(r->context->state.shadowBlur);
}
-static void ctx2d_shadowBlur_set(v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)
+static void ctx2d_shadowBlur_set(v8::Handle<v8::String>, v8::Handle<v8::Value> value, const v8::AccessorInfo &info)
{
QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
CHECK_CONTEXT_SETTER(r)
\qmlproperty string QtQuick2::Context2D::shadowColor
Holds the current shadow color.
*/
-v8::Handle<v8::Value> ctx2d_shadowColor(v8::Local<v8::String>, const v8::AccessorInfo &info)
+v8::Handle<v8::Value> ctx2d_shadowColor(v8::Handle<v8::String>, const v8::AccessorInfo &info)
{
QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
CHECK_CONTEXT(r)
return engine->toString(r->context->state.shadowColor.name());
}
-static void ctx2d_shadowColor_set(v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)
+static void ctx2d_shadowColor_set(v8::Handle<v8::String>, v8::Handle<v8::Value> value, const v8::AccessorInfo &info)
{
QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
CHECK_CONTEXT_SETTER(r)
\sa shadowOffsetY
*/
-v8::Handle<v8::Value> ctx2d_shadowOffsetX(v8::Local<v8::String>, const v8::AccessorInfo &info)
+v8::Handle<v8::Value> ctx2d_shadowOffsetX(v8::Handle<v8::String>, const v8::AccessorInfo &info)
{
QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
CHECK_CONTEXT(r)
return v8::Number::New(r->context->state.shadowOffsetX);
}
-static void ctx2d_shadowOffsetX_set(v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)
+static void ctx2d_shadowOffsetX_set(v8::Handle<v8::String>, v8::Handle<v8::Value> value, const v8::AccessorInfo &info)
{
QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
CHECK_CONTEXT_SETTER(r)
\sa shadowOffsetX
*/
-v8::Handle<v8::Value> ctx2d_shadowOffsetY(v8::Local<v8::String>, const v8::AccessorInfo &info)
+v8::Handle<v8::Value> ctx2d_shadowOffsetY(v8::Handle<v8::String>, const v8::AccessorInfo &info)
{
QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
CHECK_CONTEXT(r)
return v8::Number::New(r->context->state.shadowOffsetY);
}
-static void ctx2d_shadowOffsetY_set(v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)
+static void ctx2d_shadowOffsetY_set(v8::Handle<v8::String>, v8::Handle<v8::Value> value, const v8::AccessorInfo &info)
{
QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
CHECK_CONTEXT_SETTER(r)
}
}
-v8::Handle<v8::Value> ctx2d_path(v8::Local<v8::String>, const v8::AccessorInfo &info)
+v8::Handle<v8::Value> ctx2d_path(v8::Handle<v8::String>, const v8::AccessorInfo &info)
{
QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
CHECK_CONTEXT(r)
return r->context->m_v8path;
}
-static void ctx2d_path_set(v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)
+static void ctx2d_path_set(v8::Handle<v8::String>, v8::Handle<v8::Value> value, const v8::AccessorInfo &info)
{
QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
CHECK_CONTEXT_SETTER(r)
The default font value is "10px sans-serif".
See \l {http://www.w3.org/TR/2dcontext/#dom-context-2d-font}{w3C 2d context standard for font}
*/
-v8::Handle<v8::Value> ctx2d_font(v8::Local<v8::String>, const v8::AccessorInfo &info)
+v8::Handle<v8::Value> ctx2d_font(v8::Handle<v8::String>, const v8::AccessorInfo &info)
{
QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
CHECK_CONTEXT(r)
return engine->toString(r->context->state.font.toString());
}
-static void ctx2d_font_set(v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)
+static void ctx2d_font_set(v8::Handle<v8::String>, v8::Handle<v8::Value> value, const v8::AccessorInfo &info)
{
QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
CHECK_CONTEXT_SETTER(r)
\endlist
Other values are ignored. The default value is "start".
*/
-v8::Handle<v8::Value> ctx2d_textAlign(v8::Local<v8::String>, const v8::AccessorInfo &info)
+v8::Handle<v8::Value> ctx2d_textAlign(v8::Handle<v8::String>, const v8::AccessorInfo &info)
{
QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
CHECK_CONTEXT(r)
return engine->toString(QLatin1String("start"));
}
-static void ctx2d_textAlign_set(v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)
+static void ctx2d_textAlign_set(v8::Handle<v8::String>, v8::Handle<v8::Value> value, const v8::AccessorInfo &info)
{
QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
CHECK_CONTEXT_SETTER(r)
\endlist
Other values are ignored. The default value is "alphabetic".
*/
-v8::Handle<v8::Value> ctx2d_textBaseline(v8::Local<v8::String>, const v8::AccessorInfo &info)
+v8::Handle<v8::Value> ctx2d_textBaseline(v8::Handle<v8::String>, const v8::AccessorInfo &info)
{
QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
CHECK_CONTEXT(r)
return engine->toString(QLatin1String("alphabetic"));
}
-static void ctx2d_textBaseline_set(v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)
+static void ctx2d_textBaseline_set(v8::Handle<v8::String>, v8::Handle<v8::Value> value, const v8::AccessorInfo &info)
{
QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
CHECK_CONTEXT_SETTER(r)
if (args.Length() == 1) {
QFontMetrics fm(r->context->state.font);
uint width = fm.width(args[0]->v4Value().toQString());
- v8::Local<v8::Object> tm = v8::Object::New();
+ v8::Handle<v8::Object> tm = v8::Object::New();
tm->Set(v8::String::New("width"), v8::Number::New(width));
return tm;
}
\qmlproperty int QtQuick2::CanvasImageData::width
Holds the actual width dimension of the data in the ImageData object, in device pixels.
*/
-v8::Handle<v8::Value> ctx2d_imageData_width(v8::Local<v8::String>, const v8::AccessorInfo &args)
+v8::Handle<v8::Value> ctx2d_imageData_width(v8::Handle<v8::String>, const v8::AccessorInfo &args)
{
QV8Context2DPixelArrayResource *r = v8_resource_cast<QV8Context2DPixelArrayResource>(args.This()->GetInternalField(0)->ToObject());
if (!r)
\qmlproperty int QtQuick2::CanvasImageData::height
Holds the actual height dimension of the data in the ImageData object, in device pixels.
*/
-v8::Handle<v8::Value> ctx2d_imageData_height(v8::Local<v8::String>, const v8::AccessorInfo &args)
+v8::Handle<v8::Value> ctx2d_imageData_height(v8::Handle<v8::String>, const v8::AccessorInfo &args)
{
QV8Context2DPixelArrayResource *r = v8_resource_cast<QV8Context2DPixelArrayResource>(args.This()->GetInternalField(0)->ToObject());
if (!r)
\qmlproperty object QtQuick2::CanvasImageData::data
Holds the one-dimensional array containing the data in RGBA order, as integers in the range 0 to 255.
*/
-v8::Handle<v8::Value> ctx2d_imageData_data(v8::Local<v8::String>, const v8::AccessorInfo &args)
+v8::Handle<v8::Value> ctx2d_imageData_data(v8::Handle<v8::String>, const v8::AccessorInfo &args)
{
return args.This()->GetInternalField(0);
}
The length attribute of a CanvasPixelArray object must return this h×w×4 number value.
This property is read only.
*/
-v8::Handle<v8::Value> ctx2d_pixelArray_length(v8::Local<v8::String>, const v8::AccessorInfo &args)
+v8::Handle<v8::Value> ctx2d_pixelArray_length(v8::Handle<v8::String>, const v8::AccessorInfo &args)
{
QV8Context2DPixelArrayResource *r = v8_resource_cast<QV8Context2DPixelArrayResource>(args.This());
if (!r || r->image.isNull()) return v8::Undefined();
return v8::Undefined();
}
-v8::Handle<v8::Value> ctx2d_pixelArray_indexed_set(uint32_t index, v8::Local<v8::Value> value, const v8::AccessorInfo& info)
+v8::Handle<v8::Value> ctx2d_pixelArray_indexed_set(uint32_t index, v8::Handle<v8::Value> value, const v8::AccessorInfo& info)
{
QV8Context2DPixelArrayResource *r = v8_resource_cast<QV8Context2DPixelArrayResource>(info.This());
if (args.Length() == 1) {
if (args[0]->IsObject()) {
- v8::Local<v8::Object> imgData = args[0]->ToObject();
+ v8::Handle<v8::Object> imgData = args[0]->ToObject();
QV8Context2DPixelArrayResource *pa = v8_resource_cast<QV8Context2DPixelArrayResource>(imgData->GetInternalField(0)->ToObject());
if (pa) {
qreal w = imgData->Get(v8::String::New("width"))->NumberValue();
V8THROW_DOM(DOMEXCEPTION_INDEX_SIZE_ERR, "getImageData(): Invalid arguments");
QImage image = r->context->canvas()->toImage(QRectF(x, y, w, h));
- v8::Local<v8::Object> imageData = qt_create_image_data(w, h, engine, image);
+ v8::Handle<v8::Object> imageData = qt_create_image_data(w, h, engine, image);
return imageData;
}
if (!qIsFinite(dx) || !qIsFinite(dy))
V8THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "putImageData() : Invalid arguments");
- v8::Local<v8::Object> imageData = args[0]->ToObject();
+ v8::Handle<v8::Object> imageData = args[0]->ToObject();
QV8Context2DPixelArrayResource *pixelArray = v8_resource_cast<QV8Context2DPixelArrayResource>(imageData->Get(v8::String::New("data"))->ToObject());
if (pixelArray) {
w = imageData->Get(v8::String::New("width"))->NumberValue();
QQuickContext2DEngineData::QQuickContext2DEngineData(QV8Engine *engine)
{
- v8::Local<v8::FunctionTemplate> ft = v8::FunctionTemplate::New();
+ v8::Handle<v8::FunctionTemplate> ft = v8::FunctionTemplate::New();
ft->InstanceTemplate()->SetHasExternalResource(true);
ft->PrototypeTemplate()->SetAccessor(v8::String::New("canvas"), ctx2d_canvas, 0, v8::External::New(engine));
ft->PrototypeTemplate()->Set(v8::String::New("restore"), V8FUNCTION(ctx2d_restore, engine));
constructorContext = qPersistentNew(ft->GetFunction());
- v8::Local<v8::FunctionTemplate> ftGradient = v8::FunctionTemplate::New();
+ v8::Handle<v8::FunctionTemplate> ftGradient = v8::FunctionTemplate::New();
ftGradient->InstanceTemplate()->SetHasExternalResource(true);
ftGradient->PrototypeTemplate()->Set(v8::String::New("addColorStop"), V8FUNCTION(ctx2d_gradient_addColorStop, engine));
constructorGradient = qPersistentNew(ftGradient->GetFunction());
- v8::Local<v8::FunctionTemplate> ftPattern = v8::FunctionTemplate::New();
+ v8::Handle<v8::FunctionTemplate> ftPattern = v8::FunctionTemplate::New();
ftPattern->InstanceTemplate()->SetHasExternalResource(true);
constructorPattern = qPersistentNew(ftPattern->GetFunction());
- v8::Local<v8::FunctionTemplate> ftPixelArray = v8::FunctionTemplate::New();
+ v8::Handle<v8::FunctionTemplate> ftPixelArray = v8::FunctionTemplate::New();
ftPixelArray->InstanceTemplate()->SetHasExternalResource(true);
ftPixelArray->InstanceTemplate()->SetAccessor(v8::String::New("length"), ctx2d_pixelArray_length, 0, v8::External::New(engine));
ftPixelArray->InstanceTemplate()->SetIndexedPropertyHandler(ctx2d_pixelArray_indexed, ctx2d_pixelArray_indexed_set, 0, 0, 0, v8::External::New(engine));
constructorPixelArray = qPersistentNew(ftPixelArray->GetFunction());
- v8::Local<v8::FunctionTemplate> ftImageData = v8::FunctionTemplate::New();
+ v8::Handle<v8::FunctionTemplate> ftImageData = v8::FunctionTemplate::New();
ftImageData->InstanceTemplate()->SetAccessor(v8::String::New("width"), ctx2d_imageData_width, 0, v8::External::New(engine));
ftImageData->InstanceTemplate()->SetAccessor(v8::String::New("height"), ctx2d_imageData_height, 0, v8::External::New(engine));
ftImageData->InstanceTemplate()->SetAccessor(v8::String::New("data"), ctx2d_imageData_data, 0, v8::External::New(engine));
QQuickCanvasItem* m_canvas;
QQuickContext2DCommandBuffer* m_buffer;
QPainterPath m_path;
- v8::Local<v8::Value> m_fillStyle;
- v8::Local<v8::Value> m_strokeStyle;
+ v8::Handle<v8::Value> m_fillStyle;
+ v8::Handle<v8::Value> m_strokeStyle;
v8::Handle<v8::Value> m_v8path;
QV8Engine *m_v8engine;
QSurface *m_surface;
Qt::DropActions supportedActions = d->supportedActions;
// check arguments for supportedActions, maybe data?
if (args->Length() >= 1) {
- v8::Local<v8::Value> v = (*args)[0];
+ v8::Handle<v8::Value> v = (*args)[0];
if (v->IsInt32()) {
supportedActions = Qt::DropActions(v->Int32Value());
d->overrideActions = true;
Qt::DropAction action = event->dropAction();
if (args->Length() >= 1) {
- v8::Local<v8::Value> v = (*args)[0];
+ v8::Handle<v8::Value> v = (*args)[0];
if (v->IsInt32())
action = Qt::DropAction(v->Int32Value());
}
void QQuickItem::mapFromItem(QQmlV8Function *args) const
{
if (args->Length() != 0) {
- v8::Local<v8::Value> item = (*args)[0];
+ v8::Handle<v8::Value> item = (*args)[0];
QV8Engine *engine = args->engine();
QQuickItem *itemObj = 0;
return;
}
- v8::Local<v8::Object> rv = v8::Object::New();
+ v8::Handle<v8::Object> rv = v8::Object::New();
args->returnValue(rv);
qreal x = (args->Length() > 1)?(*args)[1]->NumberValue():0;
void QQuickItem::mapToItem(QQmlV8Function *args) const
{
if (args->Length() != 0) {
- v8::Local<v8::Value> item = (*args)[0];
+ v8::Handle<v8::Value> item = (*args)[0];
QV8Engine *engine = args->engine();
QQuickItem *itemObj = 0;
return;
}
- v8::Local<v8::Object> rv = v8::Object::New();
+ v8::Handle<v8::Object> rv = v8::Object::New();
args->returnValue(rv);
qreal x = (args->Length() > 1)?(*args)[1]->NumberValue():0;
v8::Handle<v8::Object> QQuickLoaderPrivate::extractInitialPropertyValues(QQmlV8Function *args, QObject *loader, bool *error)
{
- v8::Local<v8::Object> valuemap;
+ v8::Handle<v8::Object> valuemap;
if (args->Length() >= 2) {
- v8::Local<v8::Value> v = (*args)[1];
+ v8::Handle<v8::Value> v = (*args)[1];
if (!v->IsObject() || v->IsArray()) {
*error = true;
qmlInfo(loader) << QQuickLoader::tr("setSource: value is not an object");
} else {
*error = false;
- valuemap = v8::Local<v8::Object>::Cast(v);
+ valuemap = v8::Handle<v8::Object>::Cast(v);
}
}
return;
int i = 0;
- v8::Local<v8::Value> arg = (*args)[i];
+ v8::Handle<v8::Value> arg = (*args)[i];
x = arg->NumberValue();
if (++i < args->Length()) {
projects / platform / upstream / qtdeclarative.git / commitdiff