C# Qyoto.QVariant類代碼示例

        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);
 }