src/contrib/libqxt-2007-10-24/src/core/qxtboundcfunction.h

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) Qxt Foundation. Some rights reserved.
   4 **
   5 ** This file is part of the QxtCore module of the Qt eXTension library
   6 **
   7 ** This library is free software; you can redistribute it and/or modify it
   8 ** under the terms of th Common Public License, version 1.0, as published by
   9 ** IBM.
  10 **
  11 ** This file is provided "AS IS", without WARRANTIES OR CONDITIONS OF ANY
  12 ** KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY
  13 ** WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR
  14 ** FITNESS FOR A PARTICULAR PURPOSE.
  15 **
  16 ** You should have received a copy of the CPL along with this file.
  17 ** See the LICENSE file and the cpl1.0.txt file included with the source
  18 ** distribution for more information. If you did not receive a copy of the
  19 ** license, contact the Qxt Foundation.
  20 **
  21 ** <http://libqxt.sourceforge.net>  <foundation@libqxt.org>
  22 **
  23 ****************************************************************************/
  24
  25 #ifndef QXTBOUNDCFUNCTION_H
  26 #define QXTBOUNDCFUNCTION_H
  27
  28 #include <qxtboundfunctionbase.h>
  29 #include <qxtmetatype.h>
  30 #include <QtDebug>
  31
  32 #ifndef QXT_DOXYGEN_RUN
  33
  34 #define QXT_RETURN(fp) *reinterpret_cast<RETURN*>(returnValue.data()) = (*reinterpret_cast<FUNCTION>(fp))
  35 #define QXT_INVOKE(fp) (*reinterpret_cast<FUNCTION>(fp))
  36 #define QXT_PARAM(i) *reinterpret_cast<T ## i *>(p ## i .data())
  37
  38 template <typename RETURN, typename T1 = void, typename T2 = void, typename T3 = void, typename T4 = void, typename T5 = void,
  39           typename T6 = void, typename T7 = void, typename T8 = void, typename T9 = void, typename T10 = void>
  40 class qxt_cfunction_return : public QxtGenericFunctionPointer {
  41 public:
  42     typedef RETURN(*FUNCTION)(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10);
  43     bool invoke(QGenericReturnArgument returnValue, QXT_PROTO_10ARGS(QGenericArgument)) {
  44         QXT_10_UNUSED;
  45         QXT_RETURN (funcPtr)(QXT_PARAM(1), QXT_PARAM(2), QXT_PARAM(3), QXT_PARAM(4), QXT_PARAM(5), QXT_PARAM(6), QXT_PARAM(7), QXT_PARAM(8), QXT_PARAM(9), QXT_PARAM(10));
  46         return true;
  47     }
  48 };
  49
  50 template <typename RETURN>
  51 class qxt_cfunction_return<RETURN, void, void, void, void, void, void, void, void, void, void> : public QxtGenericFunctionPointer {
  52 public:
  53     typedef RETURN(*FUNCTION)();
  54     bool invoke(QGenericReturnArgument returnValue, QXT_PROTO_10ARGS(QGenericArgument)) {
  55         QXT_10_UNUSED;
  56         QXT_RETURN (funcPtr)();
  57         return true;
  58     }
  59 };
  60
  61 template <typename RETURN, typename T1>
  62 class qxt_cfunction_return<RETURN, T1, void, void, void, void, void, void, void, void, void> : public QxtGenericFunctionPointer {
  63 public:
  64     typedef RETURN(*FUNCTION)(T1);
  65     bool invoke(QGenericReturnArgument returnValue, QXT_PROTO_10ARGS(QGenericArgument)) {
  66         QXT_10_UNUSED;
  67         QXT_RETURN (funcPtr)(QXT_PARAM(1));
  68         return true;
  69     }
  70 };
  71
  72 template <typename RETURN, typename T1, typename T2>
  73 class qxt_cfunction_return<RETURN, T1, T2, void, void, void, void, void, void, void, void> : public QxtGenericFunctionPointer {
  74 public:
  75     typedef RETURN(*FUNCTION)(T1, T2);
  76     bool invoke(QGenericReturnArgument returnValue, QXT_PROTO_10ARGS(QGenericArgument)) {
  77         QXT_10_UNUSED;
  78         QXT_RETURN (funcPtr)(QXT_PARAM(1), QXT_PARAM(2));
  79         return true;
  80     }
  81 };
  82
  83 template <typename RETURN, typename T1, typename T2, typename T3>
  84 class qxt_cfunction_return<RETURN, T1, T2, T3, void, void, void, void, void, void, void> : public QxtGenericFunctionPointer {
  85 public:
  86     typedef RETURN(*FUNCTION)(T1, T2, T3);
  87     bool invoke(QGenericReturnArgument returnValue, QXT_PROTO_10ARGS(QGenericArgument)) {
  88         QXT_10_UNUSED;
  89         QXT_RETURN (funcPtr)(QXT_PARAM(1), QXT_PARAM(2), QXT_PARAM(3));
  90         return true;
  91     }
  92 };
  93
  94 template <typename RETURN, typename T1, typename T2, typename T3, typename T4>
  95 class qxt_cfunction_return<RETURN, T1, T2, T3, T4, void, void, void, void, void, void> : public QxtGenericFunctionPointer {
  96 public:
  97     typedef RETURN(*FUNCTION)(T1, T2, T3, T4);
  98     bool invoke(QGenericReturnArgument returnValue, QXT_PROTO_10ARGS(QGenericArgument)) {
  99         QXT_10_UNUSED;
 100         QXT_RETURN (funcPtr)(QXT_PARAM(1), QXT_PARAM(2), QXT_PARAM(3), QXT_PARAM(4));
 101         return true;
 102     }
 103 };
 104
 105 template <typename RETURN, typename T1, typename T2, typename T3, typename T4, typename T5>
 106 class qxt_cfunction_return<RETURN, T1, T2, T3, T4, T5, void, void, void, void, void> : public QxtGenericFunctionPointer {
 107 public:
 108     typedef RETURN(*FUNCTION)(T1, T2, T3, T4, T5);
 109     bool invoke(QGenericReturnArgument returnValue, QXT_PROTO_10ARGS(QGenericArgument)) {
 110         QXT_10_UNUSED;
 111         QXT_RETURN (funcPtr)(QXT_PARAM(1), QXT_PARAM(2), QXT_PARAM(3), QXT_PARAM(4), QXT_PARAM(5));
 112         return true;
 113     }
 114 };
 115
 116 template <typename RETURN, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
 117 class qxt_cfunction_return<RETURN, T1, T2, T3, T4, T5, T6, void, void, void, void> : public QxtGenericFunctionPointer {
 118 public:
 119     typedef RETURN(*FUNCTION)(T1, T2, T3, T4, T5, T6);
 120     bool invoke(QGenericReturnArgument returnValue, QXT_PROTO_10ARGS(QGenericArgument)) {
 121         QXT_10_UNUSED;
 122         QXT_RETURN (funcPtr)(QXT_PARAM(1), QXT_PARAM(2), QXT_PARAM(3), QXT_PARAM(4), QXT_PARAM(5), QXT_PARAM(6));
 123         return true;
 124     }
 125 };
 126
 127 template <typename RETURN, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
 128 class qxt_cfunction_return<RETURN, T1, T2, T3, T4, T5, T6, T7, void, void, void> : public QxtGenericFunctionPointer {
 129 public:
 130     typedef RETURN(*FUNCTION)(T1, T2, T3, T4, T5, T6, T7);
 131     bool invoke(QGenericReturnArgument returnValue, QXT_PROTO_10ARGS(QGenericArgument)) {
 132         QXT_10_UNUSED;
 133         QXT_RETURN (funcPtr)(QXT_PARAM(1), QXT_PARAM(2), QXT_PARAM(3), QXT_PARAM(4), QXT_PARAM(5), QXT_PARAM(6), QXT_PARAM(7));
 134         return true;
 135     }
 136 };
 137
 138 template <typename RETURN, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
 139 class qxt_cfunction_return<RETURN, T1, T2, T3, T4, T5, T6, T7, T8, void, void> : public QxtGenericFunctionPointer {
 140 public:
 141     typedef RETURN(*FUNCTION)(T1, T2, T3, T4, T5, T6, T7, T8);
 142     bool invoke(QGenericReturnArgument returnValue, QXT_PROTO_10ARGS(QGenericArgument)) {
 143         QXT_10_UNUSED;
 144         QXT_RETURN (funcPtr)(QXT_PARAM(1), QXT_PARAM(2), QXT_PARAM(3), QXT_PARAM(4), QXT_PARAM(5), QXT_PARAM(6), QXT_PARAM(7), QXT_PARAM(8));
 145         return true;
 146     }
 147 };
 148
 149 template <typename RETURN, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
 150 class qxt_cfunction_return<RETURN, T1, T2, T3, T4, T5, T6, T7, T8, T9, void> : public QxtGenericFunctionPointer {
 151 public:
 152     typedef RETURN(*FUNCTION)(T1, T2, T3, T4, T5, T6, T7, T8, T9);
 153     bool invoke(QGenericReturnArgument returnValue, QXT_PROTO_10ARGS(QGenericArgument)) {
 154         QXT_10_UNUSED;
 155         QXT_RETURN (funcPtr)(QXT_PARAM(1), QXT_PARAM(2), QXT_PARAM(3), QXT_PARAM(4), QXT_PARAM(5), QXT_PARAM(6), QXT_PARAM(7), QXT_PARAM(8), QXT_PARAM(9));
 156         return true;
 157     }
 158 };
 159
 160 template <typename T1 = void, typename T2 = void, typename T3 = void, typename T4 = void, typename T5 = void,
 161           typename T6 = void, typename T7 = void, typename T8 = void, typename T9 = void, typename T10 = void>
 162 class qxt_cfunction : public QxtGenericFunctionPointer {
 163 public:
 164     typedef void(*FUNCTION)(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10);
 165     bool invoke(QXT_PROTO_10ARGS(QGenericArgument)) {
 166         QXT_10_UNUSED;
 167         QXT_INVOKE (funcPtr)(QXT_PARAM(1), QXT_PARAM(2), QXT_PARAM(3), QXT_PARAM(4), QXT_PARAM(5), QXT_PARAM(6), QXT_PARAM(7), QXT_PARAM(8), QXT_PARAM(9), QXT_PARAM(10));
 168         return true;
 169     }
 170 };
 171
 172 template <>
 173 class qxt_cfunction<void, void, void, void, void, void, void, void, void, void> : public QxtGenericFunctionPointer {
 174 public:
 175     typedef void(*FUNCTION)();
 176     bool invoke(QXT_PROTO_10ARGS(QGenericArgument)) {
 177         QXT_10_UNUSED;
 178         QXT_INVOKE (funcPtr)();
 179         return true;
 180     }
 181 };
 182
 183 template <typename T1>
 184 class qxt_cfunction<T1, void, void, void, void, void, void, void, void, void> : public QxtGenericFunctionPointer {
 185 public:
 186     typedef void(*FUNCTION)(T1);
 187     bool invoke(QXT_PROTO_10ARGS(QGenericArgument)) {
 188         QXT_10_UNUSED;
 189         QXT_INVOKE (funcPtr)(QXT_PARAM(1));
 190         return true;
 191     }
 192 };
 193
 194 template <typename T1, typename T2>
 195 class qxt_cfunction<T1, T2, void, void, void, void, void, void, void, void> : public QxtGenericFunctionPointer {
 196 public:
 197     typedef void(*FUNCTION)(T1, T2);
 198     bool invoke(QXT_PROTO_10ARGS(QGenericArgument)) {
 199         QXT_10_UNUSED;
 200         QXT_INVOKE (funcPtr)(QXT_PARAM(1), QXT_PARAM(2));
 201         return true;
 202     }
 203 };
 204
 205 template <typename T1, typename T2, typename T3>
 206 class qxt_cfunction<T1, T2, T3, void, void, void, void, void, void, void> : public QxtGenericFunctionPointer {
 207 public:
 208     typedef void(*FUNCTION)(T1, T2, T3);
 209     bool invoke(QXT_PROTO_10ARGS(QGenericArgument)) {
 210         QXT_10_UNUSED;
 211         QXT_INVOKE (funcPtr)(QXT_PARAM(1), QXT_PARAM(2), QXT_PARAM(3));
 212         return true;
 213     }
 214 };
 215
 216 template <typename T1, typename T2, typename T3, typename T4>
 217 class qxt_cfunction<T1, T2, T3, T4, void, void, void, void, void, void> : public QxtGenericFunctionPointer {
 218 public:
 219     typedef void(*FUNCTION)(T1, T2, T3, T4);
 220     bool invoke(QXT_PROTO_10ARGS(QGenericArgument)) {
 221         QXT_10_UNUSED;
 222         QXT_INVOKE (funcPtr)(QXT_PARAM(1), QXT_PARAM(2), QXT_PARAM(3), QXT_PARAM(4));
 223         return true;
 224     }
 225 };
 226
 227 template <typename T1, typename T2, typename T3, typename T4, typename T5>
 228 class qxt_cfunction<T1, T2, T3, T4, T5, void, void, void, void, void> : public QxtGenericFunctionPointer {
 229 public:
 230     typedef void(*FUNCTION)(T1, T2, T3, T4, T5);
 231     bool invoke(QXT_PROTO_10ARGS(QGenericArgument)) {
 232         QXT_10_UNUSED;
 233         QXT_INVOKE (funcPtr)(QXT_PARAM(1), QXT_PARAM(2), QXT_PARAM(3), QXT_PARAM(4), QXT_PARAM(5));
 234         return true;
 235     }
 236 };
 237
 238 template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
 239 class qxt_cfunction<T1, T2, T3, T4, T5, T6, void, void, void, void> : public QxtGenericFunctionPointer {
 240 public:
 241     typedef void(*FUNCTION)(T1, T2, T3, T4, T5, T6);
 242     bool invoke(QXT_PROTO_10ARGS(QGenericArgument)) {
 243         QXT_10_UNUSED;
 244         QXT_INVOKE (funcPtr)(QXT_PARAM(1), QXT_PARAM(2), QXT_PARAM(3), QXT_PARAM(4), QXT_PARAM(5), QXT_PARAM(6));
 245         return true;
 246     }
 247 };
 248
 249 template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
 250 class qxt_cfunction<T1, T2, T3, T4, T5, T6, T7, void, void, void> : public QxtGenericFunctionPointer {
 251 public:
 252     typedef void(*FUNCTION)(T1, T2, T3, T4, T5, T6, T7);
 253     bool invoke(QXT_PROTO_10ARGS(QGenericArgument)) {
 254         QXT_10_UNUSED;
 255         QXT_INVOKE (funcPtr)(QXT_PARAM(1), QXT_PARAM(2), QXT_PARAM(3), QXT_PARAM(4), QXT_PARAM(5), QXT_PARAM(6), QXT_PARAM(7));
 256         return true;
 257     }
 258 };
 259
 260 template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
 261 class qxt_cfunction<T1, T2, T3, T4, T5, T6, T7, T8, void, void> : public QxtGenericFunctionPointer {
 262 public:
 263     typedef void(*FUNCTION)(T1, T2, T3, T4, T5, T6, T7, T8);
 264     bool invoke(QXT_PROTO_10ARGS(QGenericArgument)) {
 265         QXT_10_UNUSED;
 266         QXT_INVOKE (funcPtr)(QXT_PARAM(1), QXT_PARAM(2), QXT_PARAM(3), QXT_PARAM(4), QXT_PARAM(5), QXT_PARAM(6), QXT_PARAM(7), QXT_PARAM(8));
 267         return true;
 268     }
 269 };
 270
 271 template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
 272 class qxt_cfunction<T1, T2, T3, T4, T5, T6, T7, T8, T9, void> : public QxtGenericFunctionPointer {
 273 public:
 274     typedef void(*FUNCTION)(T1, T2, T3, T4, T5, T6, T7, T8, T9);
 275     bool invoke(QXT_PROTO_10ARGS(QGenericArgument)) {
 276         QXT_10_UNUSED;
 277         QXT_INVOKE (funcPtr)(QXT_PARAM(1), QXT_PARAM(2), QXT_PARAM(3), QXT_PARAM(4), QXT_PARAM(5), QXT_PARAM(6), QXT_PARAM(7), QXT_PARAM(8), QXT_PARAM(9));
 278         return true;
 279     }
 280 };
 281
 282 template <typename RETURN = void, typename T1 = void, typename T2 = void, typename T3 = void, typename T4 = void, typename T5 = void,
 283           typename T6 = void, typename T7 = void, typename T8 = void, typename T9 = void, typename T10 = void>
 284 class QxtBoundCFunction : public QxtBoundFunctionBase {
 285 public:
 286     QxtGenericFunctionPointer funcPtr;
 287
 288     QxtBoundCFunction(QObject* parent, QxtGenericFunctionPointer funcPointer, QGenericArgument* params[10], QByteArray types[10]) : QxtBoundFunctionBase(parent, params, types), funcPtr(funcPointer) {
 289         // initializers only, thanks to template magic
 290     }
 291
 292     virtual bool invokeImpl(Qt::ConnectionType type, QGenericReturnArgument returnValue, QXT_IMPL_10ARGS(QGenericArgument)) {
 293         if(type != Qt::AutoConnection && type != Qt::DirectConnection) {
 294             qWarning() << "WxtBoundCFunction::invoke: Cannot invoke non-Qt functions using a queued connection";
 295             return false;
 296         }
 297         return reinterpret_cast<qxt_cfunction_return<RETURN, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>*>(&funcPtr)->invoke(returnValue, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
 298     }
 299 };
 300
 301 template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
 302 class QxtBoundCFunction<void, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> : public QxtBoundFunctionBase {
 303 public:
 304     QxtGenericFunctionPointer funcPtr;
 305
 306     QxtBoundCFunction(QObject* parent, QxtGenericFunctionPointer funcPointer, QGenericArgument* params[10], QByteArray types[10]) : QxtBoundFunctionBase(parent, params, types), funcPtr(funcPointer) {
 307         // initializers only, thanks to template magic
 308     }
 309
 310     virtual bool invokeImpl(Qt::ConnectionType type, QGenericReturnArgument returnValue, QXT_IMPL_10ARGS(QGenericArgument)) {
 311         Q_UNUSED(returnValue);
 312         if(type != Qt::AutoConnection && type != Qt::DirectConnection) {
 313             qWarning() << "WxtBoundCFunction::invoke: Cannot invoke non-Qt functions using a queued connection";
 314             return false;
 315         }
 316         return reinterpret_cast<qxt_cfunction<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>*>(&funcPtr)->invoke(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
 317     }
 318 };
 319
 320 #undef QXT_RETURN
 321 #undef QXT_INVOKE
 322 #undef QXT_PARAM
 323 #endif
 324
 325 namespace QxtMetaObject {
 326 /**
 327  * \relates QxtMetaObject
 328  * \sa QxtMetaObject::connect
 329  * \sa qxtFuncPtr
 330  * \sa QxtBoundFunction
 331  * \sa QXT_BIND
 332  *
 333  * Creates a binding to the provided C/C++ function using the provided parameter list.
 334  * Use the qxtFuncPtr function to wrap a bare function pointer for use in this function.
 335  * Use the Q_ARG macro to specify constant parameters, or use the QXT_BIND macro to
 336  * relay a parameter from a connected signal or passed via the QxtBoundFunction::invoke()
 337  * method.
 338  *
 339  * The first template parameter must match the return type of the function, or
 340  * void if the function does not return a value. The remaining template parameters must
 341  * match the types of the function's parameters. If any type does not match, this
 342  * function returns NULL.
 343  *
 344  * The returned QxtBoundFunction will not have a parent. Assigning a parent using
 345  * QObject::setParent() is strongly recommended to avoid memory leaks.
 346  */
 347 template <typename RETURN, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
 348 QxtBoundFunction* bind(QxtGenericFunctionPointer funcPointer, QXT_IMPL_10ARGS(QGenericArgument)) {
 349     // Make sure the template parameters make a function pointer equivalent to the one passed in
 350     if(funcPointer.typeName != typeid(typename qxt_cfunction_return<RETURN, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::FUNCTION).name()) {
 351         qWarning() << "QxtMetaObject::bind: parameter list mismatch, check template arguments";
 352         return 0;
 353     }
 354
 355     QGenericArgument* args[10] = { &p1, &p2, &p3, &p4, &p5, &p6, &p7, &p8, &p9, &p10 };
 356     for (int i=0; i<10; i++)
 357     {
 358         if (args[i]->name() == 0) break;        // done
 359         if (QByteArray(args[i]->name()) == "QxtBoundArgument")
 360         {
 361             Q_ASSERT_X((quintptr)(args[i]->data()) > 0 && (quintptr)(args[i]->data()) <= 10, "QXT_BIND", "invalid argument number");
 362         }
 363     }
 364
 365     QByteArray types[10];
 366     types[0] = QxtMetaType<T1>::name();
 367     types[1] = QxtMetaType<T2>::name();
 368     types[2] = QxtMetaType<T3>::name();
 369     types[3] = QxtMetaType<T4>::name();
 370     types[4] = QxtMetaType<T5>::name();
 371     types[5] = QxtMetaType<T6>::name();
 372     types[6] = QxtMetaType<T7>::name();
 373     types[7] = QxtMetaType<T8>::name();
 374     types[8] = QxtMetaType<T9>::name();
 375     types[9] = QxtMetaType<T10>::name();
 376
 377     return new QxtBoundCFunction<RETURN, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(0, funcPointer, args, types);
 378 }
 379
 380 /**
 381  * \relates QxtMetaObject
 382  * \sa QxtMetaObject::connect
 383  * \sa qxtFuncPtr
 384  * \sa QxtBoundFunction
 385  *
 386  * Creates a binding to the provided C/C++ function using the provided parameter list.
 387  * Use the qxtFuncPtr function to wrap a bare function pointer for use in this function.
 388  * The type of each argument is deduced from the type of the QVariant. This function
 389  * cannot bind positional arguments; see the overload using QGenericArgument.
 390  *
 391  * The first template parameter must match the return type of the function, or
 392  * void if the function does not return a value. The remaining template parameters must
 393  * match the types of the function's parameters. If any type does not match, this
 394  * function returns NULL.
 395  *
 396  * The returned QxtBoundFunction will not have a parent. Assigning a parent using
 397  * QObject::setParent() is strongly recommended to avoid memory leaks.
 398  */
 399 template <typename RETURN, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
 400 QxtBoundFunction* bind(QxtGenericFunctionPointer funcPointer, QXT_IMPL_10ARGS(QVariant)) {
 401     QVariant* args[10] = { &p1, &p2, &p3, &p4, &p5, &p6, &p7, &p8, &p9, &p10 };
 402     return QxtMetaObject::bind<RETURN, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(funcPointer, QXT_VAR_ARG(1), QXT_VAR_ARG(2), QXT_VAR_ARG(3), QXT_VAR_ARG(4),
 403             QXT_VAR_ARG(5), QXT_VAR_ARG(6), QXT_VAR_ARG(7), QXT_VAR_ARG(8), QXT_VAR_ARG(9), QXT_VAR_ARG(10));
 404 }
 405
 406 // The following overloads exist because C++ doesn't support default parameters in function templates
 407 #ifndef QXT_DOXYGEN_RUN
 408 template <typename RETURN>
 409 inline QxtBoundFunction* bind(QxtGenericFunctionPointer funcPointer) {
 410     return bind<RETURN, void, void, void, void, void, void, void, void, void, void>(funcPointer,
 411             QGenericArgument(), QGenericArgument(), QGenericArgument(), QGenericArgument(), QGenericArgument(), QGenericArgument(), QGenericArgument(), QGenericArgument(), QGenericArgument(), QGenericArgument());
 412 }
 413
 414 template <typename RETURN, typename T1>
 415 inline QxtBoundFunction* bind(QxtGenericFunctionPointer funcPointer, QGenericArgument p1) {
 416     return bind<RETURN, T1, void, void, void, void, void, void, void, void, void>(funcPointer,
 417             p1, QGenericArgument(), QGenericArgument(), QGenericArgument(), QGenericArgument(), QGenericArgument(), QGenericArgument(), QGenericArgument(), QGenericArgument(), QGenericArgument());
 418 }
 419
 420 template <typename RETURN, typename T1, typename T2>
 421 inline QxtBoundFunction* bind(QxtGenericFunctionPointer funcPointer, QGenericArgument p1, QGenericArgument p2) {
 422     return bind<RETURN, T1, T2, void, void, void, void, void, void, void, void>(funcPointer,
 423             p1, p2, QGenericArgument(), QGenericArgument(), QGenericArgument(), QGenericArgument(), QGenericArgument(), QGenericArgument(), QGenericArgument(), QGenericArgument());
 424 }
 425
 426 template <typename RETURN, typename T1, typename T2, typename T3>
 427 inline QxtBoundFunction* bind(QxtGenericFunctionPointer funcPointer, QGenericArgument p1, QGenericArgument p2, QGenericArgument p3) {
 428     return bind<RETURN, T1, T2, T3, void, void, void, void, void, void, void>(funcPointer,
 429             p1, p2, p3, QGenericArgument(), QGenericArgument(), QGenericArgument(), QGenericArgument(), QGenericArgument(), QGenericArgument(), QGenericArgument());
 430 }
 431
 432 template <typename RETURN, typename T1, typename T2, typename T3, typename T4>
 433 inline QxtBoundFunction* bind(QxtGenericFunctionPointer funcPointer, QGenericArgument p1, QGenericArgument p2, QGenericArgument p3, QGenericArgument p4) {
 434     return bind<RETURN, T1, T2, T3, T4, void, void, void, void, void, void>(funcPointer,
 435             p1, p2, p3, p4, QGenericArgument(), QGenericArgument(), QGenericArgument(), QGenericArgument(), QGenericArgument(), QGenericArgument());
 436 }
 437
 438 template <typename RETURN, typename T1, typename T2, typename T3, typename T4, typename T5>
 439 inline QxtBoundFunction* bind(QxtGenericFunctionPointer funcPointer, QGenericArgument p1, QGenericArgument p2, QGenericArgument p3, QGenericArgument p4, QGenericArgument p5) {
 440     return bind<RETURN, T1, T2, T3, T4, T5, void, void, void, void, void>(funcPointer,
 441             p1, p2, p3, p4, p5, QGenericArgument(), QGenericArgument(), QGenericArgument(), QGenericArgument(), QGenericArgument());
 442 }
 443
 444 template <typename RETURN, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
 445 inline QxtBoundFunction* bind(QxtGenericFunctionPointer funcPointer, QGenericArgument p1, QGenericArgument p2, QGenericArgument p3, QGenericArgument p4, QGenericArgument p5, QGenericArgument p6) {
 446     return bind<RETURN, T1, T2, T3, T4, T5, T6, void, void, void, void>(funcPointer,
 447             p1, p2, p3, p4, p5, p6, QGenericArgument(), QGenericArgument(), QGenericArgument(), QGenericArgument());
 448 }
 449
 450 template <typename RETURN, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
 451 inline QxtBoundFunction* bind(QxtGenericFunctionPointer funcPointer, QGenericArgument p1, QGenericArgument p2, QGenericArgument p3, QGenericArgument p4, QGenericArgument p5, QGenericArgument p6, QGenericArgument p7) {
 452     return bind<RETURN, T1, T2, T3, T4, T5, T6, T7, void, void, void>(funcPointer,
 453             p1, p2, p3, p4, p5, p6, p7, QGenericArgument(), QGenericArgument(), QGenericArgument());
 454 }
 455
 456 template <typename RETURN, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
 457 inline QxtBoundFunction* bind(QxtGenericFunctionPointer funcPointer, QGenericArgument p1, QGenericArgument p2, QGenericArgument p3, QGenericArgument p4, QGenericArgument p5,
 458         QGenericArgument p6, QGenericArgument p7, QGenericArgument p8) {
 459     return bind<RETURN, T1, T2, T3, T4, T5, T6, T7, T8, void, void>(funcPointer, p1, p2, p3, p4, p5, p6, p7, p8, QGenericArgument(), QGenericArgument());
 460 }
 461
 462 template <typename RETURN, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
 463 inline QxtBoundFunction* bind(QxtGenericFunctionPointer funcPointer, QGenericArgument p1, QGenericArgument p2, QGenericArgument p3, QGenericArgument p4, QGenericArgument p5,
 464         QGenericArgument p6, QGenericArgument p7, QGenericArgument p8, QGenericArgument p9) {
 465     return bind<RETURN, T1, T2, T3, T4, T5, T6, T7, T8, T9, void>(funcPointer, p1, p2, p3, p4, p5, p6, p7, p8, p9, QGenericArgument());
 466 }
 467
 468 template <typename RETURN, typename T1>
 469 inline QxtBoundFunction* bind(QxtGenericFunctionPointer funcPointer, QVariant p1) {
 470     return bind<RETURN, T1, void, void, void, void, void, void, void, void, void>(funcPointer, p1, QVariant(), QVariant(), QVariant(), QVariant(), QVariant(), QVariant(), QVariant(), QVariant(), QVariant());
 471 }
 472
 473 template <typename RETURN, typename T1, typename T2>
 474 inline QxtBoundFunction* bind(QxtGenericFunctionPointer funcPointer, QVariant p1, QVariant p2) {
 475     return bind<RETURN, T1, T2, void, void, void, void, void, void, void, void>(funcPointer, p1, p2, QVariant(), QVariant(), QVariant(), QVariant(), QVariant(), QVariant(), QVariant(), QVariant());
 476 }
 477
 478 template <typename RETURN, typename T1, typename T2, typename T3>
 479 inline QxtBoundFunction* bind(QxtGenericFunctionPointer funcPointer, QVariant p1, QVariant p2, QVariant p3) {
 480     return bind<RETURN, T1, T2, T3, void, void, void, void, void, void, void>(funcPointer, p1, p2, p3, QVariant(), QVariant(), QVariant(), QVariant(), QVariant(), QVariant(), QVariant());
 481 }
 482
 483 template <typename RETURN, typename T1, typename T2, typename T3, typename T4>
 484 inline QxtBoundFunction* bind(QxtGenericFunctionPointer funcPointer, QVariant p1, QVariant p2, QVariant p3, QVariant p4) {
 485     return bind<RETURN, T1, T2, T3, T4, void, void, void, void, void, void>(funcPointer, p1, p2, p3, p4, QVariant(), QVariant(), QVariant(), QVariant(), QVariant(), QVariant());
 486 }
 487
 488 template <typename RETURN, typename T1, typename T2, typename T3, typename T4, typename T5>
 489 inline QxtBoundFunction* bind(QxtGenericFunctionPointer funcPointer, QVariant p1, QVariant p2, QVariant p3, QVariant p4, QVariant p5) {
 490     return bind<RETURN, T1, T2, T3, T4, T5, void, void, void, void, void>(funcPointer, p1, p2, p3, p4, p5, QVariant(), QVariant(), QVariant(), QVariant(), QVariant());
 491 }
 492
 493 template <typename RETURN, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
 494 inline QxtBoundFunction* bind(QxtGenericFunctionPointer funcPointer, QVariant p1, QVariant p2, QVariant p3, QVariant p4, QVariant p5, QVariant p6) {
 495     return bind<RETURN, T1, T2, T3, T4, T5, T6, void, void, void, void>(funcPointer, p1, p2, p3, p4, p5, p6, QVariant(), QVariant(), QVariant(), QVariant());
 496 }
 497
 498 template <typename RETURN, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
 499 inline QxtBoundFunction* bind(QxtGenericFunctionPointer funcPointer, QVariant p1, QVariant p2, QVariant p3, QVariant p4, QVariant p5, QVariant p6, QVariant p7) {
 500     return bind<RETURN, T1, T2, T3, T4, T5, T6, T7, void, void, void>(funcPointer, p1, p2, p3, p4, p5, p6, p7, QVariant(), QVariant(), QVariant());
 501 }
 502
 503 template <typename RETURN, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
 504 inline QxtBoundFunction* bind(QxtGenericFunctionPointer funcPointer, QVariant p1, QVariant p2, QVariant p3, QVariant p4, QVariant p5, QVariant p6, QVariant p7, QVariant p8) {
 505     return bind<RETURN, T1, T2, T3, T4, T5, T6, T7, T8, void, void>(funcPointer, p1, p2, p3, p4, p5, p6, p7, p8, QVariant(), QVariant());
 506 }
 507
 508 template <typename RETURN, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
 509 inline QxtBoundFunction* bind(QxtGenericFunctionPointer funcPointer, QVariant p1, QVariant p2, QVariant p3, QVariant p4, QVariant p5, QVariant p6, QVariant p7, QVariant p8, QVariant p9) {
 510     return bind<RETURN, T1, T2, T3, T4, T5, T6, T7, T8, T9, void>(funcPointer, p1, p2, p3, p4, p5, p6, p7, p8, p9, QVariant());
 511 }
 512 #endif
 513 }
 514 #endif