C# Qyoto.StackItem类代码示例

 public static bool Connect(QObject sender, int signal_index, QObject receiver, int method_index, int type, ref int types)
 {
     StackItem[] stack = new StackItem[7];
     #if DEBUG
     stack[1].s_class = (IntPtr) DebugGCHandle.Alloc(sender);
     #else
     stack[1].s_class = (IntPtr) GCHandle.Alloc(sender);
     #endif
     stack[2].s_int = signal_index;
     #if DEBUG
     stack[3].s_class = (IntPtr) DebugGCHandle.Alloc(receiver);
     #else
     stack[3].s_class = (IntPtr) GCHandle.Alloc(receiver);
     #endif
     stack[4].s_int = method_index;
     stack[5].s_int = type;
     stack[6].s_int = types;
     staticInterceptor.Invoke("connect#$#$$$", "connect(const QObject*, int, const QObject*, int, int, int*)", stack);
     #if DEBUG
     DebugGCHandle.Free((GCHandle) stack[1].s_class);
     #else
     ((GCHandle) stack[1].s_class).Free();
     #endif
     #if DEBUG
     DebugGCHandle.Free((GCHandle) stack[3].s_class);
     #else
     ((GCHandle) stack[3].s_class).Free();
     #endif
     types = stack[6].s_int;
     return stack[0].s_bool;
 }

 public double CursorToX(ref int cursorPos)
 {
     StackItem[] stack = new StackItem[2];
     stack[1].s_int = cursorPos;
     interceptor.Invoke("cursorToX$", "cursorToX(int*) const", stack);
     cursorPos = stack[1].s_int;
     return stack[0].s_double;
 }

 protected void SetMetaTypes(int count, ref int metaTypes)
 {
     StackItem[] stack = new StackItem[3];
     stack[1].s_int = count;
     stack[2].s_int = metaTypes;
     interceptor.Invoke("setMetaTypes$$", "setMetaTypes(int, const int*)", stack);
     metaTypes = stack[2].s_int;
     return;
 }

 /// <remarks>
 ///  Extracts the code from the given Qt key.
 /// <param> name="keyQt" the qt key code
 /// </param><param> name="keyCode" if successful, the symbol will be written here
 /// </param></remarks>        <return> true if successful, false otherwise
 /// 	 </return>
 ///         <short>    Extracts the code from the given Qt key.</short>
 public static bool KeyQtToCodeX(int keyQt, ref int keyCode)
 {
     StackItem[] stack = new StackItem[3];
     stack[1].s_int = keyQt;
     stack[2].s_int = keyCode;
     staticInterceptor.Invoke("keyQtToCodeX$$", "keyQtToCodeX(int, int*)", stack);
     keyCode = stack[2].s_int;
     return stack[0].s_bool;
 }

 /// <remarks>
 ///  Static convenience function to let the user select an item from a
 ///  list. caption is the text that is displayed in the title bar.
 ///  label is the text that appears as the label for the list. list
 ///  is the string list which is inserted into the list, and current
 ///  is the number of the item which should be the selected item. If
 ///  editable is true, the user can enter his own text.
 /// <param> name="caption" Caption of the dialog
 /// </param><param> name="label" Text of the label for the list
 /// </param><param> name="list" List of item for user to choose from
 /// </param><param> name="current" Index of the selected item
 /// </param><param> name="editable" If true, user can enter own text
 /// </param><param> name="ok" This bool would be set to true if user pressed Ok
 /// </param><param> name="parent" Parent of the dialog widget
 /// </param></remarks>        <return> Text of the selected item. If <code>editable</code> is true this can be
 ///          a text entered by the user.
 ///      </return>
 ///         <short>    Static convenience function to let the user select an item from a  list.</short>
 public static string GetItem(string caption, string label, List<string> list, int current, bool editable, ref bool ok, QWidget parent)
 {
     StackItem[] stack = new StackItem[8];
     #if DEBUG
     stack[1].s_class = (IntPtr) DebugGCHandle.Alloc(caption);
     #else
     stack[1].s_class = (IntPtr) GCHandle.Alloc(caption);
     #endif
     #if DEBUG
     stack[2].s_class = (IntPtr) DebugGCHandle.Alloc(label);
     #else
     stack[2].s_class = (IntPtr) GCHandle.Alloc(label);
     #endif
     #if DEBUG
     stack[3].s_class = (IntPtr) DebugGCHandle.Alloc(list);
     #else
     stack[3].s_class = (IntPtr) GCHandle.Alloc(list);
     #endif
     stack[4].s_int = current;
     stack[5].s_bool = editable;
     stack[6].s_bool = ok;
     #if DEBUG
     stack[7].s_class = (IntPtr) DebugGCHandle.Alloc(parent);
     #else
     stack[7].s_class = (IntPtr) GCHandle.Alloc(parent);
     #endif
     staticInterceptor.Invoke("getItem$$?$$$#", "getItem(const QString&, const QString&, const QStringList&, int, bool, bool*, QWidget*)", stack);
     #if DEBUG
     DebugGCHandle.Free((GCHandle) stack[1].s_class);
     #else
     ((GCHandle) stack[1].s_class).Free();
     #endif
     #if DEBUG
     DebugGCHandle.Free((GCHandle) stack[2].s_class);
     #else
     ((GCHandle) stack[2].s_class).Free();
     #endif
     #if DEBUG
     DebugGCHandle.Free((GCHandle) stack[3].s_class);
     #else
     ((GCHandle) stack[3].s_class).Free();
     #endif
     ok = stack[6].s_bool;
     #if DEBUG
     DebugGCHandle.Free((GCHandle) stack[7].s_class);
     #else
     ((GCHandle) stack[7].s_class).Free();
     #endif
     object returnValue = ((GCHandle) stack[0].s_class).Target;
     #if DEBUG
     DebugGCHandle.Free((GCHandle) stack[0].s_class);
     #else
     ((GCHandle) stack[0].s_class).Free();
     #endif
     return (string) returnValue;
 }

 public QMatrix4x4(ref double values)
     : this((Type) null)
 {
     CreateProxy();
     StackItem[] stack = new StackItem[2];
     stack[1].s_double = values;
     interceptor.Invoke("QMatrix4x4$", "QMatrix4x4(const qreal*)", stack);
     values = stack[1].s_double;
     return;
 }

 public void SetEntries(int count, ref int colors, int arg3)
 {
     StackItem[] stack = new StackItem[4];
     stack[1].s_int = count;
     stack[2].s_int = colors;
     stack[3].s_int = arg3;
     interceptor.Invoke("setEntries$$$", "setEntries(int, const unsigned int*, int)", stack);
     colors = stack[2].s_int;
     return;
 }

 public QPolygon(int nPoints, ref int points)
     : this((Type) null)
 {
     CreateProxy();
     StackItem[] stack = new StackItem[3];
     stack[1].s_int = nPoints;
     stack[2].s_int = points;
     interceptor.Invoke("QPolygon$$", "QPolygon(int, const int*)", stack);
     points = stack[2].s_int;
     return;
 }

 public override void GetContentsMargins(ref double left, ref double top, ref double right, ref double bottom)
 {
     StackItem[] stack = new StackItem[5];
     stack[1].s_double = left;
     stack[2].s_double = top;
     stack[3].s_double = right;
     stack[4].s_double = bottom;
     interceptor.Invoke("getContentsMargins$$$$", "getContentsMargins(qreal*, qreal*, qreal*, qreal*) const", stack);
     left = stack[1].s_double;
     top = stack[2].s_double;
     right = stack[3].s_double;
     bottom = stack[4].s_double;
     return;
 }

 public override QValidator.State Validate(StringBuilder text, ref int e)
 {
     StackItem[] stack = new StackItem[3];
     #if DEBUG
     stack[1].s_class = (IntPtr) DebugGCHandle.Alloc(text);
     #else
     stack[1].s_class = (IntPtr) GCHandle.Alloc(text);
     #endif
     stack[2].s_int = e;
     interceptor.Invoke("validate$$", "validate(QString&, int&) const", stack);
     #if DEBUG
     DebugGCHandle.Free((GCHandle) stack[1].s_class);
     #else
     ((GCHandle) stack[1].s_class).SynchronizedFree();
     #endif
     e = stack[2].s_int;
     return (QValidator.State) Enum.ToObject(typeof(QValidator.State), stack[0].s_int);
 }

 public override bool Feature(string name, ref bool ok)
 {
     StackItem[] stack = new StackItem[3];
     #if DEBUG
     stack[1].s_class = (IntPtr) DebugGCHandle.Alloc(name);
     #else
     stack[1].s_class = (IntPtr) GCHandle.Alloc(name);
     #endif
     stack[2].s_bool = ok;
     interceptor.Invoke("feature$$", "feature(const QString&, bool*) const", stack);
     #if DEBUG
     DebugGCHandle.Free((GCHandle) stack[1].s_class);
     #else
     ((GCHandle) stack[1].s_class).Free();
     #endif
     ok = stack[2].s_bool;
     return stack[0].s_bool;
 }

 /// <remarks>
 ///  Creates a new slave.
 /// <param> name="protocol" the protocol
 /// </param><param> name="url" is the url
 /// </param><param> name="error" is the error code on failure and undefined else.
 /// </param><param> name="error_text" is the error text on failure and undefined else.
 /// </param></remarks>        <return> 0 on failure, or a pointer to a slave otherwise.
 /// 	 </return>
 ///         <short>    Creates a new slave.</short>
 public static KIO.Slave CreateSlave(string protocol, KUrl url, ref int error, StringBuilder error_text)
 {
     StackItem[] stack = new StackItem[5];
     #if DEBUG
     stack[1].s_class = (IntPtr) DebugGCHandle.Alloc(protocol);
     #else
     stack[1].s_class = (IntPtr) GCHandle.Alloc(protocol);
     #endif
     #if DEBUG
     stack[2].s_class = (IntPtr) DebugGCHandle.Alloc(url);
     #else
     stack[2].s_class = (IntPtr) GCHandle.Alloc(url);
     #endif
     stack[3].s_int = error;
     #if DEBUG
     stack[4].s_class = (IntPtr) DebugGCHandle.Alloc(error_text);
     #else
     stack[4].s_class = (IntPtr) GCHandle.Alloc(error_text);
     #endif
     staticInterceptor.Invoke("createSlave$#$$", "createSlave(const QString&, const KUrl&, int&, QString&)", stack);
     #if DEBUG
     DebugGCHandle.Free((GCHandle) stack[1].s_class);
     #else
     ((GCHandle) stack[1].s_class).SynchronizedFree();
     #endif
     #if DEBUG
     DebugGCHandle.Free((GCHandle) stack[2].s_class);
     #else
     ((GCHandle) stack[2].s_class).SynchronizedFree();
     #endif
     error = stack[3].s_int;
     #if DEBUG
     DebugGCHandle.Free((GCHandle) stack[4].s_class);
     #else
     ((GCHandle) stack[4].s_class).SynchronizedFree();
     #endif
     return (KIO.Slave) Enum.ToObject(typeof(KIO.Slave), stack[0].s_int);
 }

 /// <remarks>
 ///  Overloaded member function. Tries to find an entity in the
 ///  string str.
 /// <param> name="str" the string containing entified
 /// </param><param> name="len" is a return value, that gives the length of the decoded
 ///  entity.
 /// </param></remarks>        <return> a decoded entity if one could be found, QChar.Null
 ///  otherwise
 ///      </return>
 ///         <short>    Overloaded member function.</short>
 public static QChar FromEntity(string str, ref int len)
 {
     StackItem[] stack = new StackItem[3];
     #if DEBUG
     stack[1].s_class = (IntPtr) DebugGCHandle.Alloc(str);
     #else
     stack[1].s_class = (IntPtr) GCHandle.Alloc(str);
     #endif
     stack[2].s_int = len;
     staticInterceptor.Invoke("fromEntity$$", "fromEntity(const QString&, int&)", stack);
     #if DEBUG
     DebugGCHandle.Free((GCHandle) stack[1].s_class);
     #else
     ((GCHandle) stack[1].s_class).Free();
     #endif
     len = stack[2].s_int;
     object returnValue = ((GCHandle) stack[0].s_class).Target;
     #if DEBUG
     DebugGCHandle.Free((GCHandle) stack[0].s_class);
     #else
     ((GCHandle) stack[0].s_class).Free();
     #endif
     return (QChar) returnValue;
 }

 public void GetItemPosition(int index, ref int rowPtr, QFormLayout.ItemRole rolePtr)
 {
     StackItem[] stack = new StackItem[4];
     stack[1].s_int = index;
     stack[2].s_int = rowPtr;
     stack[3].s_int = (int) rolePtr;
     interceptor.Invoke("getItemPosition$$$", "getItemPosition(int, int*, QFormLayout::ItemRole*) const", stack);
     rowPtr = stack[2].s_int;
     return;
 }

 public static int Replace(StringBuilder text, QRegExp pattern, string replacement, int index, long options, ref int replacedLength)
 {
     StackItem[] stack = new StackItem[7];
     #if DEBUG
     stack[1].s_class = (IntPtr) DebugGCHandle.Alloc(text);
     #else
     stack[1].s_class = (IntPtr) GCHandle.Alloc(text);
     #endif
     #if DEBUG
     stack[2].s_class = (IntPtr) DebugGCHandle.Alloc(pattern);
     #else
     stack[2].s_class = (IntPtr) GCHandle.Alloc(pattern);
     #endif
     #if DEBUG
     stack[3].s_class = (IntPtr) DebugGCHandle.Alloc(replacement);
     #else
     stack[3].s_class = (IntPtr) GCHandle.Alloc(replacement);
     #endif
     stack[4].s_int = index;
     stack[5].s_long = options;
     stack[6].s_int = replacedLength;
     staticInterceptor.Invoke("replace$#$$$$", "replace(QString&, const QRegExp&, const QString&, int, long, int*)", stack);
     #if DEBUG
     DebugGCHandle.Free((GCHandle) stack[1].s_class);
     #else
     ((GCHandle) stack[1].s_class).SynchronizedFree();
     #endif
     #if DEBUG
     DebugGCHandle.Free((GCHandle) stack[2].s_class);
     #else
     ((GCHandle) stack[2].s_class).SynchronizedFree();
     #endif
     #if DEBUG
     DebugGCHandle.Free((GCHandle) stack[3].s_class);
     #else
     ((GCHandle) stack[3].s_class).SynchronizedFree();
     #endif
     replacedLength = stack[6].s_int;
     return stack[0].s_int;
 }