Maemo Namespace Reference

Classes
struct	CommonParams
class	DBusDispatcher
	DBusDispatcher is a class that can send DBUS method call messages and receive unicast signals from DBUS objects. More...
class	DBusDispatcherPrivate
class	GConfItemFast
class	IAPConf
class	IAPConfPrivate
class	IAPMonitor
class	IAPMonitorPrivate
class	Icd
struct	IcdAddressInfoResult
struct	IcdIPInformation
class	IcdPrivate
struct	IcdScanResult
struct	IcdStateResult
struct	IcdStatisticsResult
class	NetworkProxyFactory
class	PendingCallInfo
class	ProxyConf
class	ProxyConfPrivate

Enumerations
enum	IcdDbusInterfaceVer { IcdOldDbusInterface = 0, IcdNewDbusInterface }

Functions
static bool	appendVariantToDBusMessage (const QVariant &argument, DBusMessageIter *dbus_iter)
void	conn_settings_notify_func (ConnSettingsType type, const char *id, const char *key, ConnSettingsValue *value, void *user_data)
static bool	constantVariantList (const QVariantList &variantList)
static QString	convertKey (const char *key)
static QVariant	convertValue (GConfValue *src)
static void	freePendingCallInfo (void *memory)
static void	get_addrinfo_all_result (QList< QVariant > &args, IcdAddressInfoResult &ret)
static void	get_scan_result (QList< QVariant > &args, IcdScanResult &ret)
static void	get_state_all_result (QList< QVariant > &args, IcdStateResult &ret)
static void	get_state_all_result2 (QList< QVariant > &args, IcdStateResult &ret)
static void	get_statistics_all_result (QList< QVariant > &args, IcdStatisticsResult &ret)
static QHash< QString, QVariant >	getHttpValues (const QString &prefix)
static QHash< QString, QVariant >	getValues (const QString &prefix)
static QVariant	getVariantFromDBusMessage (DBusMessageIter *iter)
static void	pendingCallFunction (DBusPendingCall *pending, void *memory)
static DBusMessage *	prepareDBusCall (const QString &service, const QString &path, const QString &interface, const QString &method, const QVariant &arg1=QVariant(), const QVariant &arg2=QVariant(), const QVariant &arg3=QVariant(), const QVariant &arg4=QVariant(), const QVariant &arg5=QVariant(), const QVariant &arg6=QVariant(), const QVariant &arg7=QVariant(), const QVariant &arg8=QVariant())
static DBusHandlerResult	signalHandler (DBusConnection *connection, DBusMessage *message, void *object_ref)
static QString	variantToSignature (const QVariant &argument, bool constantList=true)

Variables
static QReadWriteLock	lock
static int	refcount = 0

Enumeration Type Documentation

IcdDbusInterfaceVer

enum Maemo::IcdDbusInterfaceVer

Enumerator
IcdOldDbusInterface
IcdNewDbusInterface

Definition at line 122 of file maemo_icd.h.

                         {
    IcdOldDbusInterface = 0,  // use the old OSSO-IC interface
    IcdNewDbusInterface       // use the new Icd2 interface (default)
};

Function Documentation

appendVariantToDBusMessage()

static bool Maemo::appendVariantToDBusMessage ( const QVariant &  argument, DBusMessageIter *  dbus_iter  )

static

Definition at line 156 of file dbusdispatcher.cpp.

