protected QVariant ItemChange(GraphicsItemChange change, QVariant val)
        {
            if (change == GraphicsItemChange.ItemPositionHasChanged) {
                foreach (EdgeItem ein in inList) {
                    ein.SetToPoint(X(), Y());
                }
                foreach (EdgeItem eout in outList) {
                    eout.SetFromPoint(X(), Y());
                }
            }

            return base.ItemChange(change, val);
        }

 public void SetKeyValueAt(double step, QVariant value)
 {
     interceptor.Invoke("setKeyValueAt$#", "setKeyValueAt(qreal, const QVariant&)", typeof(void), typeof(double), step, typeof(QVariant), value);
 }

 protected virtual void SetExtension(QGraphicsItem.Extension extension, QVariant variant)
 {
     interceptor.Invoke("setExtension$#", "setExtension(QGraphicsItem::Extension, const QVariant&)", typeof(void), typeof(QGraphicsItem.Extension), extension, typeof(QVariant), variant);
 }

 protected virtual QVariant extension(QVariant variant)
 {
     return (QVariant) interceptor.Invoke("extension#", "extension(const QVariant&) const", typeof(QVariant), typeof(QVariant), variant);
 }

 public static QDataStream Write(QDataStream s, QVariant.TypeOf p)
 {
     return (QDataStream) staticInterceptor.Invoke("operator<<#$", "operator<<(QDataStream&, const QVariant::Type)", typeof(QDataStream), typeof(QDataStream), s, typeof(QVariant.TypeOf), p);
 }

 public static QDBusArgument Read(QDBusArgument a, QVariant v)
 {
     return (QDBusArgument) staticInterceptor.Invoke("operator>>##", "operator>>(const QDBusArgument&, QVariant&)", typeof(QDBusArgument), typeof(QDBusArgument), a, typeof(QVariant), v);
 }

 /// <remarks>
 ///  Sets a value for a data source. If the source
 ///  doesn't exist then it is created.
 /// <param> name="source" the name of the data source
 /// </param><param> name="key" the key to use for the data
 /// </param><param> name="value" the data to associated with the source
 /// </param></remarks>        <short>    Sets a value for a data source.</short>
 protected void SetData(string source, string key, QVariant value)
 {
     interceptor.Invoke("setData$$#", "setData(const QString&, const QString&, const QVariant&)", typeof(void), typeof(string), source, typeof(string), key, typeof(QVariant), value);
 }

 public virtual string DisplayText(QVariant value, QLocale locale)
 {
     return (string) interceptor.Invoke("displayText##", "displayText(const QVariant&, const QLocale&) const", typeof(string), typeof(QVariant), value, typeof(QLocale), locale);
 }

 public abstract void SetProperty(QPrintEngine.PrintEnginePropertyKey key, QVariant value);

 /// <remarks>
 ///  Will create an invalid Variant if other has an unsupported type.
 ///          </remarks>        <short>    Will create an invalid Variant if other has an unsupported type.</short>
 public Variant(QVariant other)
     : this((Type) null)
 {
     CreateProxy();
     interceptor.Invoke("Variant#", "Variant(const QVariant&)", typeof(void), typeof(QVariant), other);
 }

 public override bool SetHeaderData(int section, Qt.Orientation orientation, QVariant value)
 {
     return (bool) interceptor.Invoke("setHeaderData$$#", "setHeaderData(int, Qt::Orientation, const QVariant&)", typeof(bool), typeof(int), section, typeof(Qt.Orientation), orientation, typeof(QVariant), value);
 }

 public override bool SetData(QModelIndex index, QVariant value)
 {
     return (bool) interceptor.Invoke("setData##", "setData(const QModelIndex&, const QVariant&)", typeof(bool), typeof(QModelIndex), index, typeof(QVariant), value);
 }

 protected abstract void UpdateCurrentValue(QVariant value);

 protected virtual QVariant Interpolated(QVariant from, QVariant to, double progress)
 {
     return (QVariant) interceptor.Invoke("interpolated##$", "interpolated(const QVariant&, const QVariant&, qreal) const", typeof(QVariant), typeof(QVariant), from, typeof(QVariant), to, typeof(double), progress);
 }

 public bool Write(QObject arg1, QVariant value)
 {
     return (bool) interceptor.Invoke("write##", "write(QObject*, const QVariant&) const", typeof(bool), typeof(QObject), arg1, typeof(QVariant), value);
 }

 /// <remarks>
 ///  Sets data to be used internally by the associated
 ///  AbstractRunner.
 ///  When set, it is also used to form
 ///  part of the id() for this match. If that is innapropriate
 ///  as an id, the runner may generate its own id and set that
 ///  with setId(string) directly after calling setData
 ///          </remarks>        <short>    Sets data to be used internally by the associated  AbstractRunner.</short>
 public void SetData(QVariant data)
 {
     interceptor.Invoke("setData#", "setData(const QVariant&)", typeof(void), typeof(QVariant), data);
 }

 /// <remarks>
 ///  Reimplemented from QGraphicsItem
 ///          </remarks>        <short>    Reimplemented from QGraphicsItem          </short>
 protected virtual QVariant ItemChange(QGraphicsItem.GraphicsItemChange change, QVariant value)
 {
     Object[] parameters = new Object[2];
     parameters[0] = change;
     parameters[1] = value;
     return (QVariant) appletType.GetMethod("ItemChange").Invoke(applet, parameters);
 }

 public static void QDBusReplyFill(QDBusMessage reply, QDBusError error, QVariant data)
 {
     staticInterceptor.Invoke("qDBusReplyFill###", "qDBusReplyFill(const QDBusMessage&, QDBusError&, QVariant&)", typeof(void), typeof(QDBusMessage), reply, typeof(QDBusError), error, typeof(QVariant), data);
 }

 public void AssignProperty(QObject arg1, string name, QVariant value)
 {
     interceptor.Invoke("assignProperty#$#", "assignProperty(QObject*, const char*, const QVariant&)", typeof(void), typeof(QObject), arg1, typeof(string), name, typeof(QVariant), value);
 }

 public EffectParameter(int parameterId, string name, uint hints, QVariant defaultValue, QVariant min, QVariant max, List<QVariant> values)
     : this((Type) null)
 {
     CreateProxy();
     interceptor.Invoke("EffectParameter$$$###?", "EffectParameter(int, const QString&, Phonon::EffectParameter::Hints, const QVariant&, const QVariant&, const QVariant&, const QList<QVariant>&)", typeof(void), typeof(int), parameterId, typeof(string), name, typeof(uint), hints, typeof(QVariant), defaultValue, typeof(QVariant), min, typeof(QVariant), max, typeof(List<QVariant>), values);
 }