~oif-team/ubuntu/natty/qt4-x11/xi2.1

qWarning("QAxBase::dynamicCallHelper: %s: No such property in %s [%s]", name.data(), that->control().toLatin1().data(), coclass ? coclass: "unknown");

3738

if (!function.isEmpty()) {

3739

qWarning("\tCandidates are:");

3740

char f0 = function.toLower().at(0);

3741

for (int i = metaObject->propertyOffset(); i < metaObject->propertyCount(); ++i) {

3742

QByteArray signature(metaObject->property(i).name());

3743

if (!signature.isEmpty() && signature.toLower().at(0) == f0)

3744

qWarning("\t\t%s", signature.data());

3745

}

3746

}

3747

}

3748

}

3749

#endif

3750

3751

/*!

3752

\internal

3753

3754

\a name is already normalized?

3755

3756

bool QAxBase::dynamicCallHelper(const char *name, void *inout, QList<QVariant> &vars, QByteArray &type)

3757

{

3758

if (isNull()) {

3759

qWarning("QAxBase::dynamicCallHelper: Object is not initialized, or initialization failed");

3760

return false;

3761

}

3762

3763

IDispatch *disp = d->dispatch();

3764

if (!disp) {

3765

qWarning("QAxBase::dynamicCallHelper: Object does not support automation");

3766

return false;

3767

}

3768

3769

const QMetaObject *mo = metaObject();

3770

d->metaObject();

3771

Q_ASSERT(d->metaobj);

3772

3773

int varc = vars.count();

3774

3775

QByteArray normFunction = QMetaObject::normalizedSignature(name);

3776

QByteArray function(normFunction);

3777

VARIANT staticarg[QAX_NUM_PARAMS];

3778

VARIANT *arg = 0;

3779

VARIANTARG *res = (VARIANTARG*)inout;

3780

3781

unsigned short disptype;

3782

3783

int id = -1;

3784

bool parse = false;

3785

3786

if (function.contains('(')) {

3787

disptype = DISPATCH_METHOD | DISPATCH_PROPERTYGET;

3788

if (d->useMetaObject)

3789

id = mo->indexOfSlot(function);

3790

if (id >= 0) {

3791

const QMetaMethod slot = mo->method(id);

3792

Q_ASSERT(slot.methodType() == QMetaMethod::Slot);

3793

function = slot.signature();

3794

type = slot.typeName();

3795

}

3796

function.truncate(function.indexOf('('));

3797

parse = !varc && normFunction.length() > function.length() + 2;

3798

if (parse) {

3799

QString args = QLatin1String(normFunction);

3800

args = args.mid(function.length() + 1);

3801

// parse argument string int list of arguments

3802

QString curArg;

3803

const QChar *c = args.unicode();

3804

int index = 0;

3805

bool inString = false;

3806

bool inEscape = false;

3807

while (index < (int)args.length()) {

3808

QChar cc = *c;

3809

++c;

3810

++index;

3811

switch(cc.toLatin1()) {

3812

case 'n':

3813

if (inEscape)

3814

cc = QLatin1Char('\n');

3815

break;

3816

case 'r':

3817

if (inEscape)

3818

cc = QLatin1Char('\r');

3819

break;

3820

case 't':

3821

if (inEscape)

3822

cc = QLatin1Char('\t');

3823

break;

3824

case '\\':

3825

if (!inEscape && inString) {

3826

inEscape = true;

3827

continue;

3828

}

3829

break;

3830

case '"':

3831

if (!inEscape) {

3832

inString = !inString;

3833

curArg += cc;

3834

continue;

3835

}

3836

break;

3837

case ' ':

3838

if (!inString && curArg.isEmpty())

3839

continue;

3840

break;

3841

case ',':

3842

case ')':

3843

if (inString)

3844

break;

3845

curArg = curArg.trimmed();

3846

if (curArg.at(0) == QLatin1Char('\"') && curArg.at(curArg.length()-1) == QLatin1Char('\"')) {

3847

vars << curArg.mid(1, curArg.length() - 2);

3848

} else {

3849

bool isNumber = false;

3850

bool isDouble = false;

3851

int number = curArg.toInt(&isNumber);

3852

double dbl = curArg.toDouble(&isDouble);

3853

if (isNumber) {

3854

vars << number;

3855

} else if (isDouble) {

3856

vars << dbl;

3857

} else {

3858

bool isEnum = false;

3859

for (int enumIndex = 0; enumIndex < mo->enumeratorCount(); ++enumIndex) {

3860

QMetaEnum metaEnum =mo->enumerator(enumIndex);

3861

int value = metaEnum.keyToValue(curArg.toLatin1());

3862

if (value != -1 && !QByteArray(metaEnum.valueToKey(value)).isEmpty()) {

3863

vars << value;

3864

isEnum = true;

3865

break;

3866

}

3867

}

3868

if (!isEnum)

3869

vars << curArg;

3870

}

3871

}

3872

curArg.clear();

3873

continue;

3874

default:

3875

break;

3876

}

3877

inEscape = false;

3878

curArg += cc;

3879

}

3880

3881

varc = vars.count();

3882

}

3883

} else {

3884

if (d->useMetaObject)

3885

id = mo->indexOfProperty(normFunction);

3886

3887

if (id >= 0) {

3888

const QMetaProperty prop =mo->property(id);

3889

type = prop.typeName();

3890

}

3891

if (varc == 1) {

3892

res = 0;

3893

disptype = DISPATCH_PROPERTYPUT;

3894

} else {

3895

disptype = DISPATCH_PROPERTYGET;

3896

}

3897

}

3898

if (varc) {

3899

varc = qMin(varc, d->metaobj->numParameter(normFunction));

3900

arg = varc <= QAX_NUM_PARAMS ? staticarg : new VARIANT[varc];

3901

for (int i = 0; i < varc; ++i) {

3902

QVariant var(vars.at(i));

3903

VariantInit(arg + (varc - i - 1));

3904

bool out = false;

3905

QByteArray paramType;

3906

if (disptype == DISPATCH_PROPERTYPUT)

3907

paramType = type;

3908

else if (parse || disptype == DISPATCH_PROPERTYGET)

3909

paramType = 0;

3910

else

3911

paramType = d->metaobj->paramType(normFunction, i, &out);

3912

3913

if ((!parse && d->useMetaObject && var.type() == QVariant::String) || var.type() == QVariant::ByteArray) {

3914

int enumIndex =mo->indexOfEnumerator(paramType);

3915

if (enumIndex != -1) {

3916

QMetaEnum metaEnum =mo->enumerator(enumIndex);

3917

QVariantToVARIANT(metaEnum.keyToValue(var.toByteArray()), arg[varc - i - 1], "int", out);

3918

}

3919

}

3920

3921

if (arg[varc - i - 1].vt == VT_EMPTY)

3922

QVariantToVARIANT(var, arg[varc - i - 1], paramType, out);

3923

}

3924

}

3925

3926

DISPID dispid = d->metaobj->dispIDofName(function, disp);

3927

if (dispid == DISPID_UNKNOWN && function.toLower().startsWith("set")) {

3928

function = function.mid(3);

3929

dispid = d->metaobj->dispIDofName(function, disp);

3930

disptype = DISPATCH_PROPERTYPUT;

3931

}

3932

3933

if (dispid == DISPID_UNKNOWN) {

3934

#ifdef QT_CHECK_STATE

3935

qax_noSuchFunction(disptype, normFunction, function, this);

3936

#endif

3937

return false;

3938

}

3939

3940

DISPPARAMS params;

3941

DISPID dispidNamed = DISPID_PROPERTYPUT;

3942

3943

params.cArgs = varc;

3944

params.cNamedArgs = (disptype == DISPATCH_PROPERTYPUT) ? 1 : 0;

3945

params.rgdispidNamedArgs = (disptype == DISPATCH_PROPERTYPUT) ? &dispidNamed : 0;

3946

params.rgvarg = arg;

3947

EXCEPINFO excepinfo;

3948

memset(&excepinfo, 0, sizeof(excepinfo));

3949

UINT argerr = 0;

3950

3951

HRESULT hres = disp->Invoke(dispid, IID_NULL, LOCALE_USER_DEFAULT, disptype, &params, res, &excepinfo, &argerr);

3952

3953

if (disptype == (DISPATCH_METHOD|DISPATCH_PROPERTYGET) && hres == S_OK && varc) {

3954

for (int i = 0; i < varc; ++i)

3955

if (arg[varc-i-1].vt & VT_BYREF) // update out-parameters

3956

vars[i] = VARIANTToQVariant(arg[varc-i-1], vars.at(i).typeName());

3957

}

3958

3959

// clean up

3960

for (int i = 0; i < varc; ++i)

3961

clearVARIANT(params.rgvarg+i);

3962

if (arg && arg != staticarg)

3963

delete[] arg;

3964

3965

return checkHRESULT(hres, &excepinfo, this, QLatin1String(function), varc-argerr-1);

3966

}

3967

3968

3969

/*!

3970

Calls the COM object's method \a function, passing the

3971

parameters \a var1, \a var1, \a var2, \a var3, \a var4, \a var5,

3972

\a var6, \a var7 and \a var8, and returns the value returned by

3973

the method, or an invalid QVariant if the method does not return

3974

a value or when the function call failed.

3975

3976

If \a function is a method of the object the string must be provided

3977

as the full prototype, for example as it would be written in a

3978

QObject::connect() call.

3979

3980

\snippet doc/src/snippets/code/src_activeqt_container_qaxbase.cpp 15

3981

3982

Alternatively a function can be called passing the parameters embedded

3983

in the string, e.g. above function can also be invoked using

3984

3985

\snippet doc/src/snippets/code/src_activeqt_container_qaxbase.cpp 16

3986

3987

All parameters are passed as strings; it depends on the control whether

3988

they are interpreted correctly, and is slower than using the prototype

3989

with correctly typed parameters.

3990

3991

If \a function is a property the string has to be the name of the

3992

property. The property setter is called when \a var1 is a valid QVariant,

3993

otherwise the getter is called.

3994

3995

\snippet doc/src/snippets/code/src_activeqt_container_qaxbase.cpp 17

3996

3997

Note that it is faster to get and set properties using

3998

QObject::property() and QObject::setProperty().

3999

4000

dynamicCall() can also be used to call objects with a

4001

\l{QAxBase::disableMetaObject()}{disabled metaobject} wrapper,

4002

which can improve performance significantely, esp. when calling many

4003

different objects of different types during an automation process.

4004

ActiveQt will then however not validate parameters.

4005

4006

It is only possible to call functions through dynamicCall() that

4007

have parameters or return values of datatypes supported by

4008

QVariant. See the QAxBase class documentation for a list of

4009

supported and unsupported datatypes. If you want to call functions

4010

that have unsupported datatypes in the parameter list, use

4011

queryInterface() to retrieve the appropriate COM interface, and

4012

use the function directly.

4013

4014

\snippet doc/src/snippets/code/src_activeqt_container_qaxbase.cpp 18

4015

4016

This is also more efficient.

4017

4018

QVariant QAxBase::dynamicCall(const char *function,

4019

const QVariant &var1,

4020

const QVariant &var2,

4021

const QVariant &var3,

4022

const QVariant &var4,

4023

const QVariant &var5,

4024

const QVariant &var6,

4025

const QVariant &var7,

4026

const QVariant &var8)

4027

{

4028

QList<QVariant> vars;

4029

QVariant var = var1;

4030

int argc = 1;

4031

while(var.isValid()) {

4032

vars << var;

4033

switch(++argc) {

4034

case 2: var = var2; break;

4035

case 3: var = var3; break;

4036

case 4: var = var4; break;

4037

case 5: var = var5; break;

4038

case 6: var = var6; break;

4039

case 7: var = var7; break;

4040

case 8: var = var8; break;

4041

default:var = QVariant(); break;

4042

}

4043

}

4044

4045

return dynamicCall(function, vars);

4046

}

4047

4048

/*!

4049

\overload

4050

4051

Calls the COM object's method \a function, passing the

4052

parameters in \a vars, and returns the value returned by

4053

the method. If the method does not return a value or when

4054

the function call failed this function returns an invalid

4055

QVariant object.

4056

4057

The QVariant objects in \a vars are updated when the method has

4058

out-parameters.

4059

4060

QVariant QAxBase::dynamicCall(const char *function, QList<QVariant> &vars)

4061

{

4062

VARIANTARG res;

4063

VariantInit(&res);

4064

4065

QByteArray rettype;

4066

if (!dynamicCallHelper(function, &res, vars, rettype))

4067

return QVariant();

4068

4069

QVariant qvar = VARIANTToQVariant(res, rettype);

4070

if ((res.vt != VT_DISPATCH && res.vt != VT_UNKNOWN) || qvar.type() == QVariant::Pixmap || qvar.type() == QVariant::Font)

4071

clearVARIANT(&res);

4072

4073

return qvar;

4074

}

4075

4076

/*!

4077

Returns a pointer to a QAxObject wrapping the COM object provided

4078

by the method or property \a name, passing passing the parameters

4079

\a var1, \a var1, \a var2, \a var3, \a var4, \a var5, \a var6,

4080

\a var7 and \a var8.

4081

4082

If \a name is provided by a method the string must include the

4083

full function prototype.

4084

4085

If \a name is a property the string must be the name of the property,

4086

and \a var1, ... \a var8 are ignored.

4087

4088

The returned QAxObject is a child of this object (which is either of

4089

type QAxObject or QAxWidget), and is deleted when this object is

4090

deleted. It is however safe to delete the returned object yourself,

4091

and you should do so when you iterate over lists of subobjects.

4092

4093

COM enabled applications usually have an object model publishing

4094

certain elements of the application as dispatch interfaces. Use

4095

this method to navigate the hierarchy of the object model, e.g.

4096

4097

\snippet doc/src/snippets/code/src_activeqt_container_qaxbase.cpp 19

4098

4099

QAxObject *QAxBase::querySubObject(const char *name,

4100

const QVariant &var1,

4101

const QVariant &var2,

4102

const QVariant &var3,

4103

const QVariant &var4,

4104

const QVariant &var5,

4105

const QVariant &var6,

4106

const QVariant &var7,

4107

const QVariant &var8)

4108

{

4109

QList<QVariant> vars;

4110

QVariant var = var1;

4111

int argc = 1;

4112

while(var.isValid()) {

4113

vars << var;

4114

switch(++argc) {

4115

case 2: var = var2; break;

4116

case 3: var = var3; break;

4117

case 4: var = var4; break;

4118

case 5: var = var5; break;

4119

case 6: var = var6; break;

4120

case 7: var = var7; break;

4121

case 8: var = var8; break;

4122

default:var = QVariant(); break;

4123

}

4124

}

4125

4126

return querySubObject(name, vars);

4127

}

4128

4129

/*!

4130

\overload

4131

4132

The QVariant objects in \a vars are updated when the method has

4133

out-parameters.

4134

4135

QAxObject *QAxBase::querySubObject(const char *name, QList<QVariant> &vars)

4136

{

4137

QAxObject *object = 0;

4138

VARIANTARG res;

4139

VariantInit(&res);

4140

4141

QByteArray rettype;

4142

if (!dynamicCallHelper(name, &res, vars, rettype))

4143

return 0;

4144

4145

switch (res.vt) {

4146

case VT_DISPATCH:

4147

if (res.pdispVal) {

4148

if (rettype.isEmpty() || rettype == "IDispatch*" || rettype == "QVariant") {

4149

object = new QAxObject(res.pdispVal, qObject());

4150

} else if (QMetaType::type(rettype)) {

4151

QVariant qvar = VARIANTToQVariant(res, rettype, 0);

4152

object = *(QAxObject**)qvar.constData();

4153

// qVariantGet(qvar, object, rettype);

4154

res.pdispVal->AddRef();

4155

}

4156

if (object)

4157

((QAxBase*)object)->d->tryCache = true;

4158

}

4159

break;

4160

case VT_UNKNOWN:

4161

if (res.punkVal) {

4162

if (rettype.isEmpty() || rettype == "IUnknown*") {

4163

object = new QAxObject(res.punkVal, qObject());

4164

} else if (QMetaType::type(rettype)) {

4165

QVariant qvar = VARIANTToQVariant(res, rettype, 0);

4166

object = *(QAxObject**)qvar.constData();

4167

// qVariantGet(qvar, object, rettype);

4168

res.punkVal->AddRef();

4169

}

4170

if (object)

4171

((QAxBase*)object)->d->tryCache = true;

4172

}

4173

break;

4174

case VT_EMPTY:

4175

#ifdef QT_CHECK_STATE

4176

{

4177

const char *coclass = metaObject()->classInfo(metaObject()->indexOfClassInfo("CoClass")).value();

4178

qWarning("QAxBase::querySubObject: %s: Error calling function or property in %s (%s)"

4179

, name, control().toLatin1().data(), coclass ? coclass: "unknown");

4180

}

4181

#endif

4182

break;

4183

default:

4184

#ifdef QT_CHECK_STATE

4185

{

4186

const char *coclass = metaObject()->classInfo(metaObject()->indexOfClassInfo("CoClass")).value();

4187

qWarning("QAxBase::querySubObject: %s: Method or property is not of interface type in %s (%s)"

4188

, name, control().toLatin1().data(), coclass ? coclass: "unknown");

4189

}

4190

#endif

4191

break;

4192

}

4193

4194

clearVARIANT(&res);

4195

return object;

4196

}

4197

4198

class QtPropertyBag : public IPropertyBag

4199

{

4200

public:

4201

QtPropertyBag() :ref(0) {}

4202

virtual ~QtPropertyBag() {}

4203

4204

HRESULT __stdcall QueryInterface(REFIID iid, LPVOID *iface)

4205

{

4206

*iface = 0;

4207

if (iid == IID_IUnknown)

4208

*iface = this;

4209

else if (iid == IID_IPropertyBag)

4210

*iface = this;

4211

else

4212

return E_NOINTERFACE;

4213

4214

AddRef();

4215

return S_OK;

4216

}

4217

unsigned long __stdcall AddRef() { return ++ref; }

4218

unsigned long __stdcall Release()

4219

{

4220

if (!--ref) {

4221

delete this;

4222

return 0;

4223

}

4224

return ref;

4225

}

4226

4227

HRESULT __stdcall Read(LPCOLESTR name, VARIANT *var, IErrorLog *)

4228

{

4229

if (!var)

4230

return E_POINTER;

4231

4232

QString property = QString::fromWCharArray(name);

4233

QVariant qvar = map.value(property);

4234

QVariantToVARIANT(qvar, *var);

4235

return S_OK;

4236

}

4237

HRESULT __stdcall Write(LPCOLESTR name, VARIANT *var)

4238

{

4239

if (!var)

4240

return E_POINTER;

4241

QString property = QString::fromWCharArray(name);

4242

QVariant qvar = VARIANTToQVariant(*var, 0);

4243

map[property] = qvar;

4244

4245

return S_OK;

4246

}

4247

4248

QAxBase::PropertyBag map;

4249

4250

private:

4251

unsigned long ref;

4252

};

4253

4254

/*!

4255

Returns a name:value map of all the properties exposed by the COM

4256

object.

4257

4258

This is more efficient than getting multiple properties

4259

individually if the COM object supports property bags.

4260

4261

\warning It is not guaranteed that the property bag implementation

4262

of the COM object returns all properties, or that the properties

4263

returned are the same as those available through the IDispatch

4264

interface.

4265

4266

QAxBase::PropertyBag QAxBase::propertyBag() const

4267

{

4268

PropertyBag result;

4269

4270

if (!d->ptr && !d->initialized) {

4271

((QAxBase*)this)->initialize(&d->ptr);

4272

d->initialized = true;

4273

}

4274

4275

if (isNull())

4276

return result;

4277

IPersistPropertyBag *persist = 0;

4278

d->ptr->QueryInterface(IID_IPersistPropertyBag, (void**)&persist);

4279

if (persist) {

4280

QtPropertyBag *pbag = new QtPropertyBag();

4281

pbag->AddRef();

4282

persist->Save(pbag, false, true);

4283

result = pbag->map;

4284

pbag->Release();

4285

persist->Release();

4286

return result;

4287

} else {

4288

const QMetaObject *mo = metaObject();

4289

for (int p = mo->propertyOffset(); p < mo->propertyCount(); ++p) {

4290

const QMetaProperty property = mo->property(p);

4291

QVariant var = qObject()->property(property.name());

4292

result.insert(QLatin1String(property.name()), var);

4293

}

4294

}

4295

return result;

4296

}

4297

4298

/*!

4299

Sets the properties of the COM object to the corresponding values

4300

in \a bag.

4301

4302

\warning

4303

You should only set property bags that have been returned by the

4304

propertyBag function, as it cannot be guaranteed that the property

4305

bag implementation of the COM object supports the same properties

4306

that are available through the IDispatch interface.

4307

4308

\sa propertyBag()

4309

4310

void QAxBase::setPropertyBag(const PropertyBag &bag)

4311

{

4312

if (!d->ptr && !d->initialized) {

4313

initialize(&d->ptr);

4314

d->initialized = true;

4315

}

4316

4317

if (isNull())

4318

return;

4319

IPersistPropertyBag *persist = 0;

4320

d->ptr->QueryInterface(IID_IPersistPropertyBag, (void**)&persist);

4321

if (persist) {

4322

QtPropertyBag *pbag = new QtPropertyBag();

4323

pbag->map = bag;

4324

pbag->AddRef();

4325

persist->Load(pbag, 0);

4326

pbag->Release();

4327

persist->Release();

4328

} else {

4329

const QMetaObject *mo = metaObject();

4330

for (int p = mo->propertyOffset(); p < mo->propertyCount(); ++p) {

4331

const QMetaProperty property = mo->property(p);

4332

QVariant var = bag.value(QLatin1String(property.name()));

4333

qObject()->setProperty(property.name(), var);

4334

}

4335

}

4336

}

4337

4338

/*!

4339

Returns true if the property \a prop is writable; otherwise

4340

returns false. By default, all properties are writable.

4341

4342

\warning

4343

Depending on the control implementation this setting might be

4344

ignored for some properties.

4345

4346

\sa setPropertyWritable(), propertyChanged()

4347

4348

bool QAxBase::propertyWritable(const char *prop) const

4349

{

4350

return d->propWritable.value(prop, true);

4351

}

4352

4353

/*!

4354

Sets the property \a prop to writable if \a ok is true, otherwise

4355

sets \a prop to be read-only. By default, all properties are

4356

writable.

4357

4358

\warning

4359

Depending on the control implementation this setting might be

4360

ignored for some properties.

4361

4362

\sa propertyWritable(), propertyChanged()

4363

4364

void QAxBase::setPropertyWritable(const char *prop, bool ok)

4365

{

4366

d->propWritable[prop] = ok;

4367

}

4368

4369

/*!

4370

Returns true if there is no COM object loaded by this wrapper;

4371

otherwise return false.

4372

4373

\sa control

4374

4375

bool QAxBase::isNull() const

4376

{

4377

return !d->ptr;

4378

}

4379

4380

/*!

4381

Returns a QVariant that wraps the COM object. The variant can

4382

then be used as a parameter in e.g. dynamicCall().

4383

4384

QVariant QAxBase::asVariant() const

4385

{

4386

if (!d->ptr && !d->initialized) {

4387

((QAxBase*)this)->initialize(&d->ptr);

4388

d->initialized = true;

4389

}

4390

4391

QVariant qvar;

4392

QByteArray cn(className());

4393

if (cn == "QAxObject" || cn == "QAxWidget" || cn == "QAxBase") {

4394

if (d->dispatch())

4395

qVariantSetValue(qvar, d->dispatch());

4396

else if (d->ptr)

4397

qVariantSetValue(qvar, d->ptr);

4398

} else {

4399

cn = cn.mid(cn.lastIndexOf(':') + 1);

4400

QObject *object = qObject();

4401

if (QMetaType::type(cn))

4402

qvar = QVariant(qRegisterMetaType<QObject*>(cn + '*'), &object);

4403

// qVariantSetValue(qvar, qObject(), cn + '*');

4404

}

4405

4406

return qvar;

4407

}

4408

4409

// internal function that creates a QAxObject from an iface

4410

// used by type-conversion code (types.cpp)

4411

void *qax_createObjectWrapper(int metaType, IUnknown *iface)

4412

{

4413

if (!iface)

4414

return 0;

4415

4416

QAxObject *object = (QAxObject*)QMetaType::construct(metaType, 0);

4417

QAxBasePrivate *d = object->d;

4418

4419

d->ptr = iface;

4420

d->initialized = true;

4421

4422

// no release, since no addref

4423

4424

return object;

4425

}

4426

4427

/*!

4428

\fn void QAxBase::signal(const QString &name, int argc, void *argv)

4429

4430

This generic signal gets emitted when the COM object issues the

4431

event \a name. \a argc is the number of parameters provided by the

4432

event (DISPPARAMS.cArgs), and \a argv is the pointer to the

4433

parameter values (DISPPARAMS.rgvarg). Note that the order of parameter

4434

values is turned around, ie. the last element of the array is the first

4435

parameter in the function.

4436

4437

\snippet doc/src/snippets/code/src_activeqt_container_qaxbase.cpp 20

4438

4439

Use this signal if the event has parameters of unsupported data

4440

types. Otherwise, connect directly to the signal \a name.

4441

4442

4443

/*!

4444

\fn void QAxBase::propertyChanged(const QString &name)

4445

4446

If the COM object supports property notification, this signal gets

4447

emitted when the property called \a name is changed.

4448

4449

4450

/*!

4451

\fn void QAxBase::exception(int code, const QString &source, const QString &desc, const QString &help)

4452

4453

This signal is emitted when the COM object throws an exception while called using the OLE automation

4454

interface IDispatch. \a code, \a source, \a desc and \a help provide information about the exception as

4455

provided by the COM server and can be used to provide useful feedback to the end user. \a help includes

4456

the help file, and the help context ID in brackets, e.g. "filename [id]".

4457

4458

4459

/*!

4460

\fn QObject *QAxBase::qObject() const

4461

\internal

4462

4463

4464

/*!

4465

\fn const char *QAxBase::className() const

4466

\internal

4467

4468

4469

QT_END_NAMESPACE

4470

#endif //QT_NO_WIN_ACTIVEQT

Older »