Referenced by prepareDBusCall().

                                                                   {
    int idx = 0;
    DBusMessageIter array_iter;
    QStringList str_list;
    dbus_bool_t bool_data;
    dbus_int32_t int32_data;
    dbus_uint32_t uint32_data;
    dbus_int64_t int64_data;
    dbus_uint64_t uint64_data;
    char *str_data;
    char char_data;

    switch (argument.type()) {

        case QVariant::Bool:
            bool_data = argument.toBool();
            dbus_message_iter_append_basic(dbus_iter, DBUS_TYPE_BOOLEAN, 
                                           &bool_data);
            break;

        case QVariant::ByteArray:
            str_data = argument.toByteArray().data();
            dbus_message_iter_open_container(dbus_iter, DBUS_TYPE_ARRAY,
                                             DBUS_TYPE_BYTE_AS_STRING, &array_iter);
            dbus_message_iter_append_fixed_array(&array_iter,
                                                 DBUS_TYPE_BYTE,
                                                 &str_data,
                                                 argument.toByteArray().size());
            dbus_message_iter_close_container(dbus_iter, &array_iter);
            break;

        case QVariant::Char:
            char_data = argument.toChar().toAscii();
            dbus_message_iter_append_basic(dbus_iter, DBUS_TYPE_BYTE, 
                                           &char_data);
            break;

        case QVariant::Int:
            int32_data = argument.toInt();
            dbus_message_iter_append_basic(dbus_iter, DBUS_TYPE_INT32, 
                                           &int32_data);
            break;

        case QVariant::String: {
            QByteArray data = argument.toString().toUtf8();
            str_data = data.data();
            dbus_message_iter_append_basic(dbus_iter, DBUS_TYPE_STRING,
                                           &str_data);
            break;
        }

        case QVariant::StringList:
            str_list = argument.toStringList();
            dbus_message_iter_open_container(dbus_iter, DBUS_TYPE_ARRAY,
                                             "s", &array_iter);
            for (idx = 0; idx < str_list.size(); idx++) {
                QByteArray data = str_list.at(idx).toLatin1();
                str_data = data.data();
                dbus_message_iter_append_basic(&array_iter,
                                               DBUS_TYPE_STRING,
                                               &str_data);
            }
            dbus_message_iter_close_container(dbus_iter, &array_iter);
            break;

        case QVariant::UInt:
            uint32_data = argument.toUInt();
            dbus_message_iter_append_basic(dbus_iter, DBUS_TYPE_UINT32, 
                                           &uint32_data);
            break;

        case QVariant::ULongLong:
            uint64_data = argument.toULongLong();
            dbus_message_iter_append_basic(dbus_iter, DBUS_TYPE_UINT64, 
                                           &uint64_data);
            break;

        case QVariant::LongLong:
            int64_data = argument.toLongLong();
            dbus_message_iter_append_basic(dbus_iter, DBUS_TYPE_INT64, 
                                           &int64_data);
            break;

        case QVariant::List:
            {
            QVariantList variantList = argument.toList();
            bool constantList = constantVariantList(variantList);
            DBusMessageIter array_iter;

            // List is mapped either as an DBUS array (all items same type)
            // DBUS struct (variable types) depending on constantList
            if (constantList) {
                // Resolve the signature for the first item
                QString signature = "";
                if (!variantList.isEmpty()) {
                    signature = variantToSignature(
                                variantList[0],
                                constantVariantList(variantList[0].toList()));
                }

                // Mapped as DBUS array
                dbus_message_iter_open_container(dbus_iter, DBUS_TYPE_ARRAY,
                                                 signature.toAscii(),
                                                 &array_iter);

                foreach(QVariant listItem, variantList) {
                    appendVariantToDBusMessage(listItem, &array_iter);
                }

                dbus_message_iter_close_container(dbus_iter, &array_iter);
            } else {
                // Mapped as DBUS struct
                dbus_message_iter_open_container(dbus_iter, DBUS_TYPE_STRUCT,
                                                 NULL,
                                                 &array_iter);

                foreach(QVariant listItem, variantList) {
                    appendVariantToDBusMessage(listItem, &array_iter);
                }

                dbus_message_iter_close_container(dbus_iter, &array_iter);
            }

            break;
            }
        default:
            qDebug() << "Unsupported variant type: " << argument.type();
            break;
    }

    return true;
}

conn_settings_notify_func()

void Maemo::conn_settings_notify_func	(	ConnSettingsType	type,
		const char *	id,
		const char *	key,
		ConnSettingsValue *	value,
		void *	user_data
	)

