예제 #1
0
        public CecilClassDescriptor(CecilWidgetLibrary lib, XmlElement element, ClassDescriptor typeClassDescriptor, XmlElement steticDefinition, TypeDefinition cls)
        {
            this.cecilLib            = lib;
            this.steticDefinition    = steticDefinition;
            this.typeClassDescriptor = typeClassDescriptor;
            wrappedTypeName          = element.GetAttribute("type");
            type = cls;
            Load(element);
            type            = null;
            canGenerateCode = true;

            string baseType = element.GetAttribute("base-type");

            if (baseType.Length > 0)
            {
                wrapperClassDescriptor = Registry.LookupClassByName(baseType);
                if (wrapperClassDescriptor == null)
                {
                    throw new InvalidOperationException("Unknown base type: " + baseType);
                }
            }
            else
            {
                wrapperClassDescriptor = typeClassDescriptor;
            }

            if (steticDefinition == null && !AllowChildren && NeedsBlackBox(typeClassDescriptor.Name))
            {
                // It is not possible to create instances of that widget, instead we'll have
                // to create the typical custom widget black box.

                if (!CanCreateWidgetInstance(wrapperClassDescriptor.Name))
                {
                    throw new InvalidOperationException("Can't load widget type '" + Name + "'. Instances of that type can't be created because the type can't be loaded into the process.");
                }

                useCustomWidgetBox = true;
            }

            widgetId = Name.ToLower();
            int i = widgetId.LastIndexOf('.');

            if (i != -1)
            {
                if (i != widgetId.Length - 1)
                {
                    widgetId = widgetId.Substring(i + 1);
                }
                else
                {
                    widgetId = widgetId.Replace(".", "");
                }
            }

            string iconName = element.GetAttribute("icon");

            icon = lib.GetEmbeddedIcon(iconName);

            // If the class is a custom widget created using stetic, it means that it has
            // simple property and there is no custom logic, so it is safe to generate code
            // for this class.
            if (steticDefinition != null)
            {
                canGenerateCode = true;
            }

            // If it has a custom wrapper, then it definitely has custom logic, so it can't generate code
            if (element.HasAttribute("wrapper"))
            {
                canGenerateCode = false;
            }
        }
예제 #2
0
        static public void ImportWidget(ObjectWrapper wrapper, XmlElement elem)
        {
            string className = elem.GetAttribute("class");

            if (className == null)
            {
                throw new GladeException("<widget> node with no class name");
            }

            ClassDescriptor klassBase = Registry.LookupClassByCName(className);

            if (klassBase == null)
            {
                throw new GladeException("No stetic ClassDescriptor for " + className);
            }

            TypedClassDescriptor klass = klassBase as TypedClassDescriptor;

            if (klass == null)
            {
                throw new GladeException("The widget class " + className + " is not supported by Glade");
            }

            ReadSignals(klass, wrapper, elem);

            Hashtable rawProps, overrideProps;

            ExtractProperties(klass, elem, out rawProps, out overrideProps);

            string[]     propNames;
            GLib.Value[] propVals;
            ParseProperties(klass.WrappedType, false, rawProps.Values,
                            out propNames, out propVals);

            Gtk.Widget widget;

            if (wrapper.Wrapped == null)
            {
                if (className == "GtkWindow" || className == "GtkDialog")
                {
                    widget = (Gtk.Widget)klass.CreateInstance(wrapper.Project);
                    ObjectWrapper.Bind(wrapper.Project, klass, wrapper, widget, true);
                    SetProperties(klass, widget, propNames, propVals);
                }
                else
                {
                    IntPtr raw = gtksharp_object_newv(klass.GType.Val, propNames.Length, propNames, propVals);
                    if (raw == IntPtr.Zero)
                    {
                        throw new GladeException("Could not create widget", className);
                    }
                    widget = (Gtk.Widget)GLib.Object.GetObject(raw, true);
                    if (widget == null)
                    {
                        gtk_object_sink(raw);
                        throw new GladeException("Could not create gtk# wrapper", className);
                    }
                    ObjectWrapper.Bind(wrapper.Project, klass, wrapper, widget, true);
                }
            }
            else
            {
                widget = (Gtk.Widget)wrapper.Wrapped;
                for (int i = 0; i < propNames.Length; i++)
                {
                    g_object_set_property(widget.Handle, propNames[i], ref propVals[i]);
                }
            }
            MarkTranslatables(widget, rawProps);

            widget.Name = elem.GetAttribute("id");

            SetOverrideProperties(wrapper, overrideProps);
            MarkTranslatables(widget, overrideProps);
        }
        public TypedClassDescriptor(Assembly assembly, XmlElement elem)
        {
            bool inheritedWrapper = false;

            wrapped = Registry.GetType(elem.GetAttribute("type"), true);
            if (elem.HasAttribute("wrapper"))
            {
                wrapper = Registry.GetType(elem.GetAttribute("wrapper"), true);
            }
            else
            {
                inheritedWrapper = true;
                string baseClass = elem.GetAttribute("base-type");
                if (baseClass.Length > 0)
                {
                    // If a base type is specified, use the wrapper of that base type
                    TypedClassDescriptor parent = Registry.LookupClassByName(baseClass) as TypedClassDescriptor;
                    if (parent != null)
                    {
                        wrapper = parent.WrapperType;
                    }
                }
                else
                {
                    for (Type type = wrapped.BaseType; type != null; type = type.BaseType)
                    {
                        TypedClassDescriptor parent = Registry.LookupClassByName(type.FullName) as TypedClassDescriptor;
                        if (parent != null)
                        {
                            wrapper = parent.WrapperType;
                            break;
                        }
                    }
                }
                if (wrapper == null)
                {
                    throw new ArgumentException(string.Format("No wrapper type for class {0}", wrapped.FullName));
                }
            }

            gtype = (GLib.GType)wrapped;
            cname = gtype.ToString();

            string iconname = elem.GetAttribute("icon");

            if (iconname.Length > 0)
            {
                try {
                    // Using the pixbuf resource constructor generates a gdk warning.
                    Gdk.PixbufLoader loader = new Gdk.PixbufLoader(assembly, iconname);
                    icon = loader.Pixbuf;
                } catch {
                    Console.WriteLine("Could not load icon: " + iconname);
                    icon = GetDefaultIcon();
                }
            }
            else
            {
                icon = GetDefaultIcon();
            }

            BindingFlags flags = BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly;

            // If the wrapper is inherited from a base class, ignore the CreateInstance method
            // since it is going to create an instance of the base class.
            if (!inheritedWrapper)
            {
                ctorMethodInfoWithClass = wrapper.GetMethod("CreateInstance", flags, null, new Type[] { typeof(ClassDescriptor) }, null);
                if (ctorMethodInfoWithClass == null)
                {
                    ctorMethodInfo = wrapper.GetMethod("CreateInstance", flags, null, Type.EmptyTypes, null);
                }
            }

            // Look for a constructor even if a CreateInstance method was
            // found, since it may return null.
            cinfo = wrapped.GetConstructor(Type.EmptyTypes);
            if (cinfo == null)
            {
                useGTypeCtor = true;
                cinfo        = wrapped.GetConstructor(new Type[] { typeof(IntPtr) });
            }

            Load(elem);
        }