mirror of
https://github.com/Ryujinx/GtkSharp.git
synced 2024-09-09 08:23:19 +02:00
![Mike Kestner](/assets/img/avatar_default.png)
* glib/Object.cs: expose an internal ToggleRef prop. * glib/Signal.cs: use ToggleRef for lookups instead of Object. Add a Free method and release connections and gchandles. * glib/ToggleRef.cs: add signal hash and release signals on free. svn path=/trunk/gtk-sharp/; revision=93548
208 lines
5.6 KiB
C#
208 lines
5.6 KiB
C#
// GLib.Signal.cs - signal marshaling class
|
|
//
|
|
// Authors: Mike Kestner <mkestner@novell.com>
|
|
//
|
|
// Copyright (c) 2005 Novell, Inc.
|
|
//
|
|
// This program is free software; you can redistribute it and/or
|
|
// modify it under the terms of version 2 of the Lesser GNU General
|
|
// Public License as published by the Free Software Foundation.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
// Lesser General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Lesser General Public
|
|
// License along with this program; if not, write to the
|
|
// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
// Boston, MA 02111-1307, USA.
|
|
|
|
|
|
namespace GLib {
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using System.Runtime.InteropServices;
|
|
|
|
[Flags]
|
|
public enum ConnectFlags {
|
|
After = 1 << 0,
|
|
Swapped = 1 << 1,
|
|
}
|
|
|
|
[Flags]
|
|
internal enum SignalFlags {
|
|
RunFirst = 1 << 0,
|
|
RunLast = 1 << 1,
|
|
RunCleanup = 1 << 2,
|
|
NoRecurse = 1 << 3,
|
|
Detailed = 1 << 4,
|
|
Action = 1 << 5,
|
|
NoHooks = 1 << 6
|
|
}
|
|
|
|
[StructLayout (LayoutKind.Sequential)]
|
|
internal struct InvocationHint {
|
|
public uint signal_id;
|
|
public uint detail;
|
|
public SignalFlags run_type;
|
|
}
|
|
|
|
public class Signal {
|
|
|
|
GCHandle gc_handle;
|
|
ToggleRef tref;
|
|
string name;
|
|
uint before_id = UInt32.MaxValue;
|
|
uint after_id = UInt32.MaxValue;
|
|
Delegate marshaler;
|
|
|
|
~Signal ()
|
|
{
|
|
gc_handle.Free ();
|
|
}
|
|
|
|
private Signal (GLib.Object obj, string signal_name, Delegate marshaler)
|
|
{
|
|
tref = obj.ToggleRef;
|
|
name = signal_name;
|
|
this.marshaler = marshaler;
|
|
gc_handle = GCHandle.Alloc (this, GCHandleType.Weak);
|
|
tref.Signals [name] = this;
|
|
}
|
|
|
|
internal void Free ()
|
|
{
|
|
DisconnectHandler (before_id);
|
|
DisconnectHandler (after_id);
|
|
before_handler = after_handler = marshaler = null;
|
|
gc_handle.Free ();
|
|
GC.SuppressFinalize (this);
|
|
}
|
|
|
|
public static Signal Lookup (GLib.Object obj, string name)
|
|
{
|
|
return Lookup (obj, name, EventHandlerDelegate);
|
|
}
|
|
|
|
public static Signal Lookup (GLib.Object obj, string name, Delegate marshaler)
|
|
{
|
|
Signal result = obj.ToggleRef.Signals [name] as Signal;
|
|
if (result == null)
|
|
result = new Signal (obj, name, marshaler);
|
|
return result as Signal;
|
|
}
|
|
|
|
Delegate before_handler;
|
|
Delegate after_handler;
|
|
|
|
public Delegate Handler {
|
|
get {
|
|
InvocationHint hint = (InvocationHint) Marshal.PtrToStructure (g_signal_get_invocation_hint (tref.Handle), typeof (InvocationHint));
|
|
if (hint.run_type == SignalFlags.RunFirst)
|
|
return before_handler;
|
|
else
|
|
return after_handler;
|
|
}
|
|
}
|
|
|
|
uint Connect (int flags)
|
|
{
|
|
IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
|
|
uint id = g_signal_connect_data (tref.Handle, native_name, marshaler, (IntPtr) gc_handle, IntPtr.Zero, flags);
|
|
GLib.Marshaller.Free (native_name);
|
|
return id;
|
|
}
|
|
|
|
public void AddDelegate (Delegate d)
|
|
{
|
|
if (d.Method.IsDefined (typeof (ConnectBeforeAttribute), false)) {
|
|
if (before_handler == null) {
|
|
before_handler = d;
|
|
before_id = Connect (0);
|
|
} else
|
|
before_handler = Delegate.Combine (before_handler, d);
|
|
} else {
|
|
if (after_handler == null) {
|
|
after_handler = d;
|
|
after_id = Connect (1);
|
|
} else
|
|
after_handler = Delegate.Combine (after_handler, d);
|
|
}
|
|
}
|
|
|
|
public void RemoveDelegate (Delegate d)
|
|
{
|
|
if (d.Method.IsDefined (typeof (ConnectBeforeAttribute), false)) {
|
|
before_handler = Delegate.Remove (before_handler, d);
|
|
if (before_handler == null) {
|
|
DisconnectHandler (before_id);
|
|
before_id = UInt32.MaxValue;
|
|
}
|
|
} else {
|
|
after_handler = Delegate.Remove (after_handler, d);
|
|
if (after_handler == null) {
|
|
DisconnectHandler (after_id);
|
|
after_id = UInt32.MaxValue;
|
|
}
|
|
}
|
|
|
|
if (after_id == UInt32.MaxValue && before_id == UInt32.MaxValue)
|
|
tref.Signals.Remove (name);
|
|
}
|
|
|
|
void DisconnectHandler (uint handler_id)
|
|
{
|
|
if (handler_id != UInt32.MaxValue && g_signal_handler_is_connected (tref.Handle, handler_id))
|
|
g_signal_handler_disconnect (tref.Handle, handler_id);
|
|
}
|
|
|
|
[CDeclCallback]
|
|
delegate void voidObjectDelegate (IntPtr handle, IntPtr gch);
|
|
|
|
static void voidObjectCallback (IntPtr handle, IntPtr data)
|
|
{
|
|
try {
|
|
if (data == IntPtr.Zero)
|
|
return;
|
|
GCHandle gch = (GCHandle) data;
|
|
if (gch.Target == null)
|
|
return;
|
|
Signal sig = gch.Target as Signal;
|
|
if (sig == null) {
|
|
ExceptionManager.RaiseUnhandledException (new Exception ("Unknown signal class GC handle received."), false);
|
|
return;
|
|
}
|
|
|
|
EventHandler handler = (EventHandler) sig.Handler;
|
|
handler (Object.GetObject (handle), EventArgs.Empty);
|
|
} catch (Exception e) {
|
|
ExceptionManager.RaiseUnhandledException (e, false);
|
|
}
|
|
}
|
|
|
|
static voidObjectDelegate event_handler_delegate;
|
|
static voidObjectDelegate EventHandlerDelegate {
|
|
get {
|
|
if (event_handler_delegate == null)
|
|
event_handler_delegate = new voidObjectDelegate (voidObjectCallback);
|
|
return event_handler_delegate;
|
|
}
|
|
}
|
|
|
|
[DllImport("libgobject-2.0-0.dll")]
|
|
static extern uint g_signal_connect_data(IntPtr obj, IntPtr name, Delegate cb, IntPtr gc_handle, IntPtr dummy, int flags);
|
|
|
|
[DllImport("libgobject-2.0-0.dll")]
|
|
static extern IntPtr g_signal_get_invocation_hint (IntPtr instance);
|
|
|
|
[DllImport("libgobject-2.0-0.dll")]
|
|
static extern void g_signal_handler_disconnect (IntPtr instance, uint handler);
|
|
|
|
[DllImport("libgobject-2.0-0.dll")]
|
|
static extern bool g_signal_handler_is_connected (IntPtr instance, uint handler);
|
|
}
|
|
}
|
|
|