Definition at line 91 of file iapmonitor.cpp.

Referenced by Maemo::IAPMonitorPrivate::IAPMonitorPrivate().

{
    Q_UNUSED(id);

    if (type != CONN_SETTINGS_CONNECTION) return;
    IAPMonitorPrivate *priv = (IAPMonitorPrivate *)user_data;

    QString iapId(key);
    iapId = iapId.split("/")[0];
    if (value != 0) {
        priv->iapAdded(iapId);
    } else if (iapId == QString(key)) {
        // IAP is removed only when the directory gets removed
        priv->iapRemoved(iapId);
    }
}

constantVariantList()

static bool Maemo::constantVariantList ( const QVariantList &  variantList )

static

Definition at line 93 of file dbusdispatcher.cpp.

Referenced by appendVariantToDBusMessage().

                                                                 {
    // Special case, empty list == empty struct
    if (variantList.isEmpty()) {
        return false;
    } else {        
        QVariant::Type type = variantList[0].type();
        // Iterate items in the list and check if they are same type
        foreach(QVariant variant, variantList) {
            if (variant.type() != type) {
                return false;
            }
        }
    }
    return true;
}

convertKey()

static QString Maemo::convertKey ( const char *  key )

static

Definition at line 59 of file proxyconf.cpp.

Referenced by Maemo::GConfItemFast::getEntries().

{
    return QString::fromUtf8(key);
}

convertValue()

static QVariant Maemo::convertValue ( GConfValue *  src )

static

Definition at line 64 of file proxyconf.cpp.

Referenced by QScriptEnginePrivate::convertValue(), QScriptEnginePrivate::get(), and Maemo::GConfItemFast::getEntries().

{
    if (!src) {
        return QVariant();
    } else {
        switch (src->type) {
        case GCONF_VALUE_INVALID:
            return QVariant(QVariant::Invalid);
        case GCONF_VALUE_BOOL:
            return QVariant((bool)gconf_value_get_bool(src));
        case GCONF_VALUE_INT:
            return QVariant(gconf_value_get_int(src));
        case GCONF_VALUE_FLOAT:
            return QVariant(gconf_value_get_float(src));
        case GCONF_VALUE_STRING:
            return QVariant(QString::fromUtf8(gconf_value_get_string(src)));
        case GCONF_VALUE_LIST:
            switch (gconf_value_get_list_type(src)) {
            case GCONF_VALUE_STRING:
                {
                    QStringList result;
                    for (GSList *elts = gconf_value_get_list(src); elts; elts = elts->next)
                        result.append(QString::fromUtf8(gconf_value_get_string((GConfValue *)elts->data)));
                    return QVariant(result);
                }
            default:
                {
                    QList<QVariant> result;
                    for (GSList *elts = gconf_value_get_list(src); elts; elts = elts->next)
                        result.append(convertValue((GConfValue *)elts->data));
                    return QVariant(result);
                }
            }
        case GCONF_VALUE_SCHEMA:
        default:
            return QVariant();
        }
    }
}

freePendingCallInfo()

static void Maemo::freePendingCallInfo ( void *  memory )

static

Definition at line 563 of file dbusdispatcher.cpp.

Referenced by Maemo::DBusDispatcher::callAsynchronous().

                                              {
    PendingCallInfo *info = (PendingCallInfo *)memory;
    delete info;
}

get_addrinfo_all_result()

static void Maemo::get_addrinfo_all_result ( QList< QVariant > &  args, IcdAddressInfoResult &  ret  )

static

Definition at line 620 of file maemo_icd.cpp.

Referenced by Maemo::IcdPrivate::addrinfo().

