subprojects/gstreamer-sharp/sources/generated/Gst/Bin.cs

   1 // This file was generated by the Gtk# code generator.
   2 // Any changes made will be lost if regenerated.
   3
   4 namespace Gst {
   5
   6         using System;
   7         using System.Collections;
   8         using System.Collections.Generic;
   9         using System.Runtime.InteropServices;
  10
  11 #region Autogenerated code
  12         public partial class Bin : Gst.Element, Gst.IChildProxy {
  13
  14                 public Bin (IntPtr raw) : base(raw) {}
  15
  16                 [DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
  17                 static extern IntPtr gst_bin_new(IntPtr name);
  18
  19                 public Bin (string name) : base (IntPtr.Zero)
  20                 {
  21                         if (GetType () != typeof (Bin)) {
  22                                 var vals = new List<GLib.Value> ();
  23                                 var names = new List<string> ();
  24                                 names.Add ("name");
  25                                 vals.Add (new GLib.Value (name));
  26                                 CreateNativeObject (names.ToArray (), vals.ToArray ());
  27                                 return;
  28                         }
  29                         IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
  30                         Raw = gst_bin_new(native_name);
  31                         GLib.Marshaller.Free (native_name);
  32                 }
  33
  34                 [GLib.Property ("async-handling")]
  35                 public bool AsyncHandling {
  36                         get {
  37                                 GLib.Value val = GetProperty ("async-handling");
  38                                 bool ret = (bool) val;
  39                                 val.Dispose ();
  40                                 return ret;
  41                         }
  42                         set {
  43                                 GLib.Value val = new GLib.Value(value);
  44                                 SetProperty("async-handling", val);
  45                                 val.Dispose ();
  46                         }
  47                 }
  48
  49                 [GLib.Property ("message-forward")]
  50                 public bool MessageForward {
  51                         get {
  52                                 GLib.Value val = GetProperty ("message-forward");
  53                                 bool ret = (bool) val;
  54                                 val.Dispose ();
  55                                 return ret;
  56                         }
  57                         set {
  58                                 GLib.Value val = new GLib.Value(value);
  59                                 SetProperty("message-forward", val);
  60                                 val.Dispose ();
  61                         }
  62                 }
  63
  64                 public int Numchildren {
  65                         get {
  66                                 unsafe {
  67                                         int* raw_ptr = (int*)(((byte*)Handle) + abi_info.GetFieldOffset("numchildren"));
  68                                         return (*raw_ptr);
  69                                 }
  70                         }
  71                 }
  72
  73                 public GLib.List Children {
  74                         get {
  75                                 unsafe {
  76                                         IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("children"));
  77                                         return new GLib.List((*raw_ptr));
  78                                 }
  79                         }
  80                 }
  81
  82                 public uint ChildrenCookie {
  83                         get {
  84                                 unsafe {
  85                                         uint* raw_ptr = (uint*)(((byte*)Handle) + abi_info.GetFieldOffset("children_cookie"));
  86                                         return (*raw_ptr);
  87                                 }
  88                         }
  89                 }
  90
  91                 public Gst.Bus ChildBus {
  92                         get {
  93                                 unsafe {
  94                                         IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("child_bus"));
  95                                         return GLib.Object.GetObject((*raw_ptr)) as Gst.Bus;
  96                                 }
  97                         }
  98                 }
  99
 100                 public GLib.List Messages {
 101                         get {
 102                                 unsafe {
 103                                         IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("messages"));
 104                                         return new GLib.List((*raw_ptr));
 105                                 }
 106                         }
 107                 }
 108
 109                 public bool Polling {
 110                         get {
 111                                 unsafe {
 112                                         bool* raw_ptr = (bool*)(((byte*)Handle) + abi_info.GetFieldOffset("polling"));
 113                                         return (*raw_ptr);
 114                                 }
 115                         }
 116                 }
 117
 118                 public bool StateDirty {
 119                         get {
 120                                 unsafe {
 121                                         bool* raw_ptr = (bool*)(((byte*)Handle) + abi_info.GetFieldOffset("state_dirty"));
 122                                         return (*raw_ptr);
 123                                 }
 124                         }
 125                 }
 126
 127                 public bool ClockDirty {
 128                         get {
 129                                 unsafe {
 130                                         bool* raw_ptr = (bool*)(((byte*)Handle) + abi_info.GetFieldOffset("clock_dirty"));
 131                                         return (*raw_ptr);
 132                                 }
 133                         }
 134                 }
 135
 136                 public Gst.Clock ProvidedClock {
 137                         get {
 138                                 unsafe {
 139                                         IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("provided_clock"));
 140                                         return GLib.Object.GetObject((*raw_ptr)) as Gst.Clock;
 141                                 }
 142                         }
 143                 }
 144
 145                 public Gst.Element ClockProvider {
 146                         get {
 147                                 unsafe {
 148                                         IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("clock_provider"));
 149                                         return GLib.Object.GetObject((*raw_ptr)) as Gst.Element;
 150                                 }
 151                         }
 152                 }
 153
 154                 [GLib.Signal("deep-element-added")]
 155                 public event Gst.DeepElementAddedHandler DeepElementAdded {
 156                         add {
 157                                 this.AddSignalHandler ("deep-element-added", value, typeof (Gst.DeepElementAddedArgs));
 158                         }
 159                         remove {
 160                                 this.RemoveSignalHandler ("deep-element-added", value);
 161                         }
 162                 }
 163
 164                 [GLib.Signal("deep-element-removed")]
 165                 public event Gst.DeepElementRemovedHandler DeepElementRemoved {
 166                         add {
 167                                 this.AddSignalHandler ("deep-element-removed", value, typeof (Gst.DeepElementRemovedArgs));
 168                         }
 169                         remove {
 170                                 this.RemoveSignalHandler ("deep-element-removed", value);
 171                         }
 172                 }
 173
 174                 [GLib.Signal("do-latency")]
 175                 public event Gst.DoLatencyHandler DoLatency {
 176                         add {
 177                                 this.AddSignalHandler ("do-latency", value, typeof (Gst.DoLatencyArgs));
 178                         }
 179                         remove {
 180                                 this.RemoveSignalHandler ("do-latency", value);
 181                         }
 182                 }
 183
 184                 [GLib.Signal("element-added")]
 185                 public event Gst.ElementAddedHandler ElementAdded {
 186                         add {
 187                                 this.AddSignalHandler ("element-added", value, typeof (Gst.ElementAddedArgs));
 188                         }
 189                         remove {
 190                                 this.RemoveSignalHandler ("element-added", value);
 191                         }
 192                 }
 193
 194                 [GLib.Signal("element-removed")]
 195                 public event Gst.ElementRemovedHandler ElementRemoved {
 196                         add {
 197                                 this.AddSignalHandler ("element-removed", value, typeof (Gst.ElementRemovedArgs));
 198                         }
 199                         remove {
 200                                 this.RemoveSignalHandler ("element-removed", value);
 201                         }
 202                 }
 203
 204                 static ElementAddedNativeDelegate ElementAdded_cb_delegate;
 205                 static ElementAddedNativeDelegate ElementAddedVMCallback {
 206                         get {
 207                                 if (ElementAdded_cb_delegate == null)
 208                                         ElementAdded_cb_delegate = new ElementAddedNativeDelegate (ElementAdded_cb);
 209                                 return ElementAdded_cb_delegate;
 210                         }
 211                 }
 212
 213                 static void OverrideElementAdded (GLib.GType gtype)
 214                 {
 215                         OverrideElementAdded (gtype, ElementAddedVMCallback);
 216                 }
 217
 218                 static void OverrideElementAdded (GLib.GType gtype, ElementAddedNativeDelegate callback)
 219                 {
 220                         unsafe {
 221                                 IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("element_added"));
 222                                 *raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
 223                         }
 224                 }
 225
 226                 [UnmanagedFunctionPointer (CallingConvention.Cdecl)]
 227                 delegate void ElementAddedNativeDelegate (IntPtr inst, IntPtr element);
 228
 229                 static void ElementAdded_cb (IntPtr inst, IntPtr element)
 230                 {
 231                         try {
 232                                 Bin __obj = GLib.Object.GetObject (inst, false) as Bin;
 233                                 __obj.OnElementAdded (GLib.Object.GetObject(element) as Gst.Element);
 234                         } catch (Exception e) {
 235                                 GLib.ExceptionManager.RaiseUnhandledException (e, false);
 236                         }
 237                 }
 238
 239                 [GLib.DefaultSignalHandler(Type=typeof(Gst.Bin), ConnectionMethod="OverrideElementAdded")]
 240                 protected virtual void OnElementAdded (Gst.Element element)
 241                 {
 242                         InternalElementAdded (element);
 243                 }
 244
 245                 private void InternalElementAdded (Gst.Element element)
 246                 {
 247                         ElementAddedNativeDelegate unmanaged = null;
 248                         unsafe {
 249                                 IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("element_added"));
 250                                 unmanaged = (ElementAddedNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(ElementAddedNativeDelegate));
 251                         }
 252                         if (unmanaged == null) return;
 253
 254                         unmanaged (this.Handle, element == null ? IntPtr.Zero : element.Handle);
 255                 }
 256
 257                 static ElementRemovedNativeDelegate ElementRemoved_cb_delegate;
 258                 static ElementRemovedNativeDelegate ElementRemovedVMCallback {
 259                         get {
 260                                 if (ElementRemoved_cb_delegate == null)
 261                                         ElementRemoved_cb_delegate = new ElementRemovedNativeDelegate (ElementRemoved_cb);
 262                                 return ElementRemoved_cb_delegate;
 263                         }
 264                 }
 265
 266                 static void OverrideElementRemoved (GLib.GType gtype)
 267                 {
 268                         OverrideElementRemoved (gtype, ElementRemovedVMCallback);
 269                 }
 270
 271                 static void OverrideElementRemoved (GLib.GType gtype, ElementRemovedNativeDelegate callback)
 272                 {
 273                         unsafe {
 274                                 IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("element_removed"));
 275                                 *raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
 276                         }
 277                 }
 278
 279                 [UnmanagedFunctionPointer (CallingConvention.Cdecl)]
 280                 delegate void ElementRemovedNativeDelegate (IntPtr inst, IntPtr element);
 281
 282                 static void ElementRemoved_cb (IntPtr inst, IntPtr element)
 283                 {
 284                         try {
 285                                 Bin __obj = GLib.Object.GetObject (inst, false) as Bin;
 286                                 __obj.OnElementRemoved (GLib.Object.GetObject(element) as Gst.Element);
 287                         } catch (Exception e) {
 288                                 GLib.ExceptionManager.RaiseUnhandledException (e, false);
 289                         }
 290                 }
 291
 292                 [GLib.DefaultSignalHandler(Type=typeof(Gst.Bin), ConnectionMethod="OverrideElementRemoved")]
 293                 protected virtual void OnElementRemoved (Gst.Element element)
 294                 {
 295                         InternalElementRemoved (element);
 296                 }
 297
 298                 private void InternalElementRemoved (Gst.Element element)
 299                 {
 300                         ElementRemovedNativeDelegate unmanaged = null;
 301                         unsafe {
 302                                 IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("element_removed"));
 303                                 unmanaged = (ElementRemovedNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(ElementRemovedNativeDelegate));
 304                         }
 305                         if (unmanaged == null) return;
 306
 307                         unmanaged (this.Handle, element == null ? IntPtr.Zero : element.Handle);
 308                 }
 309
 310                 static AddElementNativeDelegate AddElement_cb_delegate;
 311                 static AddElementNativeDelegate AddElementVMCallback {
 312                         get {
 313                                 if (AddElement_cb_delegate == null)
 314                                         AddElement_cb_delegate = new AddElementNativeDelegate (AddElement_cb);
 315                                 return AddElement_cb_delegate;
 316                         }
 317                 }
 318
 319                 static void OverrideAddElement (GLib.GType gtype)
 320                 {
 321                         OverrideAddElement (gtype, AddElementVMCallback);
 322                 }
 323
 324                 static void OverrideAddElement (GLib.GType gtype, AddElementNativeDelegate callback)
 325                 {
 326                         unsafe {
 327                                 IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("add_element"));
 328                                 *raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
 329                         }
 330                 }
 331
 332                 [UnmanagedFunctionPointer (CallingConvention.Cdecl)]
 333                 delegate bool AddElementNativeDelegate (IntPtr inst, IntPtr element);
 334
 335                 static bool AddElement_cb (IntPtr inst, IntPtr element)
 336                 {
 337                         try {
 338                                 Bin __obj = GLib.Object.GetObject (inst, false) as Bin;
 339                                 bool __result;
 340                                 __result = __obj.OnAddElement (GLib.Object.GetObject(element) as Gst.Element);
 341                                 return __result;
 342                         } catch (Exception e) {
 343                                 GLib.ExceptionManager.RaiseUnhandledException (e, true);
 344                                 // NOTREACHED: above call does not return.
 345                                 throw e;
 346                         }
 347                 }
 348
 349                 [GLib.DefaultSignalHandler(Type=typeof(Gst.Bin), ConnectionMethod="OverrideAddElement")]
 350                 protected virtual bool OnAddElement (Gst.Element element)
 351                 {
 352                         return InternalAddElement (element);
 353                 }
 354
 355                 private bool InternalAddElement (Gst.Element element)
 356                 {
 357                         AddElementNativeDelegate unmanaged = null;
 358                         unsafe {
 359                                 IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("add_element"));
 360                                 unmanaged = (AddElementNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(AddElementNativeDelegate));
 361                         }
 362                         if (unmanaged == null) return false;
 363
 364                         bool __result = unmanaged (this.Handle, element == null ? IntPtr.Zero : element.Handle);
 365                         return __result;
 366                 }
 367
 368                 static RemoveElementNativeDelegate RemoveElement_cb_delegate;
 369                 static RemoveElementNativeDelegate RemoveElementVMCallback {
 370                         get {
 371                                 if (RemoveElement_cb_delegate == null)
 372                                         RemoveElement_cb_delegate = new RemoveElementNativeDelegate (RemoveElement_cb);
 373                                 return RemoveElement_cb_delegate;
 374                         }
 375                 }
 376
 377                 static void OverrideRemoveElement (GLib.GType gtype)
 378                 {
 379                         OverrideRemoveElement (gtype, RemoveElementVMCallback);
 380                 }
 381
 382                 static void OverrideRemoveElement (GLib.GType gtype, RemoveElementNativeDelegate callback)
 383                 {
 384                         unsafe {
 385                                 IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("remove_element"));
 386                                 *raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
 387                         }
 388                 }
 389
 390                 [UnmanagedFunctionPointer (CallingConvention.Cdecl)]
 391                 delegate bool RemoveElementNativeDelegate (IntPtr inst, IntPtr element);
 392
 393                 static bool RemoveElement_cb (IntPtr inst, IntPtr element)
 394                 {
 395                         try {
 396                                 Bin __obj = GLib.Object.GetObject (inst, false) as Bin;
 397                                 bool __result;
 398                                 __result = __obj.OnRemoveElement (GLib.Object.GetObject(element) as Gst.Element);
 399                                 return __result;
 400                         } catch (Exception e) {
 401                                 GLib.ExceptionManager.RaiseUnhandledException (e, true);
 402                                 // NOTREACHED: above call does not return.
 403                                 throw e;
 404                         }
 405                 }
 406
 407                 [GLib.DefaultSignalHandler(Type=typeof(Gst.Bin), ConnectionMethod="OverrideRemoveElement")]
 408                 protected virtual bool OnRemoveElement (Gst.Element element)
 409                 {
 410                         return InternalRemoveElement (element);
 411                 }
 412
 413                 private bool InternalRemoveElement (Gst.Element element)
 414                 {
 415                         RemoveElementNativeDelegate unmanaged = null;
 416                         unsafe {
 417                                 IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("remove_element"));
 418                                 unmanaged = (RemoveElementNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(RemoveElementNativeDelegate));
 419                         }
 420                         if (unmanaged == null) return false;
 421
 422                         bool __result = unmanaged (this.Handle, element == null ? IntPtr.Zero : element.Handle);
 423                         return __result;
 424                 }
 425
 426                 static HandleMessageNativeDelegate HandleMessage_cb_delegate;
 427                 static HandleMessageNativeDelegate HandleMessageVMCallback {
 428                         get {
 429                                 if (HandleMessage_cb_delegate == null)
 430                                         HandleMessage_cb_delegate = new HandleMessageNativeDelegate (HandleMessage_cb);
 431                                 return HandleMessage_cb_delegate;
 432                         }
 433                 }
 434
 435                 static void OverrideHandleMessage (GLib.GType gtype)
 436                 {
 437                         OverrideHandleMessage (gtype, HandleMessageVMCallback);
 438                 }
 439
 440                 static void OverrideHandleMessage (GLib.GType gtype, HandleMessageNativeDelegate callback)
 441                 {
 442                         unsafe {
 443                                 IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("handle_message"));
 444                                 *raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
 445                         }
 446                 }
 447
 448                 [UnmanagedFunctionPointer (CallingConvention.Cdecl)]
 449                 delegate void HandleMessageNativeDelegate (IntPtr inst, IntPtr message);
 450
 451                 static void HandleMessage_cb (IntPtr inst, IntPtr message)
 452                 {
 453                         try {
 454                                 Bin __obj = GLib.Object.GetObject (inst, false) as Bin;
 455                                 __obj.OnHandleMessage (message == IntPtr.Zero ? null : (Gst.Message) GLib.Opaque.GetOpaque (message, typeof (Gst.Message), false));
 456                         } catch (Exception e) {
 457                                 GLib.ExceptionManager.RaiseUnhandledException (e, false);
 458                         }
 459                 }
 460
 461                 [GLib.DefaultSignalHandler(Type=typeof(Gst.Bin), ConnectionMethod="OverrideHandleMessage")]
 462                 protected virtual void OnHandleMessage (Gst.Message message)
 463                 {
 464                         InternalHandleMessage (message);
 465                 }
 466
 467                 private void InternalHandleMessage (Gst.Message message)
 468                 {
 469                         HandleMessageNativeDelegate unmanaged = null;
 470                         unsafe {
 471                                 IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("handle_message"));
 472                                 unmanaged = (HandleMessageNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(HandleMessageNativeDelegate));
 473                         }
 474                         if (unmanaged == null) return;
 475
 476                         unmanaged (this.Handle, message == null ? IntPtr.Zero : message.Handle);
 477                 }
 478
 479                 static DoLatencyNativeDelegate DoLatency_cb_delegate;
 480                 static DoLatencyNativeDelegate DoLatencyVMCallback {
 481                         get {
 482                                 if (DoLatency_cb_delegate == null)
 483                                         DoLatency_cb_delegate = new DoLatencyNativeDelegate (DoLatency_cb);
 484                                 return DoLatency_cb_delegate;
 485                         }
 486                 }
 487
 488                 static void OverrideDoLatency (GLib.GType gtype)
 489                 {
 490                         OverrideDoLatency (gtype, DoLatencyVMCallback);
 491                 }
 492
 493                 static void OverrideDoLatency (GLib.GType gtype, DoLatencyNativeDelegate callback)
 494                 {
 495                         unsafe {
 496                                 IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("do_latency"));
 497                                 *raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
 498                         }
 499                 }
 500
 501                 [UnmanagedFunctionPointer (CallingConvention.Cdecl)]
 502                 delegate bool DoLatencyNativeDelegate (IntPtr inst);
 503
 504                 static bool DoLatency_cb (IntPtr inst)
 505                 {
 506                         try {
 507                                 Bin __obj = GLib.Object.GetObject (inst, false) as Bin;
 508                                 bool __result;
 509                                 __result = __obj.OnDoLatency ();
 510                                 return __result;
 511                         } catch (Exception e) {
 512                                 GLib.ExceptionManager.RaiseUnhandledException (e, true);
 513                                 // NOTREACHED: above call does not return.
 514                                 throw e;
 515                         }
 516                 }
 517
 518                 [GLib.DefaultSignalHandler(Type=typeof(Gst.Bin), ConnectionMethod="OverrideDoLatency")]
 519                 protected virtual bool OnDoLatency ()
 520                 {
 521                         return InternalDoLatency ();
 522                 }
 523
 524                 private bool InternalDoLatency ()
 525                 {
 526                         DoLatencyNativeDelegate unmanaged = null;
 527                         unsafe {
 528                                 IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("do_latency"));
 529                                 unmanaged = (DoLatencyNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(DoLatencyNativeDelegate));
 530                         }
 531                         if (unmanaged == null) return false;
 532
 533                         bool __result = unmanaged (this.Handle);
 534                         return __result;
 535                 }
 536
 537                 static DeepElementAddedNativeDelegate DeepElementAdded_cb_delegate;
 538                 static DeepElementAddedNativeDelegate DeepElementAddedVMCallback {
 539                         get {
 540                                 if (DeepElementAdded_cb_delegate == null)
 541                                         DeepElementAdded_cb_delegate = new DeepElementAddedNativeDelegate (DeepElementAdded_cb);
 542                                 return DeepElementAdded_cb_delegate;
 543                         }
 544                 }
 545
 546                 static void OverrideDeepElementAdded (GLib.GType gtype)
 547                 {
 548                         OverrideDeepElementAdded (gtype, DeepElementAddedVMCallback);
 549                 }
 550
 551                 static void OverrideDeepElementAdded (GLib.GType gtype, DeepElementAddedNativeDelegate callback)
 552                 {
 553                         unsafe {
 554                                 IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("deep_element_added"));
 555                                 *raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
 556                         }
 557                 }
 558
 559                 [UnmanagedFunctionPointer (CallingConvention.Cdecl)]
 560                 delegate void DeepElementAddedNativeDelegate (IntPtr inst, IntPtr sub_bin, IntPtr element);
 561
 562                 static void DeepElementAdded_cb (IntPtr inst, IntPtr sub_bin, IntPtr element)
 563                 {
 564                         try {
 565                                 Bin __obj = GLib.Object.GetObject (inst, false) as Bin;
 566                                 __obj.OnDeepElementAdded (GLib.Object.GetObject(sub_bin) as Gst.Bin, GLib.Object.GetObject(element) as Gst.Element);
 567                         } catch (Exception e) {
 568                                 GLib.ExceptionManager.RaiseUnhandledException (e, false);
 569                         }
 570                 }
 571
 572                 [GLib.DefaultSignalHandler(Type=typeof(Gst.Bin), ConnectionMethod="OverrideDeepElementAdded")]
 573                 protected virtual void OnDeepElementAdded (Gst.Bin sub_bin, Gst.Element element)
 574                 {
 575                         InternalDeepElementAdded (sub_bin, element);
 576                 }
 577
 578                 private void InternalDeepElementAdded (Gst.Bin sub_bin, Gst.Element element)
 579                 {
 580                         DeepElementAddedNativeDelegate unmanaged = null;
 581                         unsafe {
 582                                 IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("deep_element_added"));
 583                                 unmanaged = (DeepElementAddedNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(DeepElementAddedNativeDelegate));
 584                         }
 585                         if (unmanaged == null) return;
 586
 587                         unmanaged (this.Handle, sub_bin == null ? IntPtr.Zero : sub_bin.Handle, element == null ? IntPtr.Zero : element.Handle);
 588                 }
 589
 590                 static DeepElementRemovedNativeDelegate DeepElementRemoved_cb_delegate;
 591                 static DeepElementRemovedNativeDelegate DeepElementRemovedVMCallback {
 592                         get {
 593                                 if (DeepElementRemoved_cb_delegate == null)
 594                                         DeepElementRemoved_cb_delegate = new DeepElementRemovedNativeDelegate (DeepElementRemoved_cb);
 595                                 return DeepElementRemoved_cb_delegate;
 596                         }
 597                 }
 598
 599                 static void OverrideDeepElementRemoved (GLib.GType gtype)
 600                 {
 601                         OverrideDeepElementRemoved (gtype, DeepElementRemovedVMCallback);
 602                 }
 603
 604                 static void OverrideDeepElementRemoved (GLib.GType gtype, DeepElementRemovedNativeDelegate callback)
 605                 {
 606                         unsafe {
 607                                 IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("deep_element_removed"));
 608                                 *raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
 609                         }
 610                 }
 611
 612                 [UnmanagedFunctionPointer (CallingConvention.Cdecl)]
 613                 delegate void DeepElementRemovedNativeDelegate (IntPtr inst, IntPtr sub_bin, IntPtr element);
 614
 615                 static void DeepElementRemoved_cb (IntPtr inst, IntPtr sub_bin, IntPtr element)
 616                 {
 617                         try {
 618                                 Bin __obj = GLib.Object.GetObject (inst, false) as Bin;
 619                                 __obj.OnDeepElementRemoved (GLib.Object.GetObject(sub_bin) as Gst.Bin, GLib.Object.GetObject(element) as Gst.Element);
 620                         } catch (Exception e) {
 621                                 GLib.ExceptionManager.RaiseUnhandledException (e, false);
 622                         }
 623                 }
 624
 625                 [GLib.DefaultSignalHandler(Type=typeof(Gst.Bin), ConnectionMethod="OverrideDeepElementRemoved")]
 626                 protected virtual void OnDeepElementRemoved (Gst.Bin sub_bin, Gst.Element element)
 627                 {
 628                         InternalDeepElementRemoved (sub_bin, element);
 629                 }
 630
 631                 private void InternalDeepElementRemoved (Gst.Bin sub_bin, Gst.Element element)
 632                 {
 633                         DeepElementRemovedNativeDelegate unmanaged = null;
 634                         unsafe {
 635                                 IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("deep_element_removed"));
 636                                 unmanaged = (DeepElementRemovedNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(DeepElementRemovedNativeDelegate));
 637                         }
 638                         if (unmanaged == null) return;
 639
 640                         unmanaged (this.Handle, sub_bin == null ? IntPtr.Zero : sub_bin.Handle, element == null ? IntPtr.Zero : element.Handle);
 641                 }
 642
 643
 644                 // Internal representation of the wrapped structure ABI.
 645                 static GLib.AbiStruct _class_abi = null;
 646                 static public new GLib.AbiStruct class_abi {
 647                         get {
 648                                 if (_class_abi == null)
 649                                         _class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{
 650                                                 new GLib.AbiField("pool"
 651                                                         , Gst.Element.class_abi.Fields
 652                                                         , (uint) Marshal.SizeOf(typeof(IntPtr)) // pool
 653                                                         , null
 654                                                         , "element_added"
 655                                                         , (uint) Marshal.SizeOf(typeof(IntPtr))
 656                                                         , 0
 657                                                         ),
 658                                                 new GLib.AbiField("element_added"
 659                                                         , -1
 660                                                         , (uint) Marshal.SizeOf(typeof(IntPtr)) // element_added
 661                                                         , "pool"
 662                                                         , "element_removed"
 663                                                         , (uint) Marshal.SizeOf(typeof(IntPtr))
 664                                                         , 0
 665                                                         ),
 666                                                 new GLib.AbiField("element_removed"
 667                                                         , -1
 668                                                         , (uint) Marshal.SizeOf(typeof(IntPtr)) // element_removed
 669                                                         , "element_added"
 670                                                         , "add_element"
 671                                                         , (uint) Marshal.SizeOf(typeof(IntPtr))
 672                                                         , 0
 673                                                         ),
 674                                                 new GLib.AbiField("add_element"
 675                                                         , -1
 676                                                         , (uint) Marshal.SizeOf(typeof(IntPtr)) // add_element
 677                                                         , "element_removed"
 678                                                         , "remove_element"
 679                                                         , (uint) Marshal.SizeOf(typeof(IntPtr))
 680                                                         , 0
 681                                                         ),
 682                                                 new GLib.AbiField("remove_element"
 683                                                         , -1
 684                                                         , (uint) Marshal.SizeOf(typeof(IntPtr)) // remove_element
 685                                                         , "add_element"
 686                                                         , "handle_message"
 687                                                         , (uint) Marshal.SizeOf(typeof(IntPtr))
 688                                                         , 0
 689                                                         ),
 690                                                 new GLib.AbiField("handle_message"
 691                                                         , -1
 692                                                         , (uint) Marshal.SizeOf(typeof(IntPtr)) // handle_message
 693                                                         , "remove_element"
 694                                                         , "do_latency"
 695                                                         , (uint) Marshal.SizeOf(typeof(IntPtr))
 696                                                         , 0
 697                                                         ),
 698                                                 new GLib.AbiField("do_latency"
 699                                                         , -1
 700                                                         , (uint) Marshal.SizeOf(typeof(IntPtr)) // do_latency
 701                                                         , "handle_message"
 702                                                         , "deep_element_added"
 703                                                         , (uint) Marshal.SizeOf(typeof(IntPtr))
 704                                                         , 0
 705                                                         ),
 706                                                 new GLib.AbiField("deep_element_added"
 707                                                         , -1
 708                                                         , (uint) Marshal.SizeOf(typeof(IntPtr)) // deep_element_added
 709                                                         , "do_latency"
 710                                                         , "deep_element_removed"
 711                                                         , (uint) Marshal.SizeOf(typeof(IntPtr))
 712                                                         , 0
 713                                                         ),
 714                                                 new GLib.AbiField("deep_element_removed"
 715                                                         , -1
 716                                                         , (uint) Marshal.SizeOf(typeof(IntPtr)) // deep_element_removed
 717                                                         , "deep_element_added"
 718                                                         , "_gst_reserved"
 719                                                         , (uint) Marshal.SizeOf(typeof(IntPtr))
 720                                                         , 0
 721                                                         ),
 722                                                 new GLib.AbiField("_gst_reserved"
 723                                                         , -1
 724                                                         , (uint) Marshal.SizeOf(typeof(IntPtr)) * 2 // _gst_reserved
 725                                                         , "deep_element_removed"
 726                                                         , null
 727                                                         , (uint) Marshal.SizeOf(typeof(IntPtr))
 728                                                         , 0
 729                                                         ),
 730                                         });
 731
 732                                 return _class_abi;
 733                         }
 734                 }
 735
 736
 737                 // End of the ABI representation.
 738
 739                 [DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
 740                 static extern IntPtr gst_bin_get_type();
 741
 742                 public static new GLib.GType GType {
 743                         get {
 744                                 IntPtr raw_ret = gst_bin_get_type();
 745                                 GLib.GType ret = new GLib.GType(raw_ret);
 746                                 return ret;
 747                         }
 748                 }
 749
 750                 [DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
 751                 static extern bool gst_bin_add(IntPtr raw, IntPtr element);
 752
 753                 public bool Add(Gst.Element element) {
 754                         bool raw_ret = gst_bin_add(Handle, element == null ? IntPtr.Zero : element.Handle);
 755                         bool ret = raw_ret;
 756                         return ret;
 757                 }
 758
 759                 [DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
 760                 static extern IntPtr gst_bin_find_unlinked_pad(IntPtr raw, int direction);
 761
 762                 public Gst.Pad FindUnlinkedPad(Gst.PadDirection direction) {
 763                         IntPtr raw_ret = gst_bin_find_unlinked_pad(Handle, (int) direction);
 764                         Gst.Pad ret = GLib.Object.GetObject(raw_ret, true) as Gst.Pad;
 765                         return ret;
 766                 }
 767
 768                 [DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
 769                 static extern IntPtr gst_bin_get_by_interface(IntPtr raw, IntPtr iface);
 770
 771                 public Gst.Element GetByInterface(GLib.GType iface) {
 772                         IntPtr raw_ret = gst_bin_get_by_interface(Handle, iface.Val);
 773                         Gst.Element ret = GLib.Object.GetObject(raw_ret, true) as Gst.Element;
 774                         return ret;
 775                 }
 776
 777                 [DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
 778                 static extern IntPtr gst_bin_get_by_name(IntPtr raw, IntPtr name);
 779
 780                 public Gst.Element GetByName(string name) {
 781                         IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
 782                         IntPtr raw_ret = gst_bin_get_by_name(Handle, native_name);
 783                         Gst.Element ret = GLib.Object.GetObject(raw_ret, true) as Gst.Element;
 784                         GLib.Marshaller.Free (native_name);
 785                         return ret;
 786                 }
 787
 788                 [DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
 789                 static extern IntPtr gst_bin_get_by_name_recurse_up(IntPtr raw, IntPtr name);
 790
 791                 public Gst.Element GetByNameRecurseUp(string name) {
 792                         IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
 793                         IntPtr raw_ret = gst_bin_get_by_name_recurse_up(Handle, native_name);
 794                         Gst.Element ret = GLib.Object.GetObject(raw_ret, true) as Gst.Element;
 795                         GLib.Marshaller.Free (native_name);
 796                         return ret;
 797                 }
 798
 799                 [DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
 800                 static extern int gst_bin_get_suppressed_flags(IntPtr raw);
 801
 802                 [DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
 803                 static extern void gst_bin_set_suppressed_flags(IntPtr raw, int flags);
 804
 805                 public Gst.ElementFlags SuppressedFlags {
 806                         get {
 807                                 int raw_ret = gst_bin_get_suppressed_flags(Handle);
 808                                 Gst.ElementFlags ret = (Gst.ElementFlags) raw_ret;
 809                                 return ret;
 810                         }
 811                         set {
 812                                 gst_bin_set_suppressed_flags(Handle, (int) value);
 813                         }
 814                 }
 815
 816                 [DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
 817                 static extern IntPtr gst_bin_iterate_all_by_element_factory_name(IntPtr raw, IntPtr factory_name);
 818
 819                 public Gst.Iterator IterateAllByElementFactoryName(string factory_name) {
 820                         IntPtr native_factory_name = GLib.Marshaller.StringToPtrGStrdup (factory_name);
 821                         IntPtr raw_ret = gst_bin_iterate_all_by_element_factory_name(Handle, native_factory_name);
 822                         Gst.Iterator ret = raw_ret == IntPtr.Zero ? null : (Gst.Iterator) GLib.Opaque.GetOpaque (raw_ret, typeof (Gst.Iterator), true);
 823                         GLib.Marshaller.Free (native_factory_name);
 824                         return ret;
 825                 }
 826
 827                 [DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
 828                 static extern IntPtr gst_bin_iterate_all_by_interface(IntPtr raw, IntPtr iface);
 829
 830                 public Gst.Iterator IterateAllByInterface(GLib.GType iface) {
 831                         IntPtr raw_ret = gst_bin_iterate_all_by_interface(Handle, iface.Val);
 832                         Gst.Iterator ret = raw_ret == IntPtr.Zero ? null : (Gst.Iterator) GLib.Opaque.GetOpaque (raw_ret, typeof (Gst.Iterator), true);
 833                         return ret;
 834                 }
 835
 836                 [DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
 837                 static extern IntPtr gst_bin_iterate_elements(IntPtr raw);
 838
 839                 public Gst.Iterator IterateElements() {
 840                         IntPtr raw_ret = gst_bin_iterate_elements(Handle);
 841                         Gst.Iterator ret = raw_ret == IntPtr.Zero ? null : (Gst.Iterator) GLib.Opaque.GetOpaque (raw_ret, typeof (Gst.Iterator), true);
 842                         return ret;
 843                 }
 844
 845                 [DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
 846                 static extern IntPtr gst_bin_iterate_recurse(IntPtr raw);
 847
 848                 public Gst.Iterator IterateRecurse() {
 849                         IntPtr raw_ret = gst_bin_iterate_recurse(Handle);
 850                         Gst.Iterator ret = raw_ret == IntPtr.Zero ? null : (Gst.Iterator) GLib.Opaque.GetOpaque (raw_ret, typeof (Gst.Iterator), true);
 851                         return ret;
 852                 }
 853
 854                 [DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
 855                 static extern IntPtr gst_bin_iterate_sinks(IntPtr raw);
 856
 857                 public Gst.Iterator IterateSinks() {
 858                         IntPtr raw_ret = gst_bin_iterate_sinks(Handle);
 859                         Gst.Iterator ret = raw_ret == IntPtr.Zero ? null : (Gst.Iterator) GLib.Opaque.GetOpaque (raw_ret, typeof (Gst.Iterator), true);
 860                         return ret;
 861                 }
 862
 863                 [DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
 864                 static extern IntPtr gst_bin_iterate_sorted(IntPtr raw);
 865
 866                 public Gst.Iterator IterateSorted() {
 867                         IntPtr raw_ret = gst_bin_iterate_sorted(Handle);
 868                         Gst.Iterator ret = raw_ret == IntPtr.Zero ? null : (Gst.Iterator) GLib.Opaque.GetOpaque (raw_ret, typeof (Gst.Iterator), true);
 869                         return ret;
 870                 }
 871
 872                 [DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
 873                 static extern IntPtr gst_bin_iterate_sources(IntPtr raw);
 874
 875                 public Gst.Iterator IterateSources() {
 876                         IntPtr raw_ret = gst_bin_iterate_sources(Handle);
 877                         Gst.Iterator ret = raw_ret == IntPtr.Zero ? null : (Gst.Iterator) GLib.Opaque.GetOpaque (raw_ret, typeof (Gst.Iterator), true);
 878                         return ret;
 879                 }
 880
 881                 [DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
 882                 static extern bool gst_bin_recalculate_latency(IntPtr raw);
 883
 884                 public bool RecalculateLatency() {
 885                         bool raw_ret = gst_bin_recalculate_latency(Handle);
 886                         bool ret = raw_ret;
 887                         return ret;
 888                 }
 889
 890                 [DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
 891                 static extern bool gst_bin_remove(IntPtr raw, IntPtr element);
 892
 893                 public bool Remove(Gst.Element element) {
 894                         bool raw_ret = gst_bin_remove(Handle, element == null ? IntPtr.Zero : element.Handle);
 895                         bool ret = raw_ret;
 896                         return ret;
 897                 }
 898
 899                 [DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
 900                 static extern bool gst_bin_sync_children_states(IntPtr raw);
 901
 902                 public bool SyncChildrenStates() {
 903                         bool raw_ret = gst_bin_sync_children_states(Handle);
 904                         bool ret = raw_ret;
 905                         return ret;
 906                 }
 907
 908                 [DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
 909                 static extern void gst_child_proxy_child_added(IntPtr raw, IntPtr child, IntPtr name);
 910
 911                 public void ChildAdded(GLib.Object child, string name) {
 912                         IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
 913                         gst_child_proxy_child_added(Handle, child == null ? IntPtr.Zero : child.Handle, native_name);
 914                         GLib.Marshaller.Free (native_name);
 915                 }
 916
 917                 [DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
 918                 static extern void gst_child_proxy_child_removed(IntPtr raw, IntPtr child, IntPtr name);
 919
 920                 public void ChildRemoved(GLib.Object child, string name) {
 921                         IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
 922                         gst_child_proxy_child_removed(Handle, child == null ? IntPtr.Zero : child.Handle, native_name);
 923                         GLib.Marshaller.Free (native_name);
 924                 }
 925
 926                 [DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
 927                 static extern IntPtr gst_child_proxy_get_child_by_index(IntPtr raw, uint index);
 928
 929                 public GLib.Object GetChildByIndex(uint index) {
 930                         IntPtr raw_ret = gst_child_proxy_get_child_by_index(Handle, index);
 931                         GLib.Object ret = GLib.Object.GetObject (raw_ret);
 932                         return ret;
 933                 }
 934
 935                 [DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
 936                 static extern IntPtr gst_child_proxy_get_child_by_name(IntPtr raw, IntPtr name);
 937
 938                 public GLib.Object GetChildByName(string name) {
 939                         IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
 940                         IntPtr raw_ret = gst_child_proxy_get_child_by_name(Handle, native_name);
 941                         GLib.Object ret = GLib.Object.GetObject (raw_ret);
 942                         GLib.Marshaller.Free (native_name);
 943                         return ret;
 944                 }
 945
 946                 [DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
 947                 static extern uint gst_child_proxy_get_children_count(IntPtr raw);
 948
 949                 public uint ChildrenCount {
 950                         get {
 951                                 uint raw_ret = gst_child_proxy_get_children_count(Handle);
 952                                 uint ret = raw_ret;
 953                                 return ret;
 954                         }
 955                 }
 956
 957                 [DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
 958                 static extern bool gst_child_proxy_lookup(IntPtr raw, IntPtr name, out IntPtr target, out IntPtr pspec);
 959
 960                 public bool Lookup(string name, out GLib.Object target, out IntPtr pspec) {
 961                         IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
 962                         IntPtr native_target;
 963                         bool raw_ret = gst_child_proxy_lookup(Handle, native_name, out native_target, out pspec);
 964                         bool ret = raw_ret;
 965                         GLib.Marshaller.Free (native_name);
 966                         target = GLib.Object.GetObject (native_target);
 967                         return ret;
 968                 }
 969
 970                 [GLib.Signal("child-removed")]
 971                 public event Gst.ChildRemovedEventHandler ChildRemovedEvent {
 972                         add {
 973                                 this.AddSignalHandler ("child-removed", value, typeof (Gst.ChildRemovedEventArgs));
 974                         }
 975                         remove {
 976                                 this.RemoveSignalHandler ("child-removed", value);
 977                         }
 978                 }
 979
 980                 [GLib.Signal("child-added")]
 981                 public event Gst.ChildAddedEventHandler ChildAddedEvent {
 982                         add {
 983                                 this.AddSignalHandler ("child-added", value, typeof (Gst.ChildAddedEventArgs));
 984                         }
 985                         remove {
 986                                 this.RemoveSignalHandler ("child-added", value);
 987                         }
 988                 }
 989
 990                 static ChildAddedEventNativeDelegate ChildAddedEvent_cb_delegate;
 991                 static ChildAddedEventNativeDelegate ChildAddedEventVMCallback {
 992                         get {
 993                                 if (ChildAddedEvent_cb_delegate == null)
 994                                         ChildAddedEvent_cb_delegate = new ChildAddedEventNativeDelegate (ChildAddedEvent_cb);
 995                                 return ChildAddedEvent_cb_delegate;
 996                         }
 997                 }
 998
 999                 static void OverrideChildAddedEvent (GLib.GType gtype)
1000                 {
1001                         OverrideChildAddedEvent (gtype, ChildAddedEventVMCallback);
1002                 }
1003
1004                 static void OverrideChildAddedEvent (GLib.GType gtype, ChildAddedEventNativeDelegate callback)
1005                 {
1006                         OverrideVirtualMethod (gtype, "child-added", callback);
1007                 }
1008                 [UnmanagedFunctionPointer (CallingConvention.Cdecl)]
1009                 delegate void ChildAddedEventNativeDelegate (IntPtr inst, IntPtr _object, IntPtr name);
1010
1011                 static void ChildAddedEvent_cb (IntPtr inst, IntPtr _object, IntPtr name)
1012                 {
1013                         try {
1014                                 Gst.Bin __obj = GLib.Object.GetObject (inst, false) as Gst.Bin;
1015                                 __obj.OnChildAddedEvent (GLib.Object.GetObject (_object), GLib.Marshaller.Utf8PtrToString (name));
1016                         } catch (Exception e) {
1017                                 GLib.ExceptionManager.RaiseUnhandledException (e, false);
1018                         }
1019                 }
1020
1021                 [GLib.DefaultSignalHandler(Type=typeof(Gst.Bin), ConnectionMethod="OverrideChildAddedEvent")]
1022                 protected virtual void OnChildAddedEvent (GLib.Object _object, string name)
1023                 {
1024                         InternalChildAddedEvent (_object, name);
1025                 }
1026
1027                 private void InternalChildAddedEvent (GLib.Object _object, string name)
1028                 {
1029                         GLib.Value ret = GLib.Value.Empty;
1030                         GLib.ValueArray inst_and_params = new GLib.ValueArray (3);
1031                         GLib.Value[] vals = new GLib.Value [3];
1032                         vals [0] = new GLib.Value (this);
1033                         inst_and_params.Append (vals [0]);
1034                         vals [1] = new GLib.Value (_object);
1035                         inst_and_params.Append (vals [1]);
1036                         vals [2] = new GLib.Value (name);
1037                         inst_and_params.Append (vals [2]);
1038                         g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
1039                         foreach (GLib.Value v in vals)
1040                                 v.Dispose ();
1041                 }
1042
1043                 static ChildRemovedEventNativeDelegate ChildRemovedEvent_cb_delegate;
1044                 static ChildRemovedEventNativeDelegate ChildRemovedEventVMCallback {
1045                         get {
1046                                 if (ChildRemovedEvent_cb_delegate == null)
1047                                         ChildRemovedEvent_cb_delegate = new ChildRemovedEventNativeDelegate (ChildRemovedEvent_cb);
1048                                 return ChildRemovedEvent_cb_delegate;
1049                         }
1050                 }
1051
1052                 static void OverrideChildRemovedEvent (GLib.GType gtype)
1053                 {
1054                         OverrideChildRemovedEvent (gtype, ChildRemovedEventVMCallback);
1055                 }
1056
1057                 static void OverrideChildRemovedEvent (GLib.GType gtype, ChildRemovedEventNativeDelegate callback)
1058                 {
1059                         OverrideVirtualMethod (gtype, "child-removed", callback);
1060                 }
1061                 [UnmanagedFunctionPointer (CallingConvention.Cdecl)]
1062                 delegate void ChildRemovedEventNativeDelegate (IntPtr inst, IntPtr _object, IntPtr name);
1063
1064                 static void ChildRemovedEvent_cb (IntPtr inst, IntPtr _object, IntPtr name)
1065                 {
1066                         try {
1067                                 Gst.Bin __obj = GLib.Object.GetObject (inst, false) as Gst.Bin;
1068                                 __obj.OnChildRemovedEvent (GLib.Object.GetObject (_object), GLib.Marshaller.Utf8PtrToString (name));
1069                         } catch (Exception e) {
1070                                 GLib.ExceptionManager.RaiseUnhandledException (e, false);
1071                         }
1072                 }
1073
1074                 [GLib.DefaultSignalHandler(Type=typeof(Gst.Bin), ConnectionMethod="OverrideChildRemovedEvent")]
1075                 protected virtual void OnChildRemovedEvent (GLib.Object _object, string name)
1076                 {
1077                         InternalChildRemovedEvent (_object, name);
1078                 }
1079
1080                 private void InternalChildRemovedEvent (GLib.Object _object, string name)
1081                 {
1082                         GLib.Value ret = GLib.Value.Empty;
1083                         GLib.ValueArray inst_and_params = new GLib.ValueArray (3);
1084                         GLib.Value[] vals = new GLib.Value [3];
1085                         vals [0] = new GLib.Value (this);
1086                         inst_and_params.Append (vals [0]);
1087                         vals [1] = new GLib.Value (_object);
1088                         inst_and_params.Append (vals [1]);
1089                         vals [2] = new GLib.Value (name);
1090                         inst_and_params.Append (vals [2]);
1091                         g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
1092                         foreach (GLib.Value v in vals)
1093                                 v.Dispose ();
1094                 }
1095
1096
1097                 // Internal representation of the wrapped structure ABI.
1098                 static GLib.AbiStruct _abi_info = null;
1099                 static public new GLib.AbiStruct abi_info {
1100                         get {
1101                                 if (_abi_info == null)
1102                                         _abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{
1103                                                 new GLib.AbiField("numchildren"
1104                                                         , Gst.Element.abi_info.Fields
1105                                                         , (uint) Marshal.SizeOf(typeof(int)) // numchildren
1106                                                         , null
1107                                                         , "children"
1108                                                         , (long) Marshal.OffsetOf(typeof(GstBin_numchildrenAlign), "numchildren")
1109                                                         , 0
1110                                                         ),
1111                                                 new GLib.AbiField("children"
1112                                                         , -1
1113                                                         , (uint) Marshal.SizeOf(typeof(IntPtr)) // children
1114                                                         , "numchildren"
1115                                                         , "children_cookie"
1116                                                         , (uint) Marshal.SizeOf(typeof(IntPtr))
1117                                                         , 0
1118                                                         ),
1119                                                 new GLib.AbiField("children_cookie"
1120                                                         , -1
1121                                                         , (uint) Marshal.SizeOf(typeof(uint)) // children_cookie
1122                                                         , "children"
1123                                                         , "child_bus"
1124                                                         , (long) Marshal.OffsetOf(typeof(GstBin_children_cookieAlign), "children_cookie")
1125                                                         , 0
1126                                                         ),
1127                                                 new GLib.AbiField("child_bus"
1128                                                         , -1
1129                                                         , (uint) Marshal.SizeOf(typeof(IntPtr)) // child_bus
1130                                                         , "children_cookie"
1131                                                         , "messages"
1132                                                         , (uint) Marshal.SizeOf(typeof(IntPtr))
1133                                                         , 0
1134                                                         ),
1135                                                 new GLib.AbiField("messages"
1136                                                         , -1
1137                                                         , (uint) Marshal.SizeOf(typeof(IntPtr)) // messages
1138                                                         , "child_bus"
1139                                                         , "polling"
1140                                                         , (uint) Marshal.SizeOf(typeof(IntPtr))
1141                                                         , 0
1142                                                         ),
1143                                                 new GLib.AbiField("polling"
1144                                                         , -1
1145                                                         , (uint) Marshal.SizeOf(typeof(bool)) // polling
1146                                                         , "messages"
1147                                                         , "state_dirty"
1148                                                         , (long) Marshal.OffsetOf(typeof(GstBin_pollingAlign), "polling")
1149                                                         , 0
1150                                                         ),
1151                                                 new GLib.AbiField("state_dirty"
1152                                                         , -1
1153                                                         , (uint) Marshal.SizeOf(typeof(bool)) // state_dirty
1154                                                         , "polling"
1155                                                         , "clock_dirty"
1156                                                         , (long) Marshal.OffsetOf(typeof(GstBin_state_dirtyAlign), "state_dirty")
1157                                                         , 0
1158                                                         ),
1159                                                 new GLib.AbiField("clock_dirty"
1160                                                         , -1
1161                                                         , (uint) Marshal.SizeOf(typeof(bool)) // clock_dirty
1162                                                         , "state_dirty"
1163                                                         , "provided_clock"
1164                                                         , (long) Marshal.OffsetOf(typeof(GstBin_clock_dirtyAlign), "clock_dirty")
1165                                                         , 0
1166                                                         ),
1167                                                 new GLib.AbiField("provided_clock"
1168                                                         , -1
1169                                                         , (uint) Marshal.SizeOf(typeof(IntPtr)) // provided_clock
1170                                                         , "clock_dirty"
1171                                                         , "clock_provider"
1172                                                         , (uint) Marshal.SizeOf(typeof(IntPtr))
1173                                                         , 0
1174                                                         ),
1175                                                 new GLib.AbiField("clock_provider"
1176                                                         , -1
1177                                                         , (uint) Marshal.SizeOf(typeof(IntPtr)) // clock_provider
1178                                                         , "provided_clock"
1179                                                         , "priv"
1180                                                         , (uint) Marshal.SizeOf(typeof(IntPtr))
1181                                                         , 0
1182                                                         ),
1183                                                 new GLib.AbiField("priv"
1184                                                         , -1
1185                                                         , (uint) Marshal.SizeOf(typeof(IntPtr)) // priv
1186                                                         , "clock_provider"
1187                                                         , "_gst_reserved"
1188                                                         , (uint) Marshal.SizeOf(typeof(IntPtr))
1189                                                         , 0
1190                                                         ),
1191                                                 new GLib.AbiField("_gst_reserved"
1192                                                         , -1
1193                                                         , (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _gst_reserved
1194                                                         , "priv"
1195                                                         , null
1196                                                         , (uint) Marshal.SizeOf(typeof(IntPtr))
1197                                                         , 0
1198                                                         ),
1199                                         });
1200
1201                                 return _abi_info;
1202                         }
1203                 }
1204
1205                 [StructLayout(LayoutKind.Sequential)]
1206                 public struct GstBin_numchildrenAlign
1207                 {
1208                         sbyte f1;
1209                         private int numchildren;
1210                 }
1211
1212                 [StructLayout(LayoutKind.Sequential)]
1213                 public struct GstBin_children_cookieAlign
1214                 {
1215                         sbyte f1;
1216                         private uint children_cookie;
1217                 }
1218
1219                 [StructLayout(LayoutKind.Sequential)]
1220                 public struct GstBin_pollingAlign
1221                 {
1222                         sbyte f1;
1223                         private bool polling;
1224                 }
1225
1226                 [StructLayout(LayoutKind.Sequential)]
1227                 public struct GstBin_state_dirtyAlign
1228                 {
1229                         sbyte f1;
1230                         private bool state_dirty;
1231                 }
1232
1233                 [StructLayout(LayoutKind.Sequential)]
1234                 public struct GstBin_clock_dirtyAlign
1235                 {
1236                         sbyte f1;
1237                         private bool clock_dirty;
1238                 }
1239
1240
1241                 // End of the ABI representation.
1242
1243 #endregion
1244         }
1245 }