← Back to branch summary

~ubuntu-branches/ubuntu/natty/gtk-sharp2/natty

« back to all changes in this revision

Viewing changes to atk/ObjectFactory.custom

  • Committer: Bazaar Package Importer
  • Author(s): Jo Shields
  • Date: 2010-05-18 00:00:41 UTC
  • mfrom: (1.1.16 upstream) (13.1.7 sid)
  • Revision ID: james.westby@ubuntu.com-20100518000041-tlgvki554jx6ndhi
Tags: 2.12.10-1
* New upstream release
* debian/rules:
  + Bump API version to 2.12.10
* debian/control:
  + Bump Standards to 3.8.4 (no changes needed)
* debian/source/format:
  + Force Debian source format 1.0
* debian/rules:
  + Write a get-orig-source rule
* debian/watch:
  + Get rid of evil "debian uupdate" line which breaks packaging work on
    Ubuntu
* debian/patches/01_dllmaps.dpatch:
  + Refreshed

Show diffs side-by-side

added added

removed removed

Lines of Context:
atk/ObjectFactory.custom
1
1
// ObjectFactory.custom - Atk ObjectFactory class customizations
2
2
//
3
 
// Author: Mike Gorse <mgorse@novell.com>
 
3
// Authors: Mike Gorse <mgorse@novell.com>
 
4
//          Mike Kestner <mkestner@novell.com>
4
5
//
5
 
// Copyright (c) 2008 Novell, Inc.
 
6
// Copyright (c) 2008-2009 Novell, Inc.
6
7
//
7
8
// This code is inserted after the automatically generated code.
8
9
//
21
22
// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
22
23
// Boston, MA 02111-1307, USA.
23
24
 
24
 
                [DllImport("atksharpglue-2")]
25
 
                static extern void atksharp_object_factory_override_create_accessible (IntPtr type, CreateAccessibleDelegate cb);
26
 
                
 
25
                static Hashtable instances = new Hashtable ();
 
26
 
 
27
                protected override IntPtr Raw {
 
28
                        get { return base.Raw; }
 
29
                        set {
 
30
                                base.Raw = value;
 
31
                                if (value != IntPtr.Zero)
 
32
                                        instances [LookupGType (GetType ())] = this;
 
33
                        }
 
34
                }
 
35
 
 
36
                static Hashtable marshalers = new Hashtable ();
 
37
 
 
38
                static Marshaler GetMarshaler (GLib.GType gtype)
 
39
                {
 
40
                        Marshaler marshaler = marshalers [gtype] as Marshaler;
 
41
                        if (marshaler == null) {
 
42
                                marshaler = new Marshaler (gtype);
 
43
                                marshalers [gtype] = marshaler;
 
44
                        }
 
45
                        return marshaler;
 
46
                }
 
47
 
27
48
                [GLib.CDeclCallback]
28
49
                delegate IntPtr CreateAccessibleDelegate (IntPtr raw);
29
50
                
30
 
                static CreateAccessibleDelegate CreateAccessibleCallback;
31
 
                
32
 
                [DllImport("libgobject-2.0-0.dll")]
33
 
                static extern IntPtr g_object_ref (IntPtr handle);
34
 
 
35
 
                static IntPtr CreateAccessible_cb (IntPtr raw)