{
    int i=0;

    if (args.isEmpty())
      return;

    ret.params.service_type = args[i++].toString();
    ret.params.service_attrs = args[i++].toUInt();
    ret.params.service_id = args[i++].toString();
    ret.params.network_type = args[i++].toString();
    ret.params.network_attrs = args[i++].toUInt();
    ret.params.network_id = args[i++].toByteArray();

    QVariantList vl = args[i].toList();
    QVariant reply = vl.first();
    QList<QVariant> lst = reply.toList();
    for (int k=0; k<lst.size()/6; k=k+6) {
        IcdIPInformation ip_info;
    ip_info.address = lst[k].toString();
    ip_info.netmask = lst[k++].toString();
    ip_info.default_gateway = lst[k++].toString();
    ip_info.dns1 = lst[k++].toString();
    ip_info.dns2 = lst[k++].toString();
    ip_info.dns3 = lst[k++].toString();

    ret.ip_info << ip_info;
    }
}

get_scan_result()

static void Maemo::get_scan_result ( QList< QVariant > &  args, IcdScanResult &  ret  )

static

Definition at line 248 of file maemo_icd.cpp.

Referenced by Maemo::IcdPrivate::scan().

{
    int i=0;

    if (args.isEmpty())
      return;

    ret.status = args[i++].toUInt();
    ret.timestamp = args[i++].toUInt();
    ret.scan.service_type = args[i++].toString();
    ret.service_name = args[i++].toString();
    ret.scan.service_attrs = args[i++].toUInt();
    ret.scan.service_id = args[i++].toString();
    ret.service_priority = args[i++].toInt();
    ret.scan.network_type = args[i++].toString();
    ret.network_name = args[i++].toString();
    ret.scan.network_attrs = args[i++].toUInt();
    ret.scan.network_id = args[i++].toByteArray();
    ret.network_priority = args[i++].toInt();
    ret.signal_strength = args[i++].toInt();
    ret.station_id = args[i++].toString();
    ret.signal_dB = args[i++].toInt();
}

get_state_all_result()

static void Maemo::get_state_all_result ( QList< QVariant > &  args, IcdStateResult &  ret  )

static

Definition at line 382 of file maemo_icd.cpp.

Referenced by Maemo::IcdPrivate::state().

{
    int i=0;

    ret.params.service_type = args[i++].toString();
    ret.params.service_attrs = args[i++].toUInt();
    ret.params.service_id = args[i++].toString();
    ret.params.network_type = args[i++].toString();
    ret.params.network_attrs = args[i++].toUInt();
    ret.params.network_id = args[i++].toByteArray();
    ret.error = args[i++].toString();
    ret.state = args[i++].toInt();
}

get_state_all_result2()

static void Maemo::get_state_all_result2 ( QList< QVariant > &  args, IcdStateResult &  ret  )

static

Definition at line 398 of file maemo_icd.cpp.

Referenced by Maemo::IcdPrivate::state().

{
    int i=0;

    ret.params.network_type = args[i++].toString();
    ret.state = args[i++].toInt();

    // Initialize the other values so that the caller can
    // notice we only returned partial status
    ret.params.service_type = QString();
    ret.params.service_attrs = 0;
    ret.params.service_id = QString();
    ret.params.network_attrs = 0;
    ret.params.network_id = QByteArray();
    ret.error = QString();
}

get_statistics_all_result()

static void Maemo::get_statistics_all_result ( QList< QVariant > &  args, IcdStatisticsResult &  ret  )

static

Definition at line 543 of file maemo_icd.cpp.

Referenced by Maemo::IcdPrivate::statistics().

{
    int i=0;

    if (args.isEmpty())
      return;

    ret.params.service_type = args[i++].toString();
    ret.params.service_attrs = args[i++].toUInt();
    ret.params.service_id = args[i++].toString();
    ret.params.network_type = args[i++].toString();
    ret.params.network_attrs = args[i++].toUInt();
    ret.params.network_id = args[i++].toByteArray();
    ret.time_active = args[i++].toUInt();
    ret.signal_strength = (enum icd_nw_levels)args[i++].toUInt();
    ret.bytes_sent = args[i++].toUInt();
    ret.bytes_received = args[i++].toUInt();
}

