C# GType.GetClassPtr方法代码示例

        static IntPtr RegisterProperty(GType type, string name, string nick, string blurb, uint property_id, GType property_type, bool can_read, bool can_write)
        {
            IntPtr declaring_class = type.GetClassPtr ();
            ParamSpec pspec = new ParamSpec (name, nick, blurb, property_type, can_read, can_write);

            g_object_class_install_property (declaring_class, property_id, pspec.Handle);
            return pspec.Handle;
        }

        static void AddInterfaces(GType gtype, Type t, ref bool handlers_overridden)
        {
            foreach (Type iface in t.GetInterfaces ()) {
                if (!iface.IsDefined (typeof (GInterfaceAttribute), true))
                    continue;

                GInterfaceAttribute attr = iface.GetCustomAttributes (typeof (GInterfaceAttribute), false) [0] as GInterfaceAttribute;
                GInterfaceAdapter adapter = Activator.CreateInstance (attr.AdapterType, null) as GInterfaceAdapter;
                if (!handlers_overridden) {
                    IntPtr class_ptr = gtype.GetClassPtr ();
                    GObjectClass gobject_class = (GObjectClass) Marshal.PtrToStructure (class_ptr, typeof (GObjectClass));
                    gobject_class.get_prop_cb = GetPropertyHandler;
                    gobject_class.set_prop_cb = SetPropertyHandler;
                    Marshal.StructureToPtr (gobject_class, class_ptr, false);
                    handlers_overridden = true;
                }

                if (!iface.IsAssignableFrom (t.BaseType)) {
                    GInterfaceInfo info = adapter.Info;
                    info.Data = gtype.GetClassPtr ();
                    //FIXME:  overiding prop is done inside the init of interface adapter
                    // not sure that it is the good solution but
                    // it is the only one I found without exception or loop
                    g_type_add_interface_static (gtype.Val, adapter.GType.Val, ref info);
                }
                foreach (PropertyInfo p in iface.GetProperties ()) {
                    PropertyAttribute[] attrs = p.GetCustomAttributes (typeof (PropertyAttribute), true) as PropertyAttribute [];
                    if (attrs.Length == 0)
                        continue;
                    PropertyAttribute property_attr = attrs [0];
                    PropertyInfo declared_prop = t.GetProperty (p.Name, BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance);
                    if (declared_prop == null)
                        continue;
                    IntPtr param_spec = FindInterfaceProperty (adapter.GType, property_attr.Name);

                    Properties [param_spec] = declared_prop;
                }
            }
        }

        static void AddProperties(GType gtype, System.Type t, bool register_instance_prop, ref bool handlers_overridden)
        {
            if (register_instance_prop) {
                IntPtr declaring_class = gtype.GetClassPtr ();
                ParamSpec pspec = new ParamSpec ("gtk-sharp-managed-instance", "", "", GType.Pointer, ParamFlags.Writable | ParamFlags.ConstructOnly);
                g_object_class_install_property (declaring_class, idx, pspec.Handle);
                idx++;
            }

            foreach (PropertyInfo pinfo in t.GetProperties (BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly)) {
                foreach (object attr in pinfo.GetCustomAttributes (typeof (PropertyAttribute), false)) {
                    if(pinfo.GetIndexParameters().Length > 0)
                        throw(new InvalidOperationException(String.Format("GLib.RegisterPropertyAttribute cannot be applied to property {0} of type {1} because the property expects one or more indexed parameters", pinfo.Name, t.FullName)));

                    if (!handlers_overridden) {
                        IntPtr class_ptr = gtype.GetClassPtr ();
                        GObjectClass gobject_class = (GObjectClass) Marshal.PtrToStructure (class_ptr, typeof (GObjectClass));
                        gobject_class.get_prop_cb = GetPropertyHandler;
                        gobject_class.set_prop_cb = SetPropertyHandler;
                        Marshal.StructureToPtr (gobject_class, class_ptr, false);
                        handlers_overridden = true;
                    }
                    PropertyAttribute property_attr = attr as PropertyAttribute;
                    try {
                        IntPtr param_spec = RegisterProperty (gtype, property_attr.Name, property_attr.Nickname, property_attr.Blurb, idx, (GType) pinfo.PropertyType, pinfo.CanRead, pinfo.CanWrite);
                        Properties.Add (param_spec, pinfo);
                        idx++;
                    } catch (ArgumentException) {
                        throw new InvalidOperationException (String.Format ("GLib.PropertyAttribute cannot be applied to property {0} of type {1} because the return type of the property is not supported", pinfo.Name, t.FullName));
                    }
                }
            }
        }

		void InitForProperty (GType gtype, string name)
		{
			IntPtr p_name = Marshaller.StringToPtrGStrdup (name);
			IntPtr spec_ptr = g_object_class_find_property (gtype.GetClassPtr (), p_name);
			Marshaller.Free (p_name);

			if (spec_ptr == IntPtr.Zero)
				throw new Exception (String.Format ("No property with name '{0}' in type '{1}'", name, gtype.ToString()));
			
			ParamSpec spec = new ParamSpec (spec_ptr);
			g_value_init (ref this, spec.ValueType.Val);
		}