36
 
                {
37
 
                        try {
38
 
                                Atk.ObjectFactory obj = GLib.Object.GetObject (raw, false) as Atk.ObjectFactory;
39
 
                                Atk.Object ret = obj.OnCreateAccessible ();
40
 
                                if (ret != null)
41
 
                                        g_object_ref (ret.Handle);
42
 
                                return ret == null ? IntPtr.Zero : ret.Handle;
43
 
                        } catch (Exception e) {
44
 
                                GLib.ExceptionManager.RaiseUnhandledException (e, false);
45
 
                        }
46
 
                
47
 
                        return IntPtr.Zero;
 
51
                [GLib.CDeclCallback]
 
52
                delegate void InvalidateDelegate (IntPtr raw);
 
53
                
 
54
                [GLib.CDeclCallback]
 
55
                delegate IntPtr GetAccessibleTypeDelegate (IntPtr raw);
 
56
                
 
57
                class Marshaler {
 
58
 
 
59
                        GLib.GType gtype;
 
60
                        CreateAccessibleDelegate create_cb;
 
61
                        InvalidateDelegate invalidate_cb;
 
62
                        GetAccessibleTypeDelegate gettype_cb;
 
63
 
 
64
                        public Marshaler (GLib.GType gtype)
 
65
                        {
 
66
                                this.gtype = gtype;
 
67
                        }
 
68
 
 
69
                        [DllImport("libgobject-2.0-0.dll")]
 
70
                        static extern IntPtr g_object_ref (IntPtr handle);
 
71
 
 
72
                        IntPtr CreateAccessible_cb (IntPtr raw)
 
73
                        {
 
74
                                try {
 
75
                                        Atk.ObjectFactory obj = instances [gtype] as Atk.ObjectFactory;
 
76
                                        if (obj == null)
 
77
                                                return IntPtr.Zero;
 
78
                                        Atk.Object ret = obj.OnCreateAccessible (GLib.Object.GetObject (raw, false));
 
79
                                        if (ret != null)
 
80
                                                g_object_ref (ret.Handle);
 
81
                                        return ret == null ? IntPtr.Zero : ret.Handle;
 
82
                                } catch (Exception e) {
 
83
                                        GLib.ExceptionManager.RaiseUnhandledException (e, false);
 
84
                                }
 
85
 
 
86
                                return IntPtr.Zero;
 
87
                        }
 
88
                
 
89
                        void Invalidate_cb (IntPtr raw)
 
90
                        {
 
91
                                try {
 
92
                                        Atk.ObjectFactory obj = GLib.Object.GetObject (raw, false) as Atk.ObjectFactory;
 
93
                                        obj.OnInvalidate ();
 
94
                                        instances.Remove (gtype);
 
95
                                        marshalers.Remove (gtype);
 
96
                                } catch (Exception e) {
 
97
                                        GLib.ExceptionManager.RaiseUnhandledException (e, false);
 
98
                                }
 
99
                        }
 
100
 
 
101
                        IntPtr GetAccessibleType_cb (IntPtr raw)
 
102
                        {
 
103
                                try {
 
104
                                        Atk.ObjectFactory obj = instances [gtype] as Atk.ObjectFactory;
 
105
                                        if (obj == null)
 
106
                                                return GLib.GType.Invalid.Val;
 
107
                                        return obj.OnGetAccessibleType ().Val;
 
108
                                } catch (Exception e) {
 
109
                                        GLib.ExceptionManager.RaiseUnhandledException (e, false);
 
110
                                }
 
111
 
 
112
                                return GLib.GType.Invalid.Val;
 
113
                        }
 
114
                
 
115
                        [DllImport("atksharpglue-2")]
 
116
                        static extern void atksharp_object_factory_override_create_accessible (IntPtr type, CreateAccessibleDelegate cb);
 
117
                
 
118
                        public void ConnectCreateAccessible ()
 
119
                        {
 
120
                                create_cb = new CreateAccessibleDelegate (CreateAccessible_cb);
 
121
                                atksharp_object_factory_override_create_accessible (gtype.Val, create_cb);
 
122
                        }
 
123
 
 
124
                        [DllImport("atksharpglue-2")]
 
125
                        static extern void atksharp_object_factory_override_invalidate (IntPtr type, InvalidateDelegate cb);
 
126
                
 
127
                        public void ConnectInvalidate ()
 
128
                        {
 
129
                                invalidate_cb = new InvalidateDelegate (Invalidate_cb);
 
130
                                atksharp_object_factory_override_invalidate (gtype.Val, invalidate_cb);
 
131
                        }
 
132
 
 
133
                        [DllImport("atksharpglue-2")]
 
134
                        static extern void atksharp_object_factory_override_get_accessible_type (IntPtr type, GetAccessibleTypeDelegate cb);
 
135
                
 
136
                        public void ConnectGetAccessibleType ()
 
137
                        {
 
138
                                gettype_cb = new GetAccessibleTypeDelegate (GetAccessibleType_cb);
 
139
                                atksharp_object_factory_override_get_accessible_type (gtype.Val, gettype_cb);
 
140
                        }
48
141
                }
49
 
                
 
142
 
50
143
                static void OverrideCreateAccessible (GLib.GType gtype)
51
144
                {
52
 
                        if (CreateAccessibleCallback == null)
53
 
                                CreateAccessibleCallback = new CreateAccessibleDelegate (CreateAccessible_cb);
54
 
                        atksharp_object_factory_override_create_accessible (gtype.Val, CreateAccessibleCallback);
 
145
                        GetMarshaler (gtype).ConnectCreateAccessible ();
55
146
                }
56
147
                
57
148
                [GLib.DefaultSignalHandler (Type=typeof(Atk.ObjectFactory), ConnectionMethod="OverrideCreateAccessible")]
58
 
                protected virtual Atk.Object OnCreateAccessible ()
 
149
                protected virtual Atk.Object OnCreateAccessible (GLib.Object obj)
59
150
                {
60
151
                        return null;
61
152
                }
62
 
                
63
 
                [DllImport("atksharpglue-2")]
64
 
                static extern void atksharp_object_factory_override_invalidate (IntPtr type, InvalidateDelegate cb);
65
 
                
66
 
                [GLib.CDeclCallback]
67
 
                delegate void InvalidateDelegate (IntPtr raw);
68
 
                
69
 
                static InvalidateDelegate InvalidateCallback;
70
 
                
71
 
                static void Invalidate_cb (IntPtr raw)
72
 
                {
73
 
                        try {
74
 
                                Atk.ObjectFactory obj = GLib.Object.GetObject (raw, false) as Atk.ObjectFactory;
75
 
                                obj.OnInvalidate ();
76
 
                        } catch (Exception e) {
77
 
                                GLib.ExceptionManager.RaiseUnhandledException (e, false);
78
 
                        }
79
 
                }
80
 
                
 
153
 
81
154
                static void OverrideInvalidate (GLib.GType gtype)
82
155
                {
83
 
                        if (InvalidateCallback == null)
84
 
                                InvalidateCallback = new InvalidateDelegate (Invalidate_cb);
85
 
                        atksharp_object_factory_override_invalidate (gtype.Val, InvalidateCallback);
 
156
                        GetMarshaler (gtype).ConnectInvalidate ();
86
157
                }
87
158
                
88
159
                [GLib.DefaultSignalHandler (Type=typeof(Atk.ObjectFactory), ConnectionMethod="OverrideInvalidate")]
90
161
                {
91
162
                }
92
163
                
93
 
                [DllImport("atksharpglue-2")]
94
 
                static extern void atksharp_object_factory_override_get_accessible_type (IntPtr type, GetAccessibleTypeDelegate cb);
95
 
                
96
 
                [GLib.CDeclCallback]
97
 
                delegate IntPtr GetAccessibleTypeDelegate (IntPtr raw);
98
 
                
99
 
                static GetAccessibleTypeDelegate GetAccessibleTypeCallback;
100
 
                
101
 
                static IntPtr GetAccessibleType_cb (IntPtr raw)
102
 
                {
103
 
                        try {
104
 
                                Atk.ObjectFactory obj = GLib.Object.GetObject (raw, false) as Atk.ObjectFactory;
105
 
                                return obj.OnGetAccessibleType ().Val;
106
 
                        } catch (Exception e) {
107
 
                                GLib.ExceptionManager.RaiseUnhandledException (e, false);
108
 
                        }
109
 
 
110
 
                        return IntPtr.Zero;
111
 
                }
112
 
                
113
164
                static void OverrideGetAccessibleType (GLib.GType gtype)
114
165
                {
115
 
                        if (GetAccessibleTypeCallback == null)
116
 
                                GetAccessibleTypeCallback = new GetAccessibleTypeDelegate (GetAccessibleType_cb);
117
 
                        atksharp_object_factory_override_get_accessible_type (gtype.Val, GetAccessibleTypeCallback);
 
166
                        GetMarshaler (gtype).ConnectGetAccessibleType ();
118
167
                }
119
168
                
120
169
                [GLib.DefaultSignalHandler (Type=typeof(Atk.ObjectFactory), ConnectionMethod="OverrideGetAccessibleType")]
121
170
                protected virtual GLib.GType OnGetAccessibleType ()
122
 
        {
 
171
                {
123
172
                        return GLib.GType.Invalid;
124
173
                }