getHttpValues()

static QHash<QString,QVariant> Maemo::getHttpValues ( const QString &  prefix )

static

Definition at line 206 of file proxyconf.cpp.

Referenced by Maemo::ProxyConfPrivate::readProxyData().

{
    GConfItemFast item(prefix);
    return item.getEntries();
}

getValues()

static QHash<QString,QVariant> Maemo::getValues ( const QString &  prefix )

static

Definition at line 200 of file proxyconf.cpp.

Referenced by QGLContext::chooseContext(), and Maemo::ProxyConfPrivate::readProxyData().

{
    GConfItemFast item(prefix);
    return item.getEntries();
}

getVariantFromDBusMessage()

static QVariant Maemo::getVariantFromDBusMessage ( DBusMessageIter *  iter )

static

Definition at line 290 of file dbusdispatcher.cpp.

Referenced by Maemo::DBusDispatcher::call(), and pendingCallFunction().

                                                                 {
    dbus_bool_t bool_data;
    dbus_int32_t int32_data;
    dbus_uint32_t uint32_data;
    dbus_int64_t int64_data;
    dbus_uint64_t uint64_data;
    char *str_data;
    char char_data;
    int argtype = dbus_message_iter_get_arg_type(iter);

    switch (argtype) {

        case DBUS_TYPE_BOOLEAN:
        {
            dbus_message_iter_get_basic(iter, &bool_data);
            QVariant variant((bool)bool_data);
            return variant;
        }

        case DBUS_TYPE_ARRAY:
        {
            // Handle all arrays here
            int elem_type = dbus_message_iter_get_element_type(iter);
            DBusMessageIter array_iter;

            dbus_message_iter_recurse(iter, &array_iter);

            if (elem_type == DBUS_TYPE_BYTE) {
                QByteArray byte_array;
                do {
                    dbus_message_iter_get_basic(&array_iter, &char_data);
                    byte_array.append(char_data);
                } while (dbus_message_iter_next(&array_iter));
                QVariant variant(byte_array);
                return variant;
            } else if (elem_type == DBUS_TYPE_STRING) {
                QStringList str_list;
                do {
                    dbus_message_iter_get_basic(&array_iter, &str_data);
                    str_list.append(str_data);
                } while (dbus_message_iter_next(&array_iter));
                QVariant variant(str_list);
                return variant;
            } else {
                QVariantList variantList;
                do {
                    variantList << getVariantFromDBusMessage(&array_iter);
                } while (dbus_message_iter_next(&array_iter));
                QVariant variant(variantList);
                return variant;
            }
            break;
        }

        case DBUS_TYPE_BYTE:
        {
            dbus_message_iter_get_basic(iter, &char_data);
            QChar ch(char_data);
            QVariant variant(ch);
            return variant;
        }

        case DBUS_TYPE_INT32:
        {
            dbus_message_iter_get_basic(iter, &int32_data);
            QVariant variant((int)int32_data);
            return variant;
        }

        case DBUS_TYPE_UINT32:
        {
            dbus_message_iter_get_basic(iter, &uint32_data);
            QVariant variant((uint)uint32_data);
            return variant;
        }

        case DBUS_TYPE_STRING:
        {
            dbus_message_iter_get_basic(iter, &str_data);
            QString str(QString::fromUtf8(str_data));
            QVariant variant(str);
            return variant;
        }

        case DBUS_TYPE_INT64:
        {
            dbus_message_iter_get_basic(iter, &int64_data);
            QVariant variant((qlonglong)int64_data);
            return variant;
        }

        case DBUS_TYPE_UINT64:
        {
            dbus_message_iter_get_basic(iter, &uint64_data);
            QVariant variant((qulonglong)uint64_data);
            return variant;
        }

        case DBUS_TYPE_STRUCT:
        {
            // Handle all structs here
            DBusMessageIter struct_iter;
            dbus_message_iter_recurse(iter, &struct_iter);

        QVariantList variantList;
        do {
          variantList << getVariantFromDBusMessage(&struct_iter);
        } while (dbus_message_iter_next(&struct_iter));
        QVariant variant(variantList);
        return variant;
        }

        default:
            qDebug() << "Unsupported DBUS type: " << argtype;
    }

    return QVariant();
}

