subprojects/gstreamer-sharp/sources/generated/Gst.Audio/AudioSink.cs

   1 // This file was generated by the Gtk# code generator.
   2 // Any changes made will be lost if regenerated.
   3
   4 namespace Gst.Audio {
   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 AudioSink : Gst.Audio.AudioBaseSink {
  13
  14                 public AudioSink (IntPtr raw) : base(raw) {}
  15
  16                 protected AudioSink() : base(IntPtr.Zero)
  17                 {
  18                         CreateNativeObject (new string [0], new GLib.Value [0]);
  19                 }
  20
  21                 static OpenNativeDelegate Open_cb_delegate;
  22                 static OpenNativeDelegate OpenVMCallback {
  23                         get {
  24                                 if (Open_cb_delegate == null)
  25                                         Open_cb_delegate = new OpenNativeDelegate (Open_cb);
  26                                 return Open_cb_delegate;
  27                         }
  28                 }
  29
  30                 static void OverrideOpen (GLib.GType gtype)
  31                 {
  32                         OverrideOpen (gtype, OpenVMCallback);
  33                 }
  34
  35                 static void OverrideOpen (GLib.GType gtype, OpenNativeDelegate callback)
  36                 {
  37                         unsafe {
  38                                 IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("open"));
  39                                 *raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
  40                         }
  41                 }
  42
  43                 [UnmanagedFunctionPointer (CallingConvention.Cdecl)]
  44                 delegate bool OpenNativeDelegate (IntPtr inst);
  45
  46                 static bool Open_cb (IntPtr inst)
  47                 {
  48                         try {
  49                                 AudioSink __obj = GLib.Object.GetObject (inst, false) as AudioSink;
  50                                 bool __result;
  51                                 __result = __obj.OnOpen ();
  52                                 return __result;
  53                         } catch (Exception e) {
  54                                 GLib.ExceptionManager.RaiseUnhandledException (e, true);
  55                                 // NOTREACHED: above call does not return.
  56                                 throw e;
  57                         }
  58                 }
  59
  60                 [GLib.DefaultSignalHandler(Type=typeof(Gst.Audio.AudioSink), ConnectionMethod="OverrideOpen")]
  61                 protected virtual bool OnOpen ()
  62                 {
  63                         return InternalOpen ();
  64                 }
  65
  66                 private bool InternalOpen ()
  67                 {
  68                         OpenNativeDelegate unmanaged = null;
  69                         unsafe {
  70                                 IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("open"));
  71                                 unmanaged = (OpenNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(OpenNativeDelegate));
  72                         }
  73                         if (unmanaged == null) return false;
  74
  75                         bool __result = unmanaged (this.Handle);
  76                         return __result;
  77                 }
  78
  79                 static PrepareNativeDelegate Prepare_cb_delegate;
  80                 static PrepareNativeDelegate PrepareVMCallback {
  81                         get {
  82                                 if (Prepare_cb_delegate == null)
  83                                         Prepare_cb_delegate = new PrepareNativeDelegate (Prepare_cb);
  84                                 return Prepare_cb_delegate;
  85                         }
  86                 }
  87
  88                 static void OverridePrepare (GLib.GType gtype)
  89                 {
  90                         OverridePrepare (gtype, PrepareVMCallback);
  91                 }
  92
  93                 static void OverridePrepare (GLib.GType gtype, PrepareNativeDelegate callback)
  94                 {
  95                         unsafe {
  96                                 IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("prepare"));
  97                                 *raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
  98                         }
  99                 }
 100
 101                 [UnmanagedFunctionPointer (CallingConvention.Cdecl)]
 102                 delegate bool PrepareNativeDelegate (IntPtr inst, IntPtr spec);
 103
 104                 static bool Prepare_cb (IntPtr inst, IntPtr spec)
 105                 {
 106                         try {
 107                                 AudioSink __obj = GLib.Object.GetObject (inst, false) as AudioSink;
 108                                 bool __result;
 109                                 __result = __obj.OnPrepare (spec == IntPtr.Zero ? null : (Gst.Audio.AudioRingBufferSpec) GLib.Opaque.GetOpaque (spec, typeof (Gst.Audio.AudioRingBufferSpec), false));
 110                                 return __result;
 111                         } catch (Exception e) {
 112                                 GLib.ExceptionManager.RaiseUnhandledException (e, true);
 113                                 // NOTREACHED: above call does not return.
 114                                 throw e;
 115                         }
 116                 }
 117
 118                 [GLib.DefaultSignalHandler(Type=typeof(Gst.Audio.AudioSink), ConnectionMethod="OverridePrepare")]
 119                 protected virtual bool OnPrepare (Gst.Audio.AudioRingBufferSpec spec)
 120                 {
 121                         return InternalPrepare (spec);
 122                 }
 123
 124                 private bool InternalPrepare (Gst.Audio.AudioRingBufferSpec spec)
 125                 {
 126                         PrepareNativeDelegate unmanaged = null;
 127                         unsafe {
 128                                 IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("prepare"));
 129                                 unmanaged = (PrepareNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(PrepareNativeDelegate));
 130                         }
 131                         if (unmanaged == null) return false;
 132
 133                         bool __result = unmanaged (this.Handle, spec == null ? IntPtr.Zero : spec.Handle);
 134                         return __result;
 135                 }
 136
 137                 static UnprepareNativeDelegate Unprepare_cb_delegate;
 138                 static UnprepareNativeDelegate UnprepareVMCallback {
 139                         get {
 140                                 if (Unprepare_cb_delegate == null)
 141                                         Unprepare_cb_delegate = new UnprepareNativeDelegate (Unprepare_cb);
 142                                 return Unprepare_cb_delegate;
 143                         }
 144                 }
 145
 146                 static void OverrideUnprepare (GLib.GType gtype)
 147                 {
 148                         OverrideUnprepare (gtype, UnprepareVMCallback);
 149                 }
 150
 151                 static void OverrideUnprepare (GLib.GType gtype, UnprepareNativeDelegate callback)
 152                 {
 153                         unsafe {
 154                                 IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("unprepare"));
 155                                 *raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
 156                         }
 157                 }
 158
 159                 [UnmanagedFunctionPointer (CallingConvention.Cdecl)]
 160                 delegate bool UnprepareNativeDelegate (IntPtr inst);
 161
 162                 static bool Unprepare_cb (IntPtr inst)
 163                 {
 164                         try {
 165                                 AudioSink __obj = GLib.Object.GetObject (inst, false) as AudioSink;
 166                                 bool __result;
 167                                 __result = __obj.OnUnprepare ();
 168                                 return __result;
 169                         } catch (Exception e) {
 170                                 GLib.ExceptionManager.RaiseUnhandledException (e, true);
 171                                 // NOTREACHED: above call does not return.
 172                                 throw e;
 173                         }
 174                 }
 175
 176                 [GLib.DefaultSignalHandler(Type=typeof(Gst.Audio.AudioSink), ConnectionMethod="OverrideUnprepare")]
 177                 protected virtual bool OnUnprepare ()
 178                 {
 179                         return InternalUnprepare ();
 180                 }
 181
 182                 private bool InternalUnprepare ()
 183                 {
 184                         UnprepareNativeDelegate unmanaged = null;
 185                         unsafe {
 186                                 IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("unprepare"));
 187                                 unmanaged = (UnprepareNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(UnprepareNativeDelegate));
 188                         }
 189                         if (unmanaged == null) return false;
 190
 191                         bool __result = unmanaged (this.Handle);
 192                         return __result;
 193                 }
 194
 195                 static CloseNativeDelegate Close_cb_delegate;
 196                 static CloseNativeDelegate CloseVMCallback {
 197                         get {
 198                                 if (Close_cb_delegate == null)
 199                                         Close_cb_delegate = new CloseNativeDelegate (Close_cb);
 200                                 return Close_cb_delegate;
 201                         }
 202                 }
 203
 204                 static void OverrideClose (GLib.GType gtype)
 205                 {
 206                         OverrideClose (gtype, CloseVMCallback);
 207                 }
 208
 209                 static void OverrideClose (GLib.GType gtype, CloseNativeDelegate callback)
 210                 {
 211                         unsafe {
 212                                 IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("close"));
 213                                 *raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
 214                         }
 215                 }
 216
 217                 [UnmanagedFunctionPointer (CallingConvention.Cdecl)]
 218                 delegate bool CloseNativeDelegate (IntPtr inst);
 219
 220                 static bool Close_cb (IntPtr inst)
 221                 {
 222                         try {
 223                                 AudioSink __obj = GLib.Object.GetObject (inst, false) as AudioSink;
 224                                 bool __result;
 225                                 __result = __obj.OnClose ();
 226                                 return __result;
 227                         } catch (Exception e) {
 228                                 GLib.ExceptionManager.RaiseUnhandledException (e, true);
 229                                 // NOTREACHED: above call does not return.
 230                                 throw e;
 231                         }
 232                 }
 233
 234                 [GLib.DefaultSignalHandler(Type=typeof(Gst.Audio.AudioSink), ConnectionMethod="OverrideClose")]
 235                 protected virtual bool OnClose ()
 236                 {
 237                         return InternalClose ();
 238                 }
 239
 240                 private bool InternalClose ()
 241                 {
 242                         CloseNativeDelegate unmanaged = null;
 243                         unsafe {
 244                                 IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("close"));
 245                                 unmanaged = (CloseNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(CloseNativeDelegate));
 246                         }
 247                         if (unmanaged == null) return false;
 248
 249                         bool __result = unmanaged (this.Handle);
 250                         return __result;
 251                 }
 252
 253                 static WriteNativeDelegate Write_cb_delegate;
 254                 static WriteNativeDelegate WriteVMCallback {
 255                         get {
 256                                 if (Write_cb_delegate == null)
 257                                         Write_cb_delegate = new WriteNativeDelegate (Write_cb);
 258                                 return Write_cb_delegate;
 259                         }
 260                 }
 261
 262                 static void OverrideWrite (GLib.GType gtype)
 263                 {
 264                         OverrideWrite (gtype, WriteVMCallback);
 265                 }
 266
 267                 static void OverrideWrite (GLib.GType gtype, WriteNativeDelegate callback)
 268                 {
 269                         unsafe {
 270                                 IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("write"));
 271                                 *raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
 272                         }
 273                 }
 274
 275                 [UnmanagedFunctionPointer (CallingConvention.Cdecl)]
 276                 delegate int WriteNativeDelegate (IntPtr inst, IntPtr data, uint length);
 277
 278                 static int Write_cb (IntPtr inst, IntPtr data, uint length)
 279                 {
 280                         try {
 281                                 AudioSink __obj = GLib.Object.GetObject (inst, false) as AudioSink;
 282                                 int __result;
 283                                 __result = __obj.OnWrite (data, length);
 284                                 return __result;
 285                         } catch (Exception e) {
 286                                 GLib.ExceptionManager.RaiseUnhandledException (e, true);
 287                                 // NOTREACHED: above call does not return.
 288                                 throw e;
 289                         }
 290                 }
 291
 292                 [GLib.DefaultSignalHandler(Type=typeof(Gst.Audio.AudioSink), ConnectionMethod="OverrideWrite")]
 293                 protected virtual int OnWrite (IntPtr data, uint length)
 294                 {
 295                         return InternalWrite (data, length);
 296                 }
 297
 298                 private int InternalWrite (IntPtr data, uint length)
 299                 {
 300                         WriteNativeDelegate unmanaged = null;
 301                         unsafe {
 302                                 IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("write"));
 303                                 unmanaged = (WriteNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(WriteNativeDelegate));
 304                         }
 305                         if (unmanaged == null) return 0;
 306
 307                         int __result = unmanaged (this.Handle, data, length);
 308                         return __result;
 309                 }
 310
 311                 static DelayNativeDelegate Delay_cb_delegate;
 312                 static DelayNativeDelegate DelayVMCallback {
 313                         get {
 314                                 if (Delay_cb_delegate == null)
 315                                         Delay_cb_delegate = new DelayNativeDelegate (Delay_cb);
 316                                 return Delay_cb_delegate;
 317                         }
 318                 }
 319
 320                 static void OverrideDelay (GLib.GType gtype)
 321                 {
 322                         OverrideDelay (gtype, DelayVMCallback);
 323                 }
 324
 325                 static void OverrideDelay (GLib.GType gtype, DelayNativeDelegate callback)
 326                 {
 327                         unsafe {
 328                                 IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("delay"));
 329                                 *raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
 330                         }
 331                 }
 332
 333                 [UnmanagedFunctionPointer (CallingConvention.Cdecl)]
 334                 delegate uint DelayNativeDelegate (IntPtr inst);
 335
 336                 static uint Delay_cb (IntPtr inst)
 337                 {
 338                         try {
 339                                 AudioSink __obj = GLib.Object.GetObject (inst, false) as AudioSink;
 340                                 uint __result;
 341                                 __result = __obj.OnDelay ();
 342                                 return __result;
 343                         } catch (Exception e) {
 344                                 GLib.ExceptionManager.RaiseUnhandledException (e, true);
 345                                 // NOTREACHED: above call does not return.
 346                                 throw e;
 347                         }
 348                 }
 349
 350                 [GLib.DefaultSignalHandler(Type=typeof(Gst.Audio.AudioSink), ConnectionMethod="OverrideDelay")]
 351                 protected virtual uint OnDelay ()
 352                 {
 353                         return InternalDelay ();
 354                 }
 355
 356                 private uint InternalDelay ()
 357                 {
 358                         DelayNativeDelegate unmanaged = null;
 359                         unsafe {
 360                                 IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("delay"));
 361                                 unmanaged = (DelayNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(DelayNativeDelegate));
 362                         }
 363                         if (unmanaged == null) return 0;
 364
 365                         uint __result = unmanaged (this.Handle);
 366                         return __result;
 367                 }
 368
 369                 static ResetNativeDelegate Reset_cb_delegate;
 370                 static ResetNativeDelegate ResetVMCallback {
 371                         get {
 372                                 if (Reset_cb_delegate == null)
 373                                         Reset_cb_delegate = new ResetNativeDelegate (Reset_cb);
 374                                 return Reset_cb_delegate;
 375                         }
 376                 }
 377
 378                 static void OverrideReset (GLib.GType gtype)
 379                 {
 380                         OverrideReset (gtype, ResetVMCallback);
 381                 }
 382
 383                 static void OverrideReset (GLib.GType gtype, ResetNativeDelegate callback)
 384                 {
 385                         unsafe {
 386                                 IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("reset"));
 387                                 *raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
 388                         }
 389                 }
 390
 391                 [UnmanagedFunctionPointer (CallingConvention.Cdecl)]
 392                 delegate void ResetNativeDelegate (IntPtr inst);
 393
 394                 static void Reset_cb (IntPtr inst)
 395                 {
 396                         try {
 397                                 AudioSink __obj = GLib.Object.GetObject (inst, false) as AudioSink;
 398                                 __obj.OnReset ();
 399                         } catch (Exception e) {
 400                                 GLib.ExceptionManager.RaiseUnhandledException (e, false);
 401                         }
 402                 }
 403
 404                 [GLib.DefaultSignalHandler(Type=typeof(Gst.Audio.AudioSink), ConnectionMethod="OverrideReset")]
 405                 protected virtual void OnReset ()
 406                 {
 407                         InternalReset ();
 408                 }
 409
 410                 private void InternalReset ()
 411                 {
 412                         ResetNativeDelegate unmanaged = null;
 413                         unsafe {
 414                                 IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("reset"));
 415                                 unmanaged = (ResetNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(ResetNativeDelegate));
 416                         }
 417                         if (unmanaged == null) return;
 418
 419                         unmanaged (this.Handle);
 420                 }
 421
 422                 static PauseNativeDelegate Pause_cb_delegate;
 423                 static PauseNativeDelegate PauseVMCallback {
 424                         get {
 425                                 if (Pause_cb_delegate == null)
 426                                         Pause_cb_delegate = new PauseNativeDelegate (Pause_cb);
 427                                 return Pause_cb_delegate;
 428                         }
 429                 }
 430
 431                 static void OverridePause (GLib.GType gtype)
 432                 {
 433                         OverridePause (gtype, PauseVMCallback);
 434                 }
 435
 436                 static void OverridePause (GLib.GType gtype, PauseNativeDelegate callback)
 437                 {
 438                         unsafe {
 439                                 IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("pause"));
 440                                 *raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
 441                         }
 442                 }
 443
 444                 [UnmanagedFunctionPointer (CallingConvention.Cdecl)]
 445                 delegate void PauseNativeDelegate (IntPtr inst);
 446
 447                 static void Pause_cb (IntPtr inst)
 448                 {
 449                         try {
 450                                 AudioSink __obj = GLib.Object.GetObject (inst, false) as AudioSink;
 451                                 __obj.OnPause ();
 452                         } catch (Exception e) {
 453                                 GLib.ExceptionManager.RaiseUnhandledException (e, false);
 454                         }
 455                 }
 456
 457                 [GLib.DefaultSignalHandler(Type=typeof(Gst.Audio.AudioSink), ConnectionMethod="OverridePause")]
 458                 protected virtual void OnPause ()
 459                 {
 460                         InternalPause ();
 461                 }
 462
 463                 private void InternalPause ()
 464                 {
 465                         PauseNativeDelegate unmanaged = null;
 466                         unsafe {
 467                                 IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("pause"));
 468                                 unmanaged = (PauseNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(PauseNativeDelegate));
 469                         }
 470                         if (unmanaged == null) return;
 471
 472                         unmanaged (this.Handle);
 473                 }
 474
 475                 static ResumeNativeDelegate Resume_cb_delegate;
 476                 static ResumeNativeDelegate ResumeVMCallback {
 477                         get {
 478                                 if (Resume_cb_delegate == null)
 479                                         Resume_cb_delegate = new ResumeNativeDelegate (Resume_cb);
 480                                 return Resume_cb_delegate;
 481                         }
 482                 }
 483
 484                 static void OverrideResume (GLib.GType gtype)
 485                 {
 486                         OverrideResume (gtype, ResumeVMCallback);
 487                 }
 488
 489                 static void OverrideResume (GLib.GType gtype, ResumeNativeDelegate callback)
 490                 {
 491                         unsafe {
 492                                 IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("resume"));
 493                                 *raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
 494                         }
 495                 }
 496
 497                 [UnmanagedFunctionPointer (CallingConvention.Cdecl)]
 498                 delegate void ResumeNativeDelegate (IntPtr inst);
 499
 500                 static void Resume_cb (IntPtr inst)
 501                 {
 502                         try {
 503                                 AudioSink __obj = GLib.Object.GetObject (inst, false) as AudioSink;
 504                                 __obj.OnResume ();
 505                         } catch (Exception e) {
 506                                 GLib.ExceptionManager.RaiseUnhandledException (e, false);
 507                         }
 508                 }
 509
 510                 [GLib.DefaultSignalHandler(Type=typeof(Gst.Audio.AudioSink), ConnectionMethod="OverrideResume")]
 511                 protected virtual void OnResume ()
 512                 {
 513                         InternalResume ();
 514                 }
 515
 516                 private void InternalResume ()
 517                 {
 518                         ResumeNativeDelegate unmanaged = null;
 519                         unsafe {
 520                                 IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("resume"));
 521                                 unmanaged = (ResumeNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(ResumeNativeDelegate));
 522                         }
 523                         if (unmanaged == null) return;
 524
 525                         unmanaged (this.Handle);
 526                 }
 527
 528                 static StopNativeDelegate Stop_cb_delegate;
 529                 static StopNativeDelegate StopVMCallback {
 530                         get {
 531                                 if (Stop_cb_delegate == null)
 532                                         Stop_cb_delegate = new StopNativeDelegate (Stop_cb);
 533                                 return Stop_cb_delegate;
 534                         }
 535                 }
 536
 537                 static void OverrideStop (GLib.GType gtype)
 538                 {
 539                         OverrideStop (gtype, StopVMCallback);
 540                 }
 541
 542                 static void OverrideStop (GLib.GType gtype, StopNativeDelegate callback)
 543                 {
 544                         unsafe {
 545                                 IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("stop"));
 546                                 *raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
 547                         }
 548                 }
 549
 550                 [UnmanagedFunctionPointer (CallingConvention.Cdecl)]
 551                 delegate void StopNativeDelegate (IntPtr inst);
 552
 553                 static void Stop_cb (IntPtr inst)
 554                 {
 555                         try {
 556                                 AudioSink __obj = GLib.Object.GetObject (inst, false) as AudioSink;
 557                                 __obj.OnStop ();
 558                         } catch (Exception e) {
 559                                 GLib.ExceptionManager.RaiseUnhandledException (e, false);
 560                         }
 561                 }
 562
 563                 [GLib.DefaultSignalHandler(Type=typeof(Gst.Audio.AudioSink), ConnectionMethod="OverrideStop")]
 564                 protected virtual void OnStop ()
 565                 {
 566                         InternalStop ();
 567                 }
 568
 569                 private void InternalStop ()
 570                 {
 571                         StopNativeDelegate unmanaged = null;
 572                         unsafe {
 573                                 IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("stop"));
 574                                 unmanaged = (StopNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(StopNativeDelegate));
 575                         }
 576                         if (unmanaged == null) return;
 577
 578                         unmanaged (this.Handle);
 579                 }
 580
 581
 582                 // Internal representation of the wrapped structure ABI.
 583                 static GLib.AbiStruct _class_abi = null;
 584                 static public new GLib.AbiStruct class_abi {
 585                         get {
 586                                 if (_class_abi == null)
 587                                         _class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{
 588                                                 new GLib.AbiField("open"
 589                                                         , Gst.Audio.AudioBaseSink.class_abi.Fields
 590                                                         , (uint) Marshal.SizeOf(typeof(IntPtr)) // open
 591                                                         , null
 592                                                         , "prepare"
 593                                                         , (uint) Marshal.SizeOf(typeof(IntPtr))
 594                                                         , 0
 595                                                         ),
 596                                                 new GLib.AbiField("prepare"
 597                                                         , -1
 598                                                         , (uint) Marshal.SizeOf(typeof(IntPtr)) // prepare
 599                                                         , "open"
 600                                                         , "unprepare"
 601                                                         , (uint) Marshal.SizeOf(typeof(IntPtr))
 602                                                         , 0
 603                                                         ),
 604                                                 new GLib.AbiField("unprepare"
 605                                                         , -1
 606                                                         , (uint) Marshal.SizeOf(typeof(IntPtr)) // unprepare
 607                                                         , "prepare"
 608                                                         , "close"
 609                                                         , (uint) Marshal.SizeOf(typeof(IntPtr))
 610                                                         , 0
 611                                                         ),
 612                                                 new GLib.AbiField("close"
 613                                                         , -1
 614                                                         , (uint) Marshal.SizeOf(typeof(IntPtr)) // close
 615                                                         , "unprepare"
 616                                                         , "write"
 617                                                         , (uint) Marshal.SizeOf(typeof(IntPtr))
 618                                                         , 0
 619                                                         ),
 620                                                 new GLib.AbiField("write"
 621                                                         , -1
 622                                                         , (uint) Marshal.SizeOf(typeof(IntPtr)) // write
 623                                                         , "close"
 624                                                         , "delay"
 625                                                         , (uint) Marshal.SizeOf(typeof(IntPtr))
 626                                                         , 0
 627                                                         ),
 628                                                 new GLib.AbiField("delay"
 629                                                         , -1
 630                                                         , (uint) Marshal.SizeOf(typeof(IntPtr)) // delay
 631                                                         , "write"
 632                                                         , "reset"
 633                                                         , (uint) Marshal.SizeOf(typeof(IntPtr))
 634                                                         , 0
 635                                                         ),
 636                                                 new GLib.AbiField("reset"
 637                                                         , -1
 638                                                         , (uint) Marshal.SizeOf(typeof(IntPtr)) // reset
 639                                                         , "delay"
 640                                                         , "pause"
 641                                                         , (uint) Marshal.SizeOf(typeof(IntPtr))
 642                                                         , 0
 643                                                         ),
 644                                                 new GLib.AbiField("pause"
 645                                                         , -1
 646                                                         , (uint) Marshal.SizeOf(typeof(IntPtr)) // pause
 647                                                         , "reset"
 648                                                         , "resume"
 649                                                         , (uint) Marshal.SizeOf(typeof(IntPtr))
 650                                                         , 0
 651                                                         ),
 652                                                 new GLib.AbiField("resume"
 653                                                         , -1
 654                                                         , (uint) Marshal.SizeOf(typeof(IntPtr)) // resume
 655                                                         , "pause"
 656                                                         , "stop"
 657                                                         , (uint) Marshal.SizeOf(typeof(IntPtr))
 658                                                         , 0
 659                                                         ),
 660                                                 new GLib.AbiField("stop"
 661                                                         , -1
 662                                                         , (uint) Marshal.SizeOf(typeof(IntPtr)) // stop
 663                                                         , "resume"
 664                                                         , "extension"
 665                                                         , (uint) Marshal.SizeOf(typeof(IntPtr))
 666                                                         , 0
 667                                                         ),
 668                                                 new GLib.AbiField("extension"
 669                                                         , -1
 670                                                         , (uint) Marshal.SizeOf(typeof(IntPtr)) // extension
 671                                                         , "stop"
 672                                                         , null
 673                                                         , (uint) Marshal.SizeOf(typeof(IntPtr))
 674                                                         , 0
 675                                                         ),
 676                                         });
 677
 678                                 return _class_abi;
 679                         }
 680                 }
 681
 682
 683                 // End of the ABI representation.
 684
 685                 [DllImport("gstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
 686                 static extern IntPtr gst_audio_sink_get_type();
 687
 688                 public static new GLib.GType GType {
 689                         get {
 690                                 IntPtr raw_ret = gst_audio_sink_get_type();
 691                                 GLib.GType ret = new GLib.GType(raw_ret);
 692                                 return ret;
 693                         }
 694                 }
 695
 696
 697                 static AudioSink ()
 698                 {
 699                         GtkSharp.GstreamerSharp.ObjectManager.Initialize ();
 700                 }
 701
 702                 // Internal representation of the wrapped structure ABI.
 703                 static GLib.AbiStruct _abi_info = null;
 704                 static public new GLib.AbiStruct abi_info {
 705                         get {
 706                                 if (_abi_info == null)
 707                                         _abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{
 708                                                 new GLib.AbiField("thread"
 709                                                         , Gst.Audio.AudioBaseSink.abi_info.Fields
 710                                                         , (uint) Marshal.SizeOf(typeof(IntPtr)) // thread
 711                                                         , null
 712                                                         , "_gst_reserved"
 713                                                         , (uint) Marshal.SizeOf(typeof(IntPtr))
 714                                                         , 0
 715                                                         ),
 716                                                 new GLib.AbiField("_gst_reserved"
 717                                                         , -1
 718                                                         , (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _gst_reserved
 719                                                         , "thread"
 720                                                         , null
 721                                                         , (uint) Marshal.SizeOf(typeof(IntPtr))
 722                                                         , 0
 723                                                         ),
 724                                         });
 725
 726                                 return _abi_info;
 727                         }
 728                 }
 729
 730
 731                 // End of the ABI representation.
 732
 733 #endregion
 734         }
 735 }