pendingCallFunction()

static void Maemo::pendingCallFunction ( DBusPendingCall *  pending, void *  memory  )

static

Definition at line 568 of file dbusdispatcher.cpp.

Referenced by Maemo::DBusDispatcher::callAsynchronous().

                                               {
    PendingCallInfo *info = (PendingCallInfo *)memory;
    QString errorStr;
    QList<QVariant> replyList;
    DBusMessage *reply = dbus_pending_call_steal_reply (pending);

    Q_ASSERT(reply != NULL);

    if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
        errorStr = dbus_message_get_error_name (reply);
    } else {
        DBusMessageIter dbus_iter;
        dbus_message_iter_init(reply, &dbus_iter);
        // Read return arguments
        while (dbus_message_iter_get_arg_type (&dbus_iter) != DBUS_TYPE_INVALID) {
            replyList << getVariantFromDBusMessage(&dbus_iter);
            dbus_message_iter_next(&dbus_iter);
        }
    }

    info->priv->pending_calls.removeOne(pending);
    info->dispatcher->emitCallReply(info->method, replyList, errorStr);
    dbus_message_unref(reply);
    dbus_pending_call_unref(pending);
}

prepareDBusCall()

static DBusMessage* Maemo::prepareDBusCall ( const QString &  service, const QString &  path, const QString &  interface, const QString &  method, const QVariant &  arg1 = QVariant(), const QVariant &  arg2 = QVariant(), const QVariant &  arg3 = QVariant(), const QVariant &  arg4 = QVariant(), const QVariant &  arg5 = QVariant(), const QVariant &  arg6 = QVariant(), const QVariant &  arg7 = QVariant(), const QVariant &  arg8 = QVariant()  )

static

Definition at line 485 of file dbusdispatcher.cpp.

Referenced by Maemo::DBusDispatcher::call(), and Maemo::DBusDispatcher::callAsynchronous().

{
    DBusMessage *message = dbus_message_new_method_call(service.toLatin1(),
                                                        path.toLatin1(),
                                                        interface.toLatin1(),
                                                        method.toLatin1());
    DBusMessageIter dbus_iter;

    // Append variants to DBUS message
    QList<QVariant> arglist;
    if (arg1.isValid()) arglist << arg1;
    if (arg2.isValid()) arglist << arg2;
    if (arg3.isValid()) arglist << arg3;
    if (arg4.isValid()) arglist << arg4;
    if (arg5.isValid()) arglist << arg5;
    if (arg6.isValid()) arglist << arg6;
    if (arg7.isValid()) arglist << arg7;
    if (arg8.isValid()) arglist << arg8;

    dbus_message_iter_init_append (message, &dbus_iter);
    
    while (!arglist.isEmpty()) {
        QVariant argument = arglist.takeFirst();
        appendVariantToDBusMessage(argument, &dbus_iter);
    }

    return message;
}

signalHandler()

static DBusHandlerResult Maemo::signalHandler ( DBusConnection *  connection, DBusMessage *  message, void *  object_ref  )

static

Definition at line 409 of file dbusdispatcher.cpp.

Referenced by Maemo::DBusDispatcher::setupDBus().

                                                          {
    (void)connection;
    QString interface;
    QString signal;
    DBusDispatcher *dispatcher = (DBusDispatcher *)object_ref;

    if (dbus_message_get_type(message) == DBUS_MESSAGE_TYPE_SIGNAL) {
        interface = dbus_message_get_interface(message);
        signal = dbus_message_get_member(message);
        
        QList<QVariant> arglist;
        DBusMessageIter dbus_iter;

        if (dbus_message_iter_init(message, &dbus_iter)) {
            // Read return arguments
            while (dbus_message_iter_get_arg_type (&dbus_iter) != DBUS_TYPE_INVALID) {
                arglist << getVariantFromDBusMessage(&dbus_iter);
                dbus_message_iter_next(&dbus_iter);
            }
        }

        dispatcher->emitSignalReceived(interface, signal, arglist);
        return DBUS_HANDLER_RESULT_HANDLED;
    }
    (void)message;
    return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}

variantToSignature()

static QString Maemo::variantToSignature ( const QVariant &  argument, bool  constantList = true  )

static

Definition at line 109 of file dbusdispatcher.cpp.

Referenced by appendVariantToDBusMessage().

                                                            {
    switch (argument.type()) {
        case QVariant::Bool:
            return "b";
        case QVariant::ByteArray:
            return "ay";
        case QVariant::Char:
            return "y";
        case QVariant::Int:
            return "i";
        case QVariant::UInt:
            return "u";
        case QVariant::StringList:
            return "as";
        case QVariant::String:
            return "s";
        case QVariant::LongLong:
            return "x";
        case QVariant::ULongLong:
            return "t";
        case QVariant::List:
            {
            QString signature;
            QVariantList variantList = argument.toList();
            if (!constantList) {
                signature += DBUS_STRUCT_BEGIN_CHAR_AS_STRING;
                foreach(QVariant listItem, variantList) {
                    signature += variantToSignature(listItem);
                }
                signature += DBUS_STRUCT_END_CHAR_AS_STRING;
            } else {
                if (variantList.isEmpty())
                    return "";
                signature = "a" + variantToSignature(variantList[0]);
            }

            return signature;
            }
        default:
            qDebug() << "Unsupported variant type: " << argument.type();
            break;
    }

    return "";
}

Variable Documentation

lock

QReadWriteLock Maemo::lock

static

Definition at line 399 of file proxyconf.cpp.

Referenced by QSocks5BindStore::add(), QUrl::addEncodedQueryItem(), QUrl::addQueryItem(), QDir::addResourceSearchPath(), QResource::addSearchPath(), QUrl::allEncodedQueryItemValues(), QPatternist::NamePool::allocateLocalName(), QPatternist::NamePool::allocateNamespace(), QPatternist::NamePool::allocatePrefix(), QUrl::allQueryItemValues(), QDeclarativeMetaType::attachedPropertiesFuncById(), QDeclarativeMetaType::attachedPropertiesFuncId(), QAudioInputPrivate::audioDeviceError(), QAudioOutputPrivate::audioDeviceError(), QAudioInputPrivate::audioDeviceFull(), QAudioOutputPrivate::audioDeviceIdle(), QUrl::authority(), QWindowsPipeWriter::bytesToWrite(), QGL2GradientCacheWrapper::cacheForContext(), QGL2GradientCache::cleanCache(), QFontEngineQPF::cleanUpAfterClientCrash(), QSocks5BindStore::contains(), QDeclarativeMetaType::customStringConverter(), QUrl::detach(), QNetworkSession::disconnectNotify(), QFutureInterfaceBasePrivate::disconnectOutputInterface(), QBlittable::drawPixmapOpacity(), QUrl::encodedFragment(), QUrl::encodedPassword(), QUrl::encodedPath(), QUrl::encodedQuery(), QUrl::encodedQueryItems(), QUrl::encodedQueryItemValue(), QUrl::encodedUserName(), QResourcePrivate::ensureInitialized(), QUrl::errorString(), QBlittablePixmapData::fill(), QUrl::fragment(), QGL2GradientCache::getBuffer(), QGradientCache::getBuffer(), QWSDisplay::grab(), QWSDisplay::grabbed(), QUrl::hasEncodedQueryItem(), QUrl::hasFragment(), QUrl::hasQuery(), QUrl::host(), QDeclarativeTypePrivate::init(), QWSDisplay::initLock(), QAudioOutputPrivate::inputReady(), QDeclarativeMetaType::interfaceIId(), QtSharedPointer::internalSafetyCheckRemove(), QUrl::isEmpty(), QDeclarativeMetaType::isInterface(), QDeclarativeMetaType::isList(), QUrl::isLocalFile(), QUrl::isParentOf(), QDeclarativeMetaType::isQObject(), QUrl::isRelative(), QFutureInterfaceBase::isResultReadyAt(), QSslCertificate::issuerInfo(), QUrl::isValid(), QDeclarativeMetaType::listType(), QResourcePrivate::load(), QReadWriteLock::lockForRead(), QReadWriteLock::lockForWrite(), QMutex::lockInline(), QDBusConnection::objectRegisteredAt(), QDeclarativeMetaType::parentFunctions(), QUrl::password(), QUrl::path(), QUrl::port(), QWSKeyboardHandler::processKeycode(), QBlitterPaintEnginePrivate::QBlitterPaintEnginePrivate(), QDeclarativeMetaType::qmlComponents(), QDeclarativeMetaType::qmlType(), QDeclarativeMetaType::qmlTypeNames(), QDeclarativeMetaType::qmlTypes(), qRegisterResourceData(), qt_adopted_thread_watcher_function(), qt_watch_adopted_thread(), QUrl::queryItems(), qUnregisterResourceData(), QDirectPainter::region(), registerAutoParentFunction(), registerComponent(), QDeclarativeMetaType::registerCustomStringConverter(), registerInterface(), QResource::registerResource(), registerType(), QUrl::removeAllEncodedQueryItems(), QUrl::removeEncodedQueryItem(), QFutureInterfaceBase::resultCount(), QFutureInterface< T >::resultPointer(), QFutureInterface< T >::resultReference(), QFutureInterface< T >::results(), QSocks5BindStore::retrieve(), QUrl::scheme(), QResource::searchPaths(), QSslCertificate::serialNumber(), QGlobalNetworkProxy::setApplicationProxy(), QGlobalNetworkProxy::setApplicationProxyFactory(), QUrl::setAuthority(), QUrl::setEncodedFragment(), QUrl::setEncodedPassword(), QUrl::setEncodedPath(), QUrl::setEncodedQuery(), QUrl::setEncodedQueryItems(), QUrl::setEncodedUrl(), QUrl::setEncodedUserName(), QUrl::setFragment(), QUrl::setHost(), QWSIdentifyCommand::setId(), QUrl::setPassword(), QUrl::setPath(), QUrl::setPort(), QUrl::setQueryDelimiters(), QUrl::setQueryItems(), QUrl::setScheme(), QFutureInterfaceBase::setThrottled(), QUrl::setUrl(), QUrl::setUserInfo(), QUrl::setUserName(), QProcessPrivate::startProcess(), QPatternist::NamePool::stringForLocalName(), QPatternist::NamePool::stringForNamespace(), QPatternist::NamePool::stringForPrefix(), QSslCertificate::subjectInfo(), QSocks5BindStore::timerEvent(), QUrl::toEncoded(), QPatternist::NamePool::toLexical(), QUrl::toLocalFile(), QUrl::toString(), QReadWriteLock::tryLockForRead(), QReadWriteLock::tryLockForWrite(), QDeclarativeMetaType::typeCategory(), QWSDisplay::ungrab(), QReadWriteLock::unlock(), QResource::unregisterResource(), QUrl::userInfo(), QUrl::userName(), QSslCertificate::version(), QFutureInterfaceBase::waitForFinished(), QFutureInterfaceBase::waitForNextResult(), QFutureInterfaceBase::waitForResult(), QFutureInterfaceBase::waitForResume(), and QWSDisplay::~QWSDisplay().

refcount

int Maemo::refcount = 0

static

Definition at line 398 of file proxyconf.cpp.

Referenced by QStyleSheetStyle::deref(), QStyleSheetStyle::ref(), and QGraphicsAnchorLayoutPrivate::removeAnchor().