Merging gstreamer-sharp

.gitignore

@@ -0,0 +1,308 @@
+build/
+subprojects/
+
+## Ignore Visual Studio temporary files, build results, and
+## files generated by popular Visual Studio add-ons.
+##
+## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore
+
+# User-specific files
+*.suo
+*.user
+*.userosscache
+*.sln.docstates
+
+# User-specific files (MonoDevelop/Xamarin Studio)
+*.userprefs
+
+# Build results
+[Dd]ebug/
+[Dd]ebugPublic/
+[Rr]elease/
+[Rr]eleases/
+x64/
+x86/
+bld/
+[Bb]in/
+[Oo]bj/
+[Ll]og/
+
+# Visual Studio 2015 cache/options directory
+.vs/
+# Uncomment if you have tasks that create the project's static files in wwwroot
+#wwwroot/
+
+# MSTest test Results
+[Tt]est[Rr]esult*/
+[Bb]uild[Ll]og.*
+
+# NUNIT
+*.VisualState.xml
+TestResult.xml
+
+# Build Results of an ATL Project
+[Dd]ebugPS/
+[Rr]eleasePS/
+dlldata.c
+
+# Benchmark Results
+BenchmarkDotNet.Artifacts/
+
+# .NET Core
+project.lock.json
+project.fragment.lock.json
+artifacts/
+**/Properties/launchSettings.json
+
+*_i.c
+*_p.c
+*_i.h
+*.ilk
+*.meta
+*.obj
+*.pch
+*.pdb
+*.pgc
+*.pgd
+*.rsp
+*.sbr
+*.tlb
+*.tli
+*.tlh
+*.tmp
+*.tmp_proj
+*.log
+*.vspscc
+*.vssscc
+.builds
+*.pidb
+*.svclog
+*.scc
+
+# Chutzpah Test files
+_Chutzpah*
+
+# Visual C++ cache files
+ipch/
+*.aps
+*.ncb
+*.opendb
+*.opensdf
+*.sdf
+*.cachefile
+*.VC.db
+*.VC.VC.opendb
+
+# Visual Studio profiler
+*.psess
+*.vsp
+*.vspx
+*.sap
+
+# Visual Studio Trace Files
+*.e2e
+
+# TFS 2012 Local Workspace
+$tf/
+
+# Guidance Automation Toolkit
+*.gpState
+
+# ReSharper is a .NET coding add-in
+_ReSharper*/
+*.[Rr]e[Ss]harper
+*.DotSettings.user
+
+# JustCode is a .NET coding add-in
+.JustCode
+
+# TeamCity is a build add-in
+_TeamCity*
+
+# DotCover is a Code Coverage Tool
+*.dotCover
+
+# AxoCover is a Code Coverage Tool
+.axoCover/*
+!.axoCover/settings.json
+
+# Visual Studio code coverage results
+*.coverage
+*.coveragexml
+
+# NCrunch
+_NCrunch_*
+.*crunch*.local.xml
+nCrunchTemp_*
+
+# MightyMoose
+*.mm.*
+AutoTest.Net/
+
+# Web workbench (sass)
+.sass-cache/
+
+# Installshield output folder
+[Ee]xpress/
+
+# DocProject is a documentation generator add-in
+DocProject/buildhelp/
+DocProject/Help/*.HxT
+DocProject/Help/*.HxC
+DocProject/Help/*.hhc
+DocProject/Help/*.hhk
+DocProject/Help/*.hhp
+DocProject/Help/Html2
+DocProject/Help/html
+
+# Click-Once directory
+publish/
+
+# Publish Web Output
+*.[Pp]ublish.xml
+*.azurePubxml
+# Note: Comment the next line if you want to checkin your web deploy settings,
+# but database connection strings (with potential passwords) will be unencrypted
+*.pubxml
+*.publishproj
+
+# Microsoft Azure Web App publish settings. Comment the next line if you want to
+# checkin your Azure Web App publish settings, but sensitive information contained
+# in these scripts will be unencrypted
+PublishScripts/
+
+# NuGet Packages
+*.nupkg
+# The packages folder can be ignored because of Package Restore
+**/packages/*
+# except build/, which is used as an MSBuild target.
+!**/packages/build/
+# Uncomment if necessary however generally it will be regenerated when needed
+#!**/packages/repositories.config
+# NuGet v3's project.json files produces more ignorable files
+*.nuget.props
+*.nuget.targets
+
+# Microsoft Azure Build Output
+csx/
+*.build.csdef
+
+# Microsoft Azure Emulator
+ecf/
+rcf/
+
+# Windows Store app package directories and files
+AppPackages/
+BundleArtifacts/
+Package.StoreAssociation.xml
+_pkginfo.txt
+*.appx
+
+# Visual Studio cache files
+# files ending in .cache can be ignored
+*.[Cc]ache
+# but keep track of directories ending in .cache
+!*.[Cc]ache/
+
+# Others
+ClientBin/
+~$*
+*~
+*.dbmdl
+*.dbproj.schemaview
+*.jfm
+*.pfx
+*.publishsettings
+orleans.codegen.cs
+
+# Since there are multiple workflows, uncomment next line to ignore bower_components
+# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
+#bower_components/
+
+# RIA/Silverlight projects
+Generated_Code/
+
+# Backup & report files from converting an old project file
+# to a newer Visual Studio version. Backup files are not needed,
+# because we have git ;-)
+_UpgradeReport_Files/
+Backup*/
+UpgradeLog*.XML
+UpgradeLog*.htm
+
+# SQL Server files
+*.mdf
+*.ldf
+*.ndf
+
+# Business Intelligence projects
+*.rdl.data
+*.bim.layout
+*.bim_*.settings
+
+# Microsoft Fakes
+FakesAssemblies/
+
+# GhostDoc plugin setting file
+*.GhostDoc.xml
+
+# Node.js Tools for Visual Studio
+.ntvs_analysis.dat
+node_modules/
+
+# Typescript v1 declaration files
+typings/
+
+# Visual Studio 6 build log
+*.plg
+
+# Visual Studio 6 workspace options file
+*.opt
+
+# Visual Studio 6 auto-generated workspace file (contains which files were open etc.)
+*.vbw
+
+# Visual Studio LightSwitch build output
+**/*.HTMLClient/GeneratedArtifacts
+**/*.DesktopClient/GeneratedArtifacts
+**/*.DesktopClient/ModelManifest.xml
+**/*.Server/GeneratedArtifacts
+**/*.Server/ModelManifest.xml
+_Pvt_Extensions
+
+# Paket dependency manager
+.paket/paket.exe
+paket-files/
+
+# FAKE - F# Make
+.fake/
+
+# JetBrains Rider
+.idea/
+*.sln.iml
+
+# CodeRush
+.cr/
+
+# Python Tools for Visual Studio (PTVS)
+__pycache__/
+*.pyc
+
+# Cake - Uncomment if you are using it
+# tools/**
+# !tools/packages.config
+
+# Tabs Studio
+*.tss
+
+# Telerik's JustMock configuration file
+*.jmconfig
+
+# BizTalk build output
+*.btp.cs
+*.btm.cs
+*.odx.cs
+*.xsd.cs
+
+# OpenCover UI analysis results
+OpenCover/

.gitlab-ci.yml

@@ -0,0 +1 @@
+include: "https://gitlab.freedesktop.org/gstreamer/gst-ci/raw/master/gitlab/ci_template.yml"

COPYING

@@ -0,0 +1,502 @@
+                  GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+ 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+                  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+                            NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!

README.md

@@ -0,0 +1,90 @@
+gstreamer-sharp
+=========
+
+gstreamer-sharp is a .NET/mono binding for Gstreamer
+generated from gobject-introspection data using the [bindinator].
+gstreamer-sharp currently wraps the API exposed by Gstreamer 1.12
+and is compatible with newer gstreamer versions. It was developed
+under GSoC 2014 for the mono organization. gstreamer-sharp covers
+the core and base gstreamer libraries.
+
+Prerequisites
+----
+These libraries are needed for gstreamer-sharp to compile:
+* gstreamer core, base and good 1.14 or higher
+* [gtk-sharp] 3.22.0 or higher - *NOTE: This can be built as a meson subproject.*
+
+You will also need various .NET/mono bits (mcs and al). On debian-based distros
+you can install these with:
+
+    sudo apt-get install mono-mcs mono-devel
+
+Building
+----
+
+    meson build && ninja -C build/
+
+Installing
+----
+
+This package is not installed as part of the system. It should either
+be built into a Nuget or used as a subproject like this. For example,
+with meson, one would use it like this:
+
+
+    subproject('gstreamer-sharp', default_options: ['install=false'])
+    gst_sharp = subproject('gstreamer-sharp')
+    gst_sharp_dep = gst_sharp.get_variable('gst_sharp_dep')
+
+
+HACKING
+-------
+
+While hacking on the code generator or the `.metadata` files, you will
+need to force code regeneration with `ninja update-code`, a full rebuild
+is triggered right after.
+
+Updating to new GStreamer version
+--------------------------------
+
+Make sure you are in an environement where latest `.gir` files are available (either installed
+or through the `$GI_TYPELIB_PATH` env var), those files are automatically copied to `girs/`.
+
+    ninja -C build update-all
+
+or if using gst-build, start gst-env and then run
+
+    ninja -C build gstreamer-sharp@@update-all
+
+* Verify newly copied gir files in `girs/` and `git add` them
+* Verify newly generated code and `git add` files in `sources/generated/` and `ges/generated`
+* Commit
+
+Supported Platforms
+----
+* Linux
+* Mac OS X
+
+Quick Start
+----
+gstreamer-sharp provides ports of all samples from gst-docs in the samples folder.
+
+Documentation
+----
+
+Since this is a gobject-introspection binding the recommended documentation is
+the native [gstreamer] documentation. A monodoc generated documentation will be installed.
+
+Roadmap
+----
+* Add an easy way to compile on Windows
+* iOS and Android support
+* Provide binaries for these platforms
+
+License
+----
+gstreamer-sharp is licensed under the [LGPL 2.1](https://www.gnu.org/licenses/lgpl-2.1.html)
+
+[bindinator]:https://github.com/GLibSharp/bindinator
+[gtk-sharp]:https://github.com/GLibSharp/GtkSharp
+[gstreamer]: http://gstreamer.freedesktop.org/data/doc/gstreamer/head/gstreamer/html/

Tests/SdpTests.cs

@@ -0,0 +1,44 @@
+// Copyright (C) 2018 Thibault Saunier <tsaunier@igalia.com>
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+// 02110-1301  USA
+
+using NUnit.Framework;
+using System;
+using Gst;
+using Gst.Sdp;
+
+namespace GstSharp.Tests
+{
+    [TestFixture]
+    public class SdpTests : TestBase
+    {
+        [Test]
+        public void TesSdpMessage()
+        {
+            Gst.Application.Init();
+            Gst.Sdp.SDPMessage msg;
+            var res = Gst.Sdp.SDPMessage.New(out msg);
+
+            Assert.AreEqual(res, Gst.Sdp.SDPResult.Ok);
+
+            var uri = "udp://nothing.com";
+            msg.SetUri(uri);
+            Assert.AreEqual(msg.Uri, uri);
+        }
+
+    }
+}
+

Tests/TestBase.cs

@@ -0,0 +1,53 @@
+// Copyright (C) 2018 Collabora Ltd.
+//   Author: Justin Kim <justin.kim@collabora.com>
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+// 02110-1301  USA
+
+using Gst;
+using System.Threading;
+using NUnit.Framework;
+
+namespace GstSharp.Tests
+{
+    [TestFixture]
+    public abstract class TestBase
+    {
+        GLib.MainLoop mainLoop;
+        Thread thread;
+
+        void Run(object o)
+        {
+            GLib.MainContext context = new GLib.MainContext();
+            mainLoop = new GLib.MainLoop(context);
+        }
+
+        [SetUp]
+        public void BaseSetUp()
+        {
+            Assert.IsTrue(Application.InitCheck());
+
+            thread = new Thread(Run);
+            thread.Start();
+        }
+
+        [TearDown]
+        public void BaseTearDown()
+        {
+            mainLoop.Quit();
+            thread.Join();
+        }
+    }
+}

Tests/meson.build

@@ -0,0 +1,53 @@
+nunit_console = find_program('nunit-console', 'nunitlite-runner', required: get_option('tests'))
+
+if nunit_console.found()
+    nunit_tests_env = environment()
+    # FIXME: port this to macOS and Windows
+    nunit_tests_env.prepend('LD_LIBRARY_PATH', testsenv_ld_library_path)
+
+    nunit_version = '3.10.1'
+    get_nunit_res = run_command(nuget, 'get',
+        '--builddir=NUnit',
+        '--nuget-name=NUnit',
+        '--nuget-version', nunit_version,
+        '--csharp-version=net45',
+        '--current-builddir', meson.current_build_dir(),
+        '--builddir', meson.build_root(),
+    )
+
+
+    nunit_mono_path = []
+    nunit_dep = dependency('mono-nunit', required: false, version: ['>=2.6', '< 2.7'])
+    if not nunit_dep.found()
+        if get_nunit_res.returncode() != 0
+            message('Failed to get NUnit: ' + get_nunit_res.stderr())
+        else
+            foreach path: get_nunit_res.stdout().split()
+              nunit_mono_path += [join_paths(meson.build_root(), path.strip('-r:'), '..')]
+            endforeach
+
+            nunit_dep = declare_dependency(link_args: get_nunit_res.stdout().split(),
+                version: nunit_version)
+        endif
+    endif
+
+    if nunit_mono_path.length() > 0
+        nunit_tests_env.prepend('MONO_PATH', nunit_mono_path + mono_path)
+    else
+        nunit_tests_env.prepend('MONO_PATH', mono_path)
+    endif
+
+    if nunit_dep.found()
+        foreach test: [
+                # 'PipelineTests',
+                'SdpTests'
+                ]
+            lib = shared_library(test, test + '.cs', 'TestBase.cs',
+                        cs_args: ['-nowarn:169', '-nowarn:108', '-nowarn:114'],
+                        dependencies: [gst_sharp_dep, nunit_dep])
+            test(test, nunit_console, args: [lib.full_path()], env: nunit_tests_env)
+        endforeach
+    endif
+else
+    message('Could not find nunit-console, can\'t run unitests')
+endif

Tests/test_abi.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python3
+
+import difflib
+import sys
+import shutil
+import subprocess
+
+reference_abi = subprocess.check_output(sys.argv[1]).decode().split("\n")
+launcher = []
+if shutil.which("mono"):
+    launcher = ["mono", "--debug"]
+csharp_abi = subprocess.check_output(launcher + [sys.argv[2]]).decode().split("\n")
+print("Comparing output of %s and %s" % (sys.argv[1], sys.argv[2]))
+
+res = 0
+for line in difflib.unified_diff(reference_abi, csharp_abi):
+    res = 1
+    print(line)
+
+if res:
+    files = [(sys.argv[1] + ".res", reference_abi),
+             (sys.argv[2] + 'res', csharp_abi)]
+
+    for f, vals in files:
+        with open(f, "w") as _f:
+            print("Outputing results in " + f)
+            _f.write("\n".join(vals))
+sys.exit(res)

gacutil_install.py

@@ -0,0 +1,15 @@
+#!/usr/bin/env python3
+
+import os
+import sys
+import subprocess
+
+outdir = os.path.join(os.environ['MESON_INSTALL_DESTDIR_PREFIX'], 'lib')
+builddir = os.environ['MESON_BUILD_ROOT']
+
+for i in range(1, len(sys.argv), 2):
+    assembly_name, fname = sys.argv[i], os.path.join(builddir, sys.argv[i + 1])
+
+    cmd = ['gacutil', '/i', fname, '/f', '/package', assembly_name, '/root', outdir]
+    print('(%s) Running %s' % (os.path.abspath(os.path.curdir), ' '.join(cmd)))
+    subprocess.check_call(cmd)

generate_code.py

@@ -0,0 +1,99 @@
+#!/usr/bin/env python3
+
+import argparse
+import glob
+import os
+import re
+import shutil
+import subprocess
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--api-raw")
+    parser.add_argument("--gapi-fixup")
+    parser.add_argument("--metadata")
+    parser.add_argument("--gapi-codegen")
+    parser.add_argument("--abi-includes", default="")
+    parser.add_argument("--abi-cs-usings", default="")
+    parser.add_argument("--assembly-name")
+    parser.add_argument("--extra-includes", action='append', default=[])
+    parser.add_argument("--out")
+    parser.add_argument("--files")
+    parser.add_argument("--symbols")
+    parser.add_argument("--schema")
+    parser.add_argument("--fake", action='store_true')
+
+    opts = parser.parse_args()
+    if opts.fake:
+        exit(0)
+
+    api_xml = os.path.join(opts.out, os.path.basename(
+        opts.api_raw).replace('.raw', '.xml'))
+
+    shutil.copyfile(opts.api_raw, api_xml)
+
+    if shutil.which('mono'):
+        launcher = ['mono', '--debug']
+    else:
+        launcher = []
+
+    cmd = [opts.gapi_fixup, "--api=" + api_xml]
+    if opts.metadata:
+        cmd += ["--metadata=" + opts.metadata]
+    if opts.symbols:
+        cmd.extend(['--symbols=' + opts.symbols])
+    subprocess.check_call(launcher + cmd)
+
+    cmd = [
+        opts.gapi_codegen, '--generate', api_xml,
+        '--outdir=' + opts.out,
+        '--assembly-name=' + opts.assembly_name,
+        '--glue-includes=' + opts.abi_includes,
+        '--abi-c-filename=' +
+        os.path.join(opts.out, opts.assembly_name + "-abi.c"),
+        '--abi-cs-filename=' +
+        os.path.join(opts.out, opts.assembly_name + "-abi.cs"),
+    ]
+
+    if opts.schema:
+        cmd += ['--schema=' + opts.schema]
+
+    if opts.abi_cs_usings:
+        cmd += ['--abi-cs-usings=' + opts.abi_cs_usings]
+
+    cmd += ['-I' + i for i in opts.extra_includes]
+
+    subprocess.check_call(launcher + cmd)
+
+    # WORKAROUND: Moving files into the out directory with special names
+    # as meson doesn't like path separator in output names.
+    regex = re.compile('_')
+    dirs = set()
+    expected_files = set(opts.files.split(';'))
+    for _f in expected_files:
+        dirs.add(os.path.dirname(_f))
+
+    generated = set(glob.glob(os.path.join('*/*.cs')))
+    rcode = 0
+    not_listed = generated - expected_files
+    if not_listed:
+        print("Following files were generated but not listed:\n    %s" %
+              '\n    '.join(["'%s/%s'," % (m.split(os.path.sep)[-2], m.split(os.path.sep)[-1])
+                             for m in not_listed]))
+        rcode = 1
+
+    not_generated = expected_files - generated
+    if not_generated:
+        print("Following files were generated but not listed:\n    %s" %
+              '\n    '.join(["'%s/%s'," % (m.split(os.path.sep)[-2], m.split(os.path.sep)[-1])
+                             for m in not_generated]))
+        rcode = 1
+
+    if rcode == 1:
+        generated = sorted(list(generated))
+        print("List of files to use in `meson.build`:\n    %s" %
+              '\n    '.join(["'%s/%s'," % (m.split(os.path.sep)[-2], m.split(os.path.sep)[-1])
+                             for m in generated]))
+
+    exit(rcode)

ges/generated/GES/AssetAddedHandler.cs

@@ -0,0 +1,18 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+
+	public delegate void AssetAddedHandler(object o, AssetAddedArgs args);
+
+	public class AssetAddedArgs : GLib.SignalArgs {
+		public GES.Asset Asset{
+			get {
+				return (GES.Asset) Args [0];
+			}
+		}
+
+	}
+}

ges/generated/GES/AssetLoadingHandler.cs

@@ -0,0 +1,18 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+
+	public delegate void AssetLoadingHandler(object o, AssetLoadingArgs args);
+
+	public class AssetLoadingArgs : GLib.SignalArgs {
+		public GES.Asset Asset{
+			get {
+				return (GES.Asset) Args [0];
+			}
+		}
+
+	}
+}

ges/generated/GES/AssetLoadingReturn.cs

@@ -0,0 +1,17 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public enum AssetLoadingReturn {
+
+		Error = 0,
+		Async = 1,
+		Ok = 2,
+	}
+#endregion
+}

ges/generated/GES/AssetRemovedHandler.cs

@@ -0,0 +1,18 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+
+	public delegate void AssetRemovedHandler(object o, AssetRemovedArgs args);
+
+	public class AssetRemovedArgs : GLib.SignalArgs {
+		public GES.Asset Asset{
+			get {
+				return (GES.Asset) Args [0];
+			}
+		}
+
+	}
+}

ges/generated/GES/AudioSource.cs

@@ -0,0 +1,103 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class AudioSource : GES.Source {
+
+		protected AudioSource (IntPtr raw) : base(raw) {}
+
+		protected AudioSource() : base(IntPtr.Zero)
+		{
+			CreateNativeObject (new string [0], new GLib.Value [0]);
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("create_source"
+							, GES.Source.class_abi.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // create_source
+							, null
+							, "_ges_reserved"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("_ges_reserved"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _ges_reserved
+							, "create_source"
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_audio_source_get_type();
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = ges_audio_source_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+
+		static AudioSource ()
+		{
+			GtkSharp.GstEditingServices.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("priv"
+							, GES.Source.abi_info.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // priv
+							, null
+							, "_ges_reserved"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("_ges_reserved"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _ges_reserved
+							, "priv"
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

ges/generated/GES/AudioTestSource.cs

@@ -0,0 +1,129 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class AudioTestSource : GES.AudioSource {
+
+		public AudioTestSource (IntPtr raw) : base(raw) {}
+
+		protected AudioTestSource() : base(IntPtr.Zero)
+		{
+			CreateNativeObject (new string [0], new GLib.Value [0]);
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("_ges_reserved"
+							, GES.AudioSource.class_abi.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _ges_reserved
+							, null
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_audio_test_source_get_type();
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = ges_audio_test_source_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern double ges_audio_test_source_get_freq(IntPtr raw);
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern void ges_audio_test_source_set_freq(IntPtr raw, double freq);
+
+		public double Freq { 
+			get {
+				double raw_ret = ges_audio_test_source_get_freq(Handle);
+				double ret = raw_ret;
+				return ret;
+			}
+			set {
+				ges_audio_test_source_set_freq(Handle, value);
+			}
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern double ges_audio_test_source_get_volume(IntPtr raw);
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern void ges_audio_test_source_set_volume(IntPtr raw, double volume);
+
+		public double Volume { 
+			get {
+				double raw_ret = ges_audio_test_source_get_volume(Handle);
+				double ret = raw_ret;
+				return ret;
+			}
+			set {
+				ges_audio_test_source_set_volume(Handle, value);
+			}
+		}
+
+
+		static AudioTestSource ()
+		{
+			GtkSharp.GstEditingServices.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("priv"
+							, GES.AudioSource.abi_info.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // priv
+							, null
+							, "_ges_reserved"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("_ges_reserved"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _ges_reserved
+							, "priv"
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

ges/generated/GES/AudioTrack.cs

@@ -0,0 +1,102 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class AudioTrack : GES.Track {
+
+		public AudioTrack (IntPtr raw) : base(raw) {}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_audio_track_new();
+
+		public AudioTrack () : base (IntPtr.Zero)
+		{
+			if (GetType () != typeof (AudioTrack)) {
+				CreateNativeObject (new string [0], new GLib.Value[0]);
+				return;
+			}
+			Raw = ges_audio_track_new();
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("_ges_reserved"
+							, GES.Track.class_abi.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _ges_reserved
+							, null
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_audio_track_get_type();
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = ges_audio_track_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+
+		static AudioTrack ()
+		{
+			GtkSharp.GstEditingServices.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("priv"
+							, GES.Track.abi_info.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // priv
+							, null
+							, "_ges_reserved"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("_ges_reserved"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _ges_reserved
+							, "priv"
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

ges/generated/GES/AudioTransition.cs

@@ -0,0 +1,102 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class AudioTransition : GES.Transition {
+
+		public AudioTransition (IntPtr raw) : base(raw) {}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_audio_transition_new();
+
+		public AudioTransition () : base (IntPtr.Zero)
+		{
+			if (GetType () != typeof (AudioTransition)) {
+				CreateNativeObject (new string [0], new GLib.Value[0]);
+				return;
+			}
+			Raw = ges_audio_transition_new();
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("_ges_reserved"
+							, GES.Transition.class_abi.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _ges_reserved
+							, null
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_audio_transition_get_type();
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = ges_audio_transition_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+
+		static AudioTransition ()
+		{
+			GtkSharp.GstEditingServices.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("priv"
+							, GES.Transition.abi_info.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // priv
+							, null
+							, "_ges_reserved"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("_ges_reserved"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _ges_reserved
+							, "priv"
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

ges/generated/GES/AudioUriSource.cs

@@ -0,0 +1,113 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class AudioUriSource : GES.AudioSource {
+
+		public AudioUriSource (IntPtr raw) : base(raw) {}
+
+		protected AudioUriSource() : base(IntPtr.Zero)
+		{
+			CreateNativeObject (new string [0], new GLib.Value [0]);
+		}
+
+		[GLib.Property ("uri")]
+		public string Uri {
+			get {
+				GLib.Value val = GetProperty ("uri");
+				string ret = (string) val;
+				val.Dispose ();
+				return ret;
+			}
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("_ges_reserved"
+							, GES.AudioSource.class_abi.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _ges_reserved
+							, null
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_audio_uri_source_get_type();
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = ges_audio_uri_source_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+
+		static AudioUriSource ()
+		{
+			GtkSharp.GstEditingServices.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("uri"
+							, GES.AudioSource.abi_info.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // uri
+							, null
+							, "priv"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("priv"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // priv
+							, "uri"
+							, "_ges_reserved"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("_ges_reserved"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _ges_reserved
+							, "priv"
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

ges/generated/GES/BaseEffect.cs

@@ -0,0 +1,117 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class BaseEffect : GES.Operation {
+
+		protected BaseEffect (IntPtr raw) : base(raw) {}
+
+		protected BaseEffect() : base(IntPtr.Zero)
+		{
+			CreateNativeObject (new string [0], new GLib.Value [0]);
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("_ges_reserved"
+							, GES.Operation.class_abi.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _ges_reserved
+							, null
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_base_effect_get_type();
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = ges_base_effect_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_base_effect_is_time_effect(IntPtr raw);
+
+		public bool IsTimeEffect { 
+			get {
+				bool raw_ret = ges_base_effect_is_time_effect(Handle);
+				bool ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_base_effect_register_time_property(IntPtr raw, IntPtr child_property_name);
+
+		public bool RegisterTimeProperty(string child_property_name) {
+			IntPtr native_child_property_name = GLib.Marshaller.StringToPtrGStrdup (child_property_name);
+			bool raw_ret = ges_base_effect_register_time_property(Handle, native_child_property_name);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_child_property_name);
+			return ret;
+		}
+
+
+		static BaseEffect ()
+		{
+			GtkSharp.GstEditingServices.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("priv"
+							, GES.Operation.abi_info.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // priv
+							, null
+							, "_ges_reserved"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("_ges_reserved"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _ges_reserved
+							, "priv"
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

ges/generated/GES/BaseEffectClip.cs

@@ -0,0 +1,95 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class BaseEffectClip : GES.OperationClip {
+
+		protected BaseEffectClip (IntPtr raw) : base(raw) {}
+
+		protected BaseEffectClip() : base(IntPtr.Zero)
+		{
+			CreateNativeObject (new string [0], new GLib.Value [0]);
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("_ges_reserved"
+							, GES.OperationClip.class_abi.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _ges_reserved
+							, null
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_base_effect_clip_get_type();
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = ges_base_effect_clip_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+
+		static BaseEffectClip ()
+		{
+			GtkSharp.GstEditingServices.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("priv"
+							, GES.OperationClip.abi_info.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // priv
+							, null
+							, "_ges_reserved"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("_ges_reserved"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _ges_reserved
+							, "priv"
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

ges/generated/GES/BaseEffectTimeTranslationFunc.cs

@@ -0,0 +1,10 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+
+	public delegate ulong BaseEffectTimeTranslationFunc(GES.BaseEffect effect, ulong time, System.IntPtr time_property_values);
+
+}

ges/generated/GES/BaseTransitionClip.cs

@@ -0,0 +1,95 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class BaseTransitionClip : GES.OperationClip {
+
+		protected BaseTransitionClip (IntPtr raw) : base(raw) {}
+
+		protected BaseTransitionClip() : base(IntPtr.Zero)
+		{
+			CreateNativeObject (new string [0], new GLib.Value [0]);
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("_ges_reserved"
+							, GES.OperationClip.class_abi.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _ges_reserved
+							, null
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_base_transition_clip_get_type();
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = ges_base_transition_clip_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+
+		static BaseTransitionClip ()
+		{
+			GtkSharp.GstEditingServices.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("priv"
+							, GES.OperationClip.abi_info.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // priv
+							, null
+							, "_ges_reserved"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("_ges_reserved"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _ges_reserved
+							, "priv"
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

ges/generated/GES/BaseXmlFormatter.cs

@@ -0,0 +1,126 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class BaseXmlFormatter : GES.Formatter {
+
+		protected BaseXmlFormatter (IntPtr raw) : base(raw) {}
+
+		protected BaseXmlFormatter() : base(IntPtr.Zero)
+		{
+			CreateNativeObject (new string [0], new GLib.Value [0]);
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("content_parser"
+							, GES.Formatter.class_abi.Fields
+							, (uint) Marshal.SizeOf(typeof(GLib.MarkupParser)) // content_parser
+							, null
+							, "save"
+							, (long) Marshal.OffsetOf(typeof(GESBaseXmlFormatter_content_parserAlign), "content_parser")
+							, 0
+							),
+						new GLib.AbiField("save"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // save
+							, "content_parser"
+							, "_ges_reserved"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("_ges_reserved"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _ges_reserved
+							, "save"
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+		[StructLayout(LayoutKind.Sequential)]
+		public struct GESBaseXmlFormatter_content_parserAlign
+		{
+			sbyte f1;
+			private GLib.MarkupParser content_parser;
+		}
+
+
+		// End of the ABI representation.
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_base_xml_formatter_get_type();
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = ges_base_xml_formatter_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+
+		static BaseXmlFormatter ()
+		{
+			GtkSharp.GstEditingServices.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("priv"
+							, GES.Formatter.abi_info.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // priv
+							, null
+							, "xmlcontent"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("xmlcontent"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // xmlcontent
+							, "priv"
+							, "_ges_reserved"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("_ges_reserved"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 3 // _ges_reserved
+							, "xmlcontent"
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

ges/generated/GES/ChildAddedHandler.cs

@@ -0,0 +1,18 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+
+	public delegate void ChildAddedHandler(object o, ChildAddedArgs args);
+
+	public class ChildAddedArgs : GLib.SignalArgs {
+		public GES.TimelineElement Element{
+			get {
+				return (GES.TimelineElement) Args [0];
+			}
+		}
+
+	}
+}

ges/generated/GES/ChildPropertyAddedHandler.cs

@@ -0,0 +1,24 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+
+	public delegate void ChildPropertyAddedHandler(object o, ChildPropertyAddedArgs args);
+
+	public class ChildPropertyAddedArgs : GLib.SignalArgs {
+		public GLib.Object PropObject{
+			get {
+				return (GLib.Object) Args [0];
+			}
+		}
+
+		public IntPtr Prop{
+			get {
+				return (IntPtr) Args [1];
+			}
+		}
+
+	}
+}

ges/generated/GES/ChildPropertyRemovedHandler.cs

@@ -0,0 +1,24 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+
+	public delegate void ChildPropertyRemovedHandler(object o, ChildPropertyRemovedArgs args);
+
+	public class ChildPropertyRemovedArgs : GLib.SignalArgs {
+		public GLib.Object PropObject{
+			get {
+				return (GLib.Object) Args [0];
+			}
+		}
+
+		public IntPtr Prop{
+			get {
+				return (IntPtr) Args [1];
+			}
+		}
+
+	}
+}

ges/generated/GES/ChildRemovedHandler.cs

@@ -0,0 +1,18 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+
+	public delegate void ChildRemovedHandler(object o, ChildRemovedArgs args);
+
+	public class ChildRemovedArgs : GLib.SignalArgs {
+		public GES.TimelineElement Element{
+			get {
+				return (GES.TimelineElement) Args [0];
+			}
+		}
+
+	}
+}

ges/generated/GES/ChildrenControlMode.cs

@@ -0,0 +1,19 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public enum ChildrenControlMode {
+
+		Update = 0,
+		IgnoreNotifies = 1,
+		UpdateOffsets = 2,
+		UpdateAllValues = 3,
+		Last = 4,
+	}
+#endregion
+}

ges/generated/GES/Clip.cs

@@ -0,0 +1,368 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class Clip : GES.Container {
+
+		protected Clip (IntPtr raw) : base(raw) {}
+
+		protected Clip() : base(IntPtr.Zero)
+		{
+			CreateNativeObject (new string [0], new GLib.Value [0]);
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern ulong ges_clip_get_duration_limit(IntPtr raw);
+
+		[GLib.Property ("duration-limit")]
+		public ulong DurationLimit {
+			get  {
+				ulong raw_ret = ges_clip_get_duration_limit(Handle);
+				ulong ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_clip_get_layer(IntPtr raw);
+
+		[GLib.Property ("layer")]
+		public GES.Layer Layer {
+			get  {
+				IntPtr raw_ret = ges_clip_get_layer(Handle);
+				GES.Layer ret = GLib.Object.GetObject(raw_ret, true) as GES.Layer;
+				return ret;
+			}
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern int ges_clip_get_supported_formats(IntPtr raw);
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern void ges_clip_set_supported_formats(IntPtr raw, int supportedformats);
+
+		[GLib.Property ("supported-formats")]
+		public GES.TrackType SupportedFormats {
+			get  {
+				int raw_ret = ges_clip_get_supported_formats(Handle);
+				GES.TrackType ret = (GES.TrackType) raw_ret;
+				return ret;
+			}
+			set  {
+				ges_clip_set_supported_formats(Handle, (int) value);
+			}
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("create_track_element"
+							, GES.Container.class_abi.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // create_track_element
+							, null
+							, "create_track_elements"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("create_track_elements"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // create_track_elements
+							, "create_track_element"
+							, "ABI"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						// union struct ABI.abi
+						// End ABI.abi
+
+						// union struct ABI
+							new GLib.AbiField("ABI._gst_reserved"
+								, -1
+								, (uint) Marshal.SizeOf(typeof(IntPtr)) * 20 // ABI._gst_reserved
+								, "create_track_elements"
+								, null
+								, (uint) Marshal.SizeOf(typeof(IntPtr))
+								, 0
+								),
+						// End ABI
+
+						new GLib.AbiField("ABI"
+							, -1
+							, new List<List<string>>() {  // union ABI
+						new List<string>() {},
+						new List<string>() {"ABI._gst_reserved"}
+					  }
+							, "create_track_elements"
+							, null
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_clip_get_type();
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = ges_clip_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_clip_add_asset(IntPtr raw, IntPtr asset);
+
+		public GES.TrackElement AddAsset(GES.Asset asset) {
+			IntPtr raw_ret = ges_clip_add_asset(Handle, asset == null ? IntPtr.Zero : asset.Handle);
+			GES.TrackElement ret = GLib.Object.GetObject(raw_ret) as GES.TrackElement;
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern unsafe IntPtr ges_clip_add_child_to_track(IntPtr raw, IntPtr child, IntPtr track, out IntPtr error);
+
+		public unsafe GES.TrackElement AddChildToTrack(GES.TrackElement child, GES.Track track) {
+			IntPtr error = IntPtr.Zero;
+			IntPtr raw_ret = ges_clip_add_child_to_track(Handle, child == null ? IntPtr.Zero : child.Handle, track == null ? IntPtr.Zero : track.Handle, out error);
+			GES.TrackElement ret = GLib.Object.GetObject(raw_ret) as GES.TrackElement;
+			if (error != IntPtr.Zero) throw new GLib.GException (error);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern unsafe bool ges_clip_add_top_effect(IntPtr raw, IntPtr effect, int index, out IntPtr error);
+
+		public unsafe bool AddTopEffect(GES.BaseEffect effect, int index) {
+			IntPtr error = IntPtr.Zero;
+			bool raw_ret = ges_clip_add_top_effect(Handle, effect == null ? IntPtr.Zero : effect.Handle, index, out error);
+			bool ret = raw_ret;
+			if (error != IntPtr.Zero) throw new GLib.GException (error);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_clip_find_track_element(IntPtr raw, IntPtr track, IntPtr type);
+
+		public GES.TrackElement FindTrackElement(GES.Track track, GLib.GType type) {
+			IntPtr raw_ret = ges_clip_find_track_element(Handle, track == null ? IntPtr.Zero : track.Handle, type.Val);
+			GES.TrackElement ret = GLib.Object.GetObject(raw_ret, true) as GES.TrackElement;
+			return ret;
+		}
+
+		public GES.TrackElement FindTrackElement(GLib.GType type) {
+			return FindTrackElement (null, type);
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_clip_find_track_elements(IntPtr raw, IntPtr track, int track_type, IntPtr type);
+
+		public GES.TrackElement[] FindTrackElements(GES.Track track, GES.TrackType track_type, GLib.GType type) {
+			IntPtr raw_ret = ges_clip_find_track_elements(Handle, track == null ? IntPtr.Zero : track.Handle, (int) track_type, type.Val);
+			GES.TrackElement[] ret = (GES.TrackElement[]) GLib.Marshaller.ListPtrToArray (raw_ret, typeof(GLib.List), true, true, typeof(GES.TrackElement));
+			return ret;
+		}
+
+		public GES.TrackElement[] FindTrackElements(GES.TrackType track_type, GLib.GType type) {
+			return FindTrackElements (null, track_type, type);
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern unsafe ulong ges_clip_get_internal_time_from_timeline_time(IntPtr raw, IntPtr child, ulong timeline_time, out IntPtr error);
+
+		public unsafe ulong GetInternalTimeFromTimelineTime(GES.TrackElement child, ulong timeline_time) {
+			IntPtr error = IntPtr.Zero;
+			ulong raw_ret = ges_clip_get_internal_time_from_timeline_time(Handle, child == null ? IntPtr.Zero : child.Handle, timeline_time, out error);
+			ulong ret = raw_ret;
+			if (error != IntPtr.Zero) throw new GLib.GException (error);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern unsafe ulong ges_clip_get_timeline_time_from_internal_time(IntPtr raw, IntPtr child, ulong internal_time, out IntPtr error);
+
+		public unsafe ulong GetTimelineTimeFromInternalTime(GES.TrackElement child, ulong internal_time) {
+			IntPtr error = IntPtr.Zero;
+			ulong raw_ret = ges_clip_get_timeline_time_from_internal_time(Handle, child == null ? IntPtr.Zero : child.Handle, internal_time, out error);
+			ulong ret = raw_ret;
+			if (error != IntPtr.Zero) throw new GLib.GException (error);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern unsafe ulong ges_clip_get_timeline_time_from_source_frame(IntPtr raw, long frame_number, out IntPtr error);
+
+		public unsafe ulong GetTimelineTimeFromSourceFrame(long frame_number) {
+			IntPtr error = IntPtr.Zero;
+			ulong raw_ret = ges_clip_get_timeline_time_from_source_frame(Handle, frame_number, out error);
+			ulong ret = raw_ret;
+			if (error != IntPtr.Zero) throw new GLib.GException (error);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern int ges_clip_get_top_effect_index(IntPtr raw, IntPtr effect);
+
+		public int GetTopEffectIndex(GES.BaseEffect effect) {
+			int raw_ret = ges_clip_get_top_effect_index(Handle, effect == null ? IntPtr.Zero : effect.Handle);
+			int ret = raw_ret;
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern int ges_clip_get_top_effect_position(IntPtr raw, IntPtr effect);
+
+		public int GetTopEffectPosition(GES.BaseEffect effect) {
+			int raw_ret = ges_clip_get_top_effect_position(Handle, effect == null ? IntPtr.Zero : effect.Handle);
+			int ret = raw_ret;
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_clip_get_top_effects(IntPtr raw);
+
+		public GES.TrackElement[] TopEffects { 
+			get {
+				IntPtr raw_ret = ges_clip_get_top_effects(Handle);
+				GES.TrackElement[] ret = (GES.TrackElement[]) GLib.Marshaller.ListPtrToArray (raw_ret, typeof(GLib.List), true, true, typeof(GES.TrackElement));
+				return ret;
+			}
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_clip_move_to_layer(IntPtr raw, IntPtr layer);
+
+		public bool MoveToLayer(GES.Layer layer) {
+			bool raw_ret = ges_clip_move_to_layer(Handle, layer == null ? IntPtr.Zero : layer.Handle);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern unsafe bool ges_clip_move_to_layer_full(IntPtr raw, IntPtr layer, out IntPtr error);
+
+		public unsafe bool MoveToLayerFull(GES.Layer layer) {
+			IntPtr error = IntPtr.Zero;
+			bool raw_ret = ges_clip_move_to_layer_full(Handle, layer == null ? IntPtr.Zero : layer.Handle, out error);
+			bool ret = raw_ret;
+			if (error != IntPtr.Zero) throw new GLib.GException (error);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern unsafe bool ges_clip_remove_top_effect(IntPtr raw, IntPtr effect, out IntPtr error);
+
+		public unsafe bool RemoveTopEffect(GES.BaseEffect effect) {
+			IntPtr error = IntPtr.Zero;
+			bool raw_ret = ges_clip_remove_top_effect(Handle, effect == null ? IntPtr.Zero : effect.Handle, out error);
+			bool ret = raw_ret;
+			if (error != IntPtr.Zero) throw new GLib.GException (error);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_clip_set_top_effect_index(IntPtr raw, IntPtr effect, uint newindex);
+
+		public bool SetTopEffectIndex(GES.BaseEffect effect, uint newindex) {
+			bool raw_ret = ges_clip_set_top_effect_index(Handle, effect == null ? IntPtr.Zero : effect.Handle, newindex);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern unsafe bool ges_clip_set_top_effect_index_full(IntPtr raw, IntPtr effect, uint newindex, out IntPtr error);
+
+		public unsafe bool SetTopEffectIndexFull(GES.BaseEffect effect, uint newindex) {
+			IntPtr error = IntPtr.Zero;
+			bool raw_ret = ges_clip_set_top_effect_index_full(Handle, effect == null ? IntPtr.Zero : effect.Handle, newindex, out error);
+			bool ret = raw_ret;
+			if (error != IntPtr.Zero) throw new GLib.GException (error);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_clip_set_top_effect_priority(IntPtr raw, IntPtr effect, uint newpriority);
+
+		public bool SetTopEffectPriority(GES.BaseEffect effect, uint newpriority) {
+			bool raw_ret = ges_clip_set_top_effect_priority(Handle, effect == null ? IntPtr.Zero : effect.Handle, newpriority);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_clip_split(IntPtr raw, ulong position);
+
+		public GES.Clip Split(ulong position) {
+			IntPtr raw_ret = ges_clip_split(Handle, position);
+			GES.Clip ret = GLib.Object.GetObject(raw_ret) as GES.Clip;
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern unsafe IntPtr ges_clip_split_full(IntPtr raw, ulong position, out IntPtr error);
+
+		public unsafe GES.Clip SplitFull(ulong position) {
+			IntPtr error = IntPtr.Zero;
+			IntPtr raw_ret = ges_clip_split_full(Handle, position, out error);
+			GES.Clip ret = GLib.Object.GetObject(raw_ret) as GES.Clip;
+			if (error != IntPtr.Zero) throw new GLib.GException (error);
+			return ret;
+		}
+
+
+		static Clip ()
+		{
+			GtkSharp.GstEditingServices.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("priv"
+							, GES.Container.abi_info.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // priv
+							, null
+							, "_ges_reserved"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("_ges_reserved"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 20 // _ges_reserved
+							, "priv"
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

ges/generated/GES/ClipAddedHandler.cs

@@ -0,0 +1,18 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+
+	public delegate void ClipAddedHandler(object o, ClipAddedArgs args);
+
+	public class ClipAddedArgs : GLib.SignalArgs {
+		public GES.Clip Clip{
+			get {
+				return (GES.Clip) Args [0];
+			}
+		}
+
+	}
+}

ges/generated/GES/ClipAsset.cs

@@ -0,0 +1,197 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class ClipAsset : GES.Asset {
+
+		public ClipAsset (IntPtr raw) : base(raw) {}
+
+		protected ClipAsset() : base(IntPtr.Zero)
+		{
+			CreateNativeObject (new string [0], new GLib.Value [0]);
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern int ges_clip_asset_get_supported_formats(IntPtr raw);
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern void ges_clip_asset_set_supported_formats(IntPtr raw, int supportedformats);
+
+		[GLib.Property ("supported-formats")]
+		public GES.TrackType SupportedFormats {
+			get  {
+				int raw_ret = ges_clip_asset_get_supported_formats(Handle);
+				GES.TrackType ret = (GES.TrackType) raw_ret;
+				return ret;
+			}
+			set  {
+				ges_clip_asset_set_supported_formats(Handle, (int) value);
+			}
+		}
+
+		static GetNaturalFramerateNativeDelegate GetNaturalFramerate_cb_delegate;
+		static GetNaturalFramerateNativeDelegate GetNaturalFramerateVMCallback {
+			get {
+				if (GetNaturalFramerate_cb_delegate == null)
+					GetNaturalFramerate_cb_delegate = new GetNaturalFramerateNativeDelegate (GetNaturalFramerate_cb);
+				return GetNaturalFramerate_cb_delegate;
+			}
+		}
+
+		static void OverrideGetNaturalFramerate (GLib.GType gtype)
+		{
+			OverrideGetNaturalFramerate (gtype, GetNaturalFramerateVMCallback);
+		}
+
+		static void OverrideGetNaturalFramerate (GLib.GType gtype, GetNaturalFramerateNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_natural_framerate"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool GetNaturalFramerateNativeDelegate (IntPtr inst, int framerate_n, int framerate_d);
+
+		static bool GetNaturalFramerate_cb (IntPtr inst, int framerate_n, int framerate_d)
+		{
+			try {
+				ClipAsset __obj = GLib.Object.GetObject (inst, false) as ClipAsset;
+				bool __result;
+				__result = __obj.OnGetNaturalFramerate (framerate_n, framerate_d);
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw e;
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(GES.ClipAsset), ConnectionMethod="OverrideGetNaturalFramerate")]
+		protected virtual bool OnGetNaturalFramerate (int framerate_n, int framerate_d)
+		{
+			return InternalGetNaturalFramerate (framerate_n, framerate_d);
+		}
+
+		private bool InternalGetNaturalFramerate (int framerate_n, int framerate_d)
+		{
+			GetNaturalFramerateNativeDelegate unmanaged = null;
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_natural_framerate"));
+				unmanaged = (GetNaturalFramerateNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetNaturalFramerateNativeDelegate));
+			}
+			if (unmanaged == null) return false;
+
+			bool __result = unmanaged (this.Handle, framerate_n, framerate_d);
+			return __result;
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("get_natural_framerate"
+							, GES.Asset.class_abi.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_natural_framerate
+							, null
+							, "_ges_reserved"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("_ges_reserved"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 3 // _ges_reserved
+							, "get_natural_framerate"
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_clip_asset_get_type();
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = ges_clip_asset_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern ulong ges_clip_asset_get_frame_time(IntPtr raw, long frame_number);
+
+		public ulong GetFrameTime(long frame_number) {
+			ulong raw_ret = ges_clip_asset_get_frame_time(Handle, frame_number);
+			ulong ret = raw_ret;
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_clip_asset_get_natural_framerate(IntPtr raw, int framerate_n, int framerate_d);
+
+		public bool GetNaturalFramerate(int framerate_n, int framerate_d) {
+			bool raw_ret = ges_clip_asset_get_natural_framerate(Handle, framerate_n, framerate_d);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+
+		static ClipAsset ()
+		{
+			GtkSharp.GstEditingServices.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("priv"
+							, GES.Asset.abi_info.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // priv
+							, null
+							, "_ges_reserved"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("_ges_reserved"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _ges_reserved
+							, "priv"
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

ges/generated/GES/ClipRemovedHandler.cs

@@ -0,0 +1,18 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+
+	public delegate void ClipRemovedHandler(object o, ClipRemovedArgs args);
+
+	public class ClipRemovedArgs : GLib.SignalArgs {
+		public GES.Clip Clip{
+			get {
+				return (GES.Clip) Args [0];
+			}
+		}
+
+	}
+}

ges/generated/GES/CommandLineFormatter.cs

@@ -0,0 +1,89 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class CommandLineFormatter : GES.Formatter {
+
+		public CommandLineFormatter (IntPtr raw) : base(raw) {}
+
+		protected CommandLineFormatter() : base(IntPtr.Zero)
+		{
+			CreateNativeObject (new string [0], new GLib.Value [0]);
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (GES.Formatter.class_abi.Fields);
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_command_line_formatter_get_type();
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = ges_command_line_formatter_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_command_line_formatter_get_help(int nargs, IntPtr commands);
+
+		public static string GetHelp(int nargs, string commands) {
+			IntPtr native_commands = GLib.Marshaller.StringToPtrGStrdup (commands);
+			IntPtr raw_ret = ges_command_line_formatter_get_help(nargs, native_commands);
+			string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
+			GLib.Marshaller.Free (native_commands);
+			return ret;
+		}
+
+
+		static CommandLineFormatter ()
+		{
+			GtkSharp.GstEditingServices.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("priv"
+							, GES.Formatter.abi_info.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // priv
+							, null
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

ges/generated/GES/Constants.cs

@@ -0,0 +1,35 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class Constants {
+
+		public const long FRAME_NUMBER_NONE = 9223372036854775807;
+		public const string META_DESCRIPTION = @"description";
+		public const string META_FORMATTER_EXTENSION = @"extension";
+		public const string META_FORMATTER_MIMETYPE = @"mimetype";
+		public const string META_FORMATTER_NAME = @"name";
+		public const string META_FORMATTER_RANK = @"rank";
+		public const string META_FORMATTER_VERSION = @"version";
+		public const string META_FORMAT_VERSION = @"format-version";
+		public const string META_MARKER_COLOR = @"marker-color";
+		public const string META_VOLUME = @"volume";
+		public const double META_VOLUME_DEFAULT = 1.000000;
+		public const string MULTI_FILE_URI_PREFIX = @"multifile://";
+		public const int PADDING = 4;
+		public const int PADDING_LARGE = 20;
+		public const uint TIMELINE_ELEMENT_NO_LAYER_PRIORITY = 4294967295;
+		public const int VERSION_MAJOR = 1;
+		public const int VERSION_MICRO = 0;
+		public const int VERSION_MINOR = 19;
+		public const int VERSION_NANO = 1;
+#endregion
+	}
+}

ges/generated/GES/Container.cs

@@ -0,0 +1,679 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class Container : GES.TimelineElement {
+
+		protected Container (IntPtr raw) : base(raw) {}
+
+		protected Container() : base(IntPtr.Zero)
+		{
+			CreateNativeObject (new string [0], new GLib.Value [0]);
+		}
+
+		[GLib.Property ("height")]
+		public uint Height {
+			get {
+				GLib.Value val = GetProperty ("height");
+				uint ret = (uint) val;
+				val.Dispose ();
+				return ret;
+			}
+		}
+
+		public GLib.List Children {
+			get {
+				unsafe {
+					IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("children"));
+					return new GLib.List((*raw_ptr));
+				}
+			}
+		}
+
+		public uint HeightField {
+			get {
+				unsafe {
+					uint* raw_ptr = (uint*)(((byte*)Handle) + abi_info.GetFieldOffset("height"));
+					return (*raw_ptr);
+				}
+			}
+		}
+
+		public GES.ChildrenControlMode ChildrenControlMode {
+			get {
+				unsafe {
+					int* raw_ptr = (int*)(((byte*)Handle) + abi_info.GetFieldOffset("children_control_mode"));
+					return (GES.ChildrenControlMode) (*raw_ptr);
+				}
+			}
+		}
+
+		public GES.TimelineElement InitiatedMove {
+			get {
+				unsafe {
+					IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("initiated_move"));
+					return GLib.Object.GetObject((*raw_ptr)) as GES.TimelineElement;
+				}
+			}
+		}
+
+		[GLib.Signal("child-added")]
+		public event GES.ChildAddedHandler ChildAdded {
+			add {
+				this.AddSignalHandler ("child-added", value, typeof (GES.ChildAddedArgs));
+			}
+			remove {
+				this.RemoveSignalHandler ("child-added", value);
+			}
+		}
+
+		[GLib.Signal("child-removed")]
+		public event GES.ChildRemovedHandler ChildRemoved {
+			add {
+				this.AddSignalHandler ("child-removed", value, typeof (GES.ChildRemovedArgs));
+			}
+			remove {
+				this.RemoveSignalHandler ("child-removed", value);
+			}
+		}
+
+		static ChildAddedNativeDelegate ChildAdded_cb_delegate;
+		static ChildAddedNativeDelegate ChildAddedVMCallback {
+			get {
+				if (ChildAdded_cb_delegate == null)
+					ChildAdded_cb_delegate = new ChildAddedNativeDelegate (ChildAdded_cb);
+				return ChildAdded_cb_delegate;
+			}
+		}
+
+		static void OverrideChildAdded (GLib.GType gtype)
+		{
+			OverrideChildAdded (gtype, ChildAddedVMCallback);
+		}
+
+		static void OverrideChildAdded (GLib.GType gtype, ChildAddedNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("child_added"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void ChildAddedNativeDelegate (IntPtr inst, IntPtr element);
+
+		static void ChildAdded_cb (IntPtr inst, IntPtr element)
+		{
+			try {
+				Container __obj = GLib.Object.GetObject (inst, false) as Container;
+				__obj.OnChildAdded (GLib.Object.GetObject(element) as GES.TimelineElement);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(GES.Container), ConnectionMethod="OverrideChildAdded")]
+		protected virtual void OnChildAdded (GES.TimelineElement element)
+		{
+			InternalChildAdded (element);
+		}
+
+		private void InternalChildAdded (GES.TimelineElement element)
+		{
+			ChildAddedNativeDelegate unmanaged = null;
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("child_added"));
+				unmanaged = (ChildAddedNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(ChildAddedNativeDelegate));
+			}
+			if (unmanaged == null) return;
+
+			unmanaged (this.Handle, element == null ? IntPtr.Zero : element.Handle);
+		}
+
+		static ChildRemovedNativeDelegate ChildRemoved_cb_delegate;
+		static ChildRemovedNativeDelegate ChildRemovedVMCallback {
+			get {
+				if (ChildRemoved_cb_delegate == null)
+					ChildRemoved_cb_delegate = new ChildRemovedNativeDelegate (ChildRemoved_cb);
+				return ChildRemoved_cb_delegate;
+			}
+		}
+
+		static void OverrideChildRemoved (GLib.GType gtype)
+		{
+			OverrideChildRemoved (gtype, ChildRemovedVMCallback);
+		}
+
+		static void OverrideChildRemoved (GLib.GType gtype, ChildRemovedNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("child_removed"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void ChildRemovedNativeDelegate (IntPtr inst, IntPtr element);
+
+		static void ChildRemoved_cb (IntPtr inst, IntPtr element)
+		{
+			try {
+				Container __obj = GLib.Object.GetObject (inst, false) as Container;
+				__obj.OnChildRemoved (GLib.Object.GetObject(element) as GES.TimelineElement);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(GES.Container), ConnectionMethod="OverrideChildRemoved")]
+		protected virtual void OnChildRemoved (GES.TimelineElement element)
+		{
+			InternalChildRemoved (element);
+		}
+
+		private void InternalChildRemoved (GES.TimelineElement element)
+		{
+			ChildRemovedNativeDelegate unmanaged = null;
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("child_removed"));
+				unmanaged = (ChildRemovedNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(ChildRemovedNativeDelegate));
+			}
+			if (unmanaged == null) return;
+
+			unmanaged (this.Handle, element == null ? IntPtr.Zero : element.Handle);
+		}
+
+		static AddChildNativeDelegate AddChild_cb_delegate;
+		static AddChildNativeDelegate AddChildVMCallback {
+			get {
+				if (AddChild_cb_delegate == null)
+					AddChild_cb_delegate = new AddChildNativeDelegate (AddChild_cb);
+				return AddChild_cb_delegate;
+			}
+		}
+
+		static void OverrideAddChild (GLib.GType gtype)
+		{
+			OverrideAddChild (gtype, AddChildVMCallback);
+		}
+
+		static void OverrideAddChild (GLib.GType gtype, AddChildNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("add_child"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool AddChildNativeDelegate (IntPtr inst, IntPtr element);
+
+		static bool AddChild_cb (IntPtr inst, IntPtr element)
+		{
+			try {
+				Container __obj = GLib.Object.GetObject (inst, false) as Container;
+				bool __result;
+				__result = __obj.OnAddChild (GLib.Object.GetObject(element) as GES.TimelineElement);
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw e;
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(GES.Container), ConnectionMethod="OverrideAddChild")]
+		protected virtual bool OnAddChild (GES.TimelineElement element)
+		{
+			return InternalAddChild (element);
+		}
+
+		private bool InternalAddChild (GES.TimelineElement element)
+		{
+			AddChildNativeDelegate unmanaged = null;
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("add_child"));
+				unmanaged = (AddChildNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(AddChildNativeDelegate));
+			}
+			if (unmanaged == null) return false;
+
+			bool __result = unmanaged (this.Handle, element == null ? IntPtr.Zero : element.Handle);
+			return __result;
+		}
+
+		static RemoveChildNativeDelegate RemoveChild_cb_delegate;
+		static RemoveChildNativeDelegate RemoveChildVMCallback {
+			get {
+				if (RemoveChild_cb_delegate == null)
+					RemoveChild_cb_delegate = new RemoveChildNativeDelegate (RemoveChild_cb);
+				return RemoveChild_cb_delegate;
+			}
+		}
+
+		static void OverrideRemoveChild (GLib.GType gtype)
+		{
+			OverrideRemoveChild (gtype, RemoveChildVMCallback);
+		}
+
+		static void OverrideRemoveChild (GLib.GType gtype, RemoveChildNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("remove_child"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool RemoveChildNativeDelegate (IntPtr inst, IntPtr element);
+
+		static bool RemoveChild_cb (IntPtr inst, IntPtr element)
+		{
+			try {
+				Container __obj = GLib.Object.GetObject (inst, false) as Container;
+				bool __result;
+				__result = __obj.OnRemoveChild (GLib.Object.GetObject(element) as GES.TimelineElement);
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw e;
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(GES.Container), ConnectionMethod="OverrideRemoveChild")]
+		protected virtual bool OnRemoveChild (GES.TimelineElement element)
+		{
+			return InternalRemoveChild (element);
+		}
+
+		private bool InternalRemoveChild (GES.TimelineElement element)
+		{
+			RemoveChildNativeDelegate unmanaged = null;
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("remove_child"));
+				unmanaged = (RemoveChildNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(RemoveChildNativeDelegate));
+			}
+			if (unmanaged == null) return false;
+
+			bool __result = unmanaged (this.Handle, element == null ? IntPtr.Zero : element.Handle);
+			return __result;
+		}
+
+		static UngroupNativeDelegate Ungroup_cb_delegate;
+		static UngroupNativeDelegate UngroupVMCallback {
+			get {
+				if (Ungroup_cb_delegate == null)
+					Ungroup_cb_delegate = new UngroupNativeDelegate (Ungroup_cb);
+				return Ungroup_cb_delegate;
+			}
+		}
+
+		static void OverrideUngroup (GLib.GType gtype)
+		{
+			OverrideUngroup (gtype, UngroupVMCallback);
+		}
+
+		static void OverrideUngroup (GLib.GType gtype, UngroupNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("ungroup"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr UngroupNativeDelegate (IntPtr inst, bool recursive);
+
+		static IntPtr Ungroup_cb (IntPtr inst, bool recursive)
+		{
+			try {
+				Container __obj = GLib.Object.GetObject (inst, false) as Container;
+				GES.Container[] __result;
+				__result = __obj.OnUngroup (recursive);
+				return new GLib.List(__result, typeof (GES.Container), true, true) == null ? IntPtr.Zero : new GLib.List(__result, typeof (GES.Container), true, true).Handle;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw e;
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(GES.Container), ConnectionMethod="OverrideUngroup")]
+		protected virtual GES.Container[] OnUngroup (bool recursive)
+		{
+			return InternalUngroup (recursive);
+		}
+
+		private GES.Container[] InternalUngroup (bool recursive)
+		{
+			UngroupNativeDelegate unmanaged = null;
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("ungroup"));
+				unmanaged = (UngroupNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(UngroupNativeDelegate));
+			}
+			if (unmanaged == null) return null;
+
+			IntPtr __result = unmanaged (this.Handle, recursive);
+			return (GES.Container[]) GLib.Marshaller.ListPtrToArray (__result, typeof(GLib.List), true, true, typeof(GES.Container));
+		}
+
+		static EditNativeDelegate Edit_cb_delegate;
+		static EditNativeDelegate EditVMCallback {
+			get {
+				if (Edit_cb_delegate == null)
+					Edit_cb_delegate = new EditNativeDelegate (Edit_cb);
+				return Edit_cb_delegate;
+			}
+		}
+
+		static void OverrideEdit (GLib.GType gtype)
+		{
+			OverrideEdit (gtype, EditVMCallback);
+		}
+
+		static void OverrideEdit (GLib.GType gtype, EditNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("edit"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool EditNativeDelegate (IntPtr inst, IntPtr layers, int new_layer_priority, int mode, int edge, ulong position);
+
+		static bool Edit_cb (IntPtr inst, IntPtr layers, int new_layer_priority, int mode, int edge, ulong position)
+		{
+			try {
+				Container __obj = GLib.Object.GetObject (inst, false) as Container;
+				bool __result;
+				__result = __obj.OnEdit (new GLib.List(layers), new_layer_priority, (GES.EditMode) mode, (GES.Edge) edge, position);
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw e;
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(GES.Container), ConnectionMethod="OverrideEdit")]
+		protected virtual bool OnEdit (GLib.List layers, int new_layer_priority, GES.EditMode mode, GES.Edge edge, ulong position)
+		{
+			return InternalEdit (layers, new_layer_priority, mode, edge, position);
+		}
+
+		private bool InternalEdit (GLib.List layers, int new_layer_priority, GES.EditMode mode, GES.Edge edge, ulong position)
+		{
+			EditNativeDelegate unmanaged = null;
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("edit"));
+				unmanaged = (EditNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(EditNativeDelegate));
+			}
+			if (unmanaged == null) return false;
+
+			bool __result = unmanaged (this.Handle, layers == null ? IntPtr.Zero : layers.Handle, new_layer_priority, (int) mode, (int) edge, position);
+			return __result;
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("child_added"
+							, GES.TimelineElement.class_abi.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // child_added
+							, null
+							, "child_removed"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("child_removed"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // child_removed
+							, "child_added"
+							, "add_child"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("add_child"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // add_child
+							, "child_removed"
+							, "remove_child"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("remove_child"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // remove_child
+							, "add_child"
+							, "ungroup"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("ungroup"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // ungroup
+							, "remove_child"
+							, "group"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("group"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // group
+							, "ungroup"
+							, "edit"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("edit"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // edit
+							, "group"
+							, "grouping_priority"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("grouping_priority"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(uint)) // grouping_priority
+							, "edit"
+							, "_ges_reserved"
+							, (long) Marshal.OffsetOf(typeof(GESContainer_grouping_priorityAlign), "grouping_priority")
+							, 0
+							),
+						new GLib.AbiField("_ges_reserved"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 20 // _ges_reserved
+							, "grouping_priority"
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+		[StructLayout(LayoutKind.Sequential)]
+		public struct GESContainer_grouping_priorityAlign
+		{
+			sbyte f1;
+			private uint grouping_priority;
+		}
+
+
+		// End of the ABI representation.
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_container_get_type();
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = ges_container_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_container_group(IntPtr containers);
+
+		public static GES.Container Group(GLib.List containers) {
+			IntPtr raw_ret = ges_container_group(containers == null ? IntPtr.Zero : containers.Handle);
+			GES.Container ret = GLib.Object.GetObject(raw_ret) as GES.Container;
+			return ret;
+		}
+
+		public static GES.Container Group() {
+			return Group (null);
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_container_add(IntPtr raw, IntPtr child);
+
+		public bool Add(GES.TimelineElement child) {
+			bool raw_ret = ges_container_add(Handle, child == null ? IntPtr.Zero : child.Handle);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_container_edit(IntPtr raw, IntPtr layers, int new_layer_priority, int mode, int edge, ulong position);
+
+		[Obsolete]
+		public bool Edit(GLib.List layers, int new_layer_priority, GES.EditMode mode, GES.Edge edge, ulong position) {
+			bool raw_ret = ges_container_edit(Handle, layers == null ? IntPtr.Zero : layers.Handle, new_layer_priority, (int) mode, (int) edge, position);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		public bool Edit(int new_layer_priority, GES.EditMode mode, GES.Edge edge, ulong position) {
+			return Edit (null, new_layer_priority, mode, edge, position);
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_container_get_children(IntPtr raw, bool recursive);
+
+		public GES.TimelineElement[] GetChildren(bool recursive) {
+			IntPtr raw_ret = ges_container_get_children(Handle, recursive);
+			GES.TimelineElement[] ret = (GES.TimelineElement[]) GLib.Marshaller.ListPtrToArray (raw_ret, typeof(GLib.List), true, true, typeof(GES.TimelineElement));
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_container_remove(IntPtr raw, IntPtr child);
+
+		public bool Remove(GES.TimelineElement child) {
+			bool raw_ret = ges_container_remove(Handle, child == null ? IntPtr.Zero : child.Handle);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_container_ungroup(IntPtr raw, bool recursive);
+
+		public GES.Container[] Ungroup(bool recursive) {
+			IntPtr raw_ret = ges_container_ungroup(Handle, recursive);
+			GES.Container[] ret = (GES.Container[]) GLib.Marshaller.ListPtrToArray (raw_ret, typeof(GLib.List), true, true, typeof(GES.Container));
+			return ret;
+		}
+
+
+		static Container ()
+		{
+			GtkSharp.GstEditingServices.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("children"
+							, GES.TimelineElement.abi_info.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // children
+							, null
+							, "height"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("height"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(uint)) // height
+							, "children"
+							, "children_control_mode"
+							, (long) Marshal.OffsetOf(typeof(GESContainer_heightAlign), "height")
+							, 0
+							),
+						new GLib.AbiField("children_control_mode"
+							, -1
+							, (uint) Marshal.SizeOf(System.Enum.GetUnderlyingType(typeof(GES.ChildrenControlMode))) // children_control_mode
+							, "height"
+							, "initiated_move"
+							, (long) Marshal.OffsetOf(typeof(GESContainer_children_control_modeAlign), "children_control_mode")
+							, 0
+							),
+						new GLib.AbiField("initiated_move"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // initiated_move
+							, "children_control_mode"
+							, "priv"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("priv"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // priv
+							, "initiated_move"
+							, "_ges_reserved"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("_ges_reserved"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 20 // _ges_reserved
+							, "priv"
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+		[StructLayout(LayoutKind.Sequential)]
+		public struct GESContainer_heightAlign
+		{
+			sbyte f1;
+			private uint height;
+		}
+
+		[StructLayout(LayoutKind.Sequential)]
+		public struct GESContainer_children_control_modeAlign
+		{
+			sbyte f1;
+			private GES.ChildrenControlMode children_control_mode;
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

ges/generated/GES/ControlBindingAddedHandler.cs

@@ -0,0 +1,18 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+
+	public delegate void ControlBindingAddedHandler(object o, ControlBindingAddedArgs args);
+
+	public class ControlBindingAddedArgs : GLib.SignalArgs {
+		public Gst.ControlBinding ControlBinding{
+			get {
+				return (Gst.ControlBinding) Args [0];
+			}
+		}
+
+	}
+}

ges/generated/GES/ControlBindingRemovedHandler.cs

@@ -0,0 +1,18 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+
+	public delegate void ControlBindingRemovedHandler(object o, ControlBindingRemovedArgs args);
+
+	public class ControlBindingRemovedArgs : GLib.SignalArgs {
+		public Gst.ControlBinding ControlBinding{
+			get {
+				return (Gst.ControlBinding) Args [0];
+			}
+		}
+
+	}
+}

ges/generated/GES/CreateElementForGapFunc.cs

@@ -0,0 +1,10 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+
+	public delegate Gst.Element CreateElementForGapFunc(GES.Track track);
+
+}

ges/generated/GES/CreateTrackElementFunc.cs

@@ -0,0 +1,10 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+
+	public delegate GES.TrackElement CreateTrackElementFunc(GES.Clip clip, GES.TrackType type);
+
+}

ges/generated/GES/CreateTrackElementsFunc.cs

@@ -0,0 +1,10 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+
+	public delegate GES.TrackElement[] CreateTrackElementsFunc(GES.Clip clip, GES.TrackType type);
+
+}

ges/generated/GES/DeepNotifyHandler.cs

@@ -0,0 +1,24 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+
+	public delegate void DeepNotifyHandler(object o, DeepNotifyArgs args);
+
+	public class DeepNotifyArgs : GLib.SignalArgs {
+		public GLib.Object PropObject{
+			get {
+				return (GLib.Object) Args [0];
+			}
+		}
+
+		public IntPtr Prop{
+			get {
+				return (IntPtr) Args [1];
+			}
+		}
+
+	}
+}

ges/generated/GES/Edge.cs

@@ -0,0 +1,32 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[GLib.GType (typeof (GES.EdgeGType))]
+	public enum Edge {
+
+		EdgeStart = 0,
+		Start = 0,
+		EdgeEnd = 1,
+		End = 1,
+		EdgeNone = 2,
+		None = 2,
+	}
+
+	internal class EdgeGType {
+		[DllImport ("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_edge_get_type ();
+
+		public static GLib.GType GType {
+			get {
+				return new GLib.GType (ges_edge_get_type ());
+			}
+		}
+	}
+#endregion
+}

ges/generated/GES/EditMode.cs

@@ -0,0 +1,36 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[GLib.GType (typeof (GES.EditModeGType))]
+	public enum EditMode {
+
+		EditNormal = 0,
+		Normal = 0,
+		EditRipple = 1,
+		Ripple = 1,
+		EditRoll = 2,
+		Roll = 2,
+		EditTrim = 3,
+		Trim = 3,
+		EditSlide = 4,
+		Slide = 4,
+	}
+
+	internal class EditModeGType {
+		[DllImport ("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_edit_mode_get_type ();
+
+		public static GLib.GType GType {
+			get {
+				return new GLib.GType (ges_edit_mode_get_type ());
+			}
+		}
+	}
+#endregion
+}

ges/generated/GES/Effect.cs

@@ -0,0 +1,139 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class Effect : GES.BaseEffect {
+
+		public Effect (IntPtr raw) : base(raw) {}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_effect_new(IntPtr bin_description);
+
+		public Effect (string bin_description) : base (IntPtr.Zero)
+		{
+			if (GetType () != typeof (Effect)) {
+				var vals = new List<GLib.Value> ();
+				var names = new List<string> ();
+				names.Add ("bin_description");
+				vals.Add (new GLib.Value (bin_description));
+				CreateNativeObject (names.ToArray (), vals.ToArray ());
+				return;
+			}
+			IntPtr native_bin_description = GLib.Marshaller.StringToPtrGStrdup (bin_description);
+			Raw = ges_effect_new(native_bin_description);
+			GLib.Marshaller.Free (native_bin_description);
+		}
+
+		[GLib.Property ("bin-description")]
+		public string BinDescription {
+			get {
+				GLib.Value val = GetProperty ("bin-description");
+				string ret = (string) val;
+				val.Dispose ();
+				return ret;
+			}
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("rate_properties"
+							, GES.BaseEffect.class_abi.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // rate_properties
+							, null
+							, "_ges_reserved"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("_ges_reserved"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _ges_reserved
+							, "rate_properties"
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_effect_class_register_rate_property(IntPtr element_name, IntPtr property_name);
+
+		public static bool RegisterRateProperty(string element_name, string property_name) {
+			IntPtr native_element_name = GLib.Marshaller.StringToPtrGStrdup (element_name);
+			IntPtr native_property_name = GLib.Marshaller.StringToPtrGStrdup (property_name);
+			bool raw_ret = ges_effect_class_register_rate_property(native_element_name, native_property_name);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_element_name);
+			GLib.Marshaller.Free (native_property_name);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_effect_get_type();
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = ges_effect_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+
+		static Effect ()
+		{
+			GtkSharp.GstEditingServices.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("priv"
+							, GES.BaseEffect.abi_info.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // priv
+							, null
+							, "_ges_reserved"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("_ges_reserved"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _ges_reserved
+							, "priv"
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

ges/generated/GES/EffectAsset.cs

@@ -0,0 +1,39 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class EffectAsset : GES.TrackElementAsset {
+
+		public EffectAsset (IntPtr raw) : base(raw) {}
+
+		protected EffectAsset() : base(IntPtr.Zero)
+		{
+			CreateNativeObject (new string [0], new GLib.Value [0]);
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_effect_asset_get_type();
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = ges_effect_asset_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+
+		static EffectAsset ()
+		{
+			GtkSharp.GstEditingServices.ObjectManager.Initialize ();
+		}
+#endregion
+	}
+}

ges/generated/GES/EffectClip.cs

@@ -0,0 +1,132 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class EffectClip : GES.BaseEffectClip {
+
+		public EffectClip (IntPtr raw) : base(raw) {}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_effect_clip_new(IntPtr video_bin_description, IntPtr audio_bin_description);
+
+		public EffectClip (string video_bin_description, string audio_bin_description) : base (IntPtr.Zero)
+		{
+			if (GetType () != typeof (EffectClip)) {
+				var vals = new List<GLib.Value> ();
+				var names = new List<string> ();
+				names.Add ("video_bin_description");
+				vals.Add (new GLib.Value (video_bin_description));
+				names.Add ("audio_bin_description");
+				vals.Add (new GLib.Value (audio_bin_description));
+				CreateNativeObject (names.ToArray (), vals.ToArray ());
+				return;
+			}
+			IntPtr native_video_bin_description = GLib.Marshaller.StringToPtrGStrdup (video_bin_description);
+			IntPtr native_audio_bin_description = GLib.Marshaller.StringToPtrGStrdup (audio_bin_description);
+			Raw = ges_effect_clip_new(native_video_bin_description, native_audio_bin_description);
+			GLib.Marshaller.Free (native_video_bin_description);
+			GLib.Marshaller.Free (native_audio_bin_description);
+		}
+
+		[GLib.Property ("audio-bin-description")]
+		public string AudioBinDescription {
+			get {
+				GLib.Value val = GetProperty ("audio-bin-description");
+				string ret = (string) val;
+				val.Dispose ();
+				return ret;
+			}
+		}
+
+		[GLib.Property ("video-bin-description")]
+		public string VideoBinDescription {
+			get {
+				GLib.Value val = GetProperty ("video-bin-description");
+				string ret = (string) val;
+				val.Dispose ();
+				return ret;
+			}
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("_ges_reserved"
+							, GES.BaseEffectClip.class_abi.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _ges_reserved
+							, null
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_effect_clip_get_type();
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = ges_effect_clip_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+
+		static EffectClip ()
+		{
+			GtkSharp.GstEditingServices.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("priv"
+							, GES.BaseEffectClip.abi_info.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // priv
+							, null
+							, "_ges_reserved"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("_ges_reserved"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _ges_reserved
+							, "priv"
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

ges/generated/GES/Error.cs

@@ -0,0 +1,23 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public enum Error {
+
+		AssetWrongId = 0,
+		AssetLoading = 1,
+		FormatterMalformedInputFile = 2,
+		InvalidFrameNumber = 3,
+		NegativeLayer = 4,
+		NegativeTime = 5,
+		NotEnoughInternalContent = 6,
+		InvalidOverlapInTrack = 7,
+		InvalidEffectBinDescription = 8,
+	}
+#endregion
+}

ges/generated/GES/ExtractableAdapter.cs

@@ -0,0 +1,191 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class ExtractableAdapter : GLib.GInterfaceAdapter, GES.IExtractable {
+
+		[StructLayout (LayoutKind.Sequential)]
+		struct GESExtractableInterface {
+			public GLib.GType AssetType;
+			private GESSharp.ExtractableCheckIdNative _check_id;
+			public GES.ExtractableCheckId CheckId {
+				get {
+					return GESSharp.ExtractableCheckIdWrapper.GetManagedDelegate (_check_id);
+				}
+			}
+			public bool CanUpdateAsset;
+			public SetAssetNativeDelegate SetAsset;
+			IntPtr SetAssetFull;
+			IntPtr GetParametersFromId;
+			public GetIdNativeDelegate GetId;
+			IntPtr GetRealExtractableType;
+			IntPtr RegisterMetas;
+			[MarshalAs (UnmanagedType.ByValArray, SizeConst=4)]
+			public IntPtr[] _gesGesReserved;
+		}
+
+		static GESExtractableInterface iface;
+
+		static ExtractableAdapter ()
+		{
+			GLib.GType.Register (_gtype, typeof (ExtractableAdapter));
+			iface.SetAsset = new SetAssetNativeDelegate (SetAsset_cb);
+			iface.GetId = new GetIdNativeDelegate (GetId_cb);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void SetAssetNativeDelegate (IntPtr inst, IntPtr asset);
+
+		static void SetAsset_cb (IntPtr inst, IntPtr asset)
+		{
+			try {
+				IExtractableImplementor __obj = GLib.Object.GetObject (inst, false) as IExtractableImplementor;
+				__obj.Asset = GLib.Object.GetObject(asset) as GES.Asset;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetIdNativeDelegate (IntPtr inst);
+
+		static IntPtr GetId_cb (IntPtr inst)
+		{
+			try {
+				IExtractableImplementor __obj = GLib.Object.GetObject (inst, false) as IExtractableImplementor;
+				string __result;
+				__result = __obj.Id;
+				return GLib.Marshaller.StringToPtrGStrdup(__result);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw e;
+			}
+		}
+
+		static int class_offset = 2 * IntPtr.Size;
+
+		static void Initialize (IntPtr ptr, IntPtr data)
+		{
+			IntPtr ifaceptr = new IntPtr (ptr.ToInt64 () + class_offset);
+			GESExtractableInterface native_iface = (GESExtractableInterface) Marshal.PtrToStructure (ifaceptr, typeof (GESExtractableInterface));
+			native_iface.SetAsset = iface.SetAsset;
+			native_iface.GetId = iface.GetId;
+			Marshal.StructureToPtr (native_iface, ifaceptr, false);
+		}
+
+		GLib.Object implementor;
+
+		public ExtractableAdapter ()
+		{
+			InitHandler = new GLib.GInterfaceInitHandler (Initialize);
+		}
+
+		public ExtractableAdapter (IExtractableImplementor implementor)
+		{
+			if (implementor == null)
+				throw new ArgumentNullException ("implementor");
+			else if (!(implementor is GLib.Object))
+				throw new ArgumentException ("implementor must be a subclass of GLib.Object");
+			this.implementor = implementor as GLib.Object;
+		}
+
+		public ExtractableAdapter (IntPtr handle)
+		{
+			if (!_gtype.IsInstance (handle))
+				throw new ArgumentException ("The gobject doesn't implement the GInterface of this adapter", "handle");
+			implementor = GLib.Object.GetObject (handle);
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_extractable_get_type();
+
+		private static GLib.GType _gtype = new GLib.GType (ges_extractable_get_type ());
+
+		public static GLib.GType GType {
+			get {
+				return _gtype;
+			}
+		}
+
+		public override GLib.GType GInterfaceGType {
+			get {
+				return _gtype;
+			}
+		}
+
+		public override IntPtr Handle {
+			get {
+				return implementor.Handle;
+			}
+		}
+
+		public IntPtr OwnedHandle {
+			get {
+				return implementor.OwnedHandle;
+			}
+		}
+
+		public static IExtractable GetObject (IntPtr handle, bool owned)
+		{
+			GLib.Object obj = GLib.Object.GetObject (handle, owned);
+			return GetObject (obj);
+		}
+
+		public static IExtractable GetObject (GLib.Object obj)
+		{
+			if (obj == null)
+				return null;
+			else if (obj is IExtractableImplementor)
+				return new ExtractableAdapter (obj as IExtractableImplementor);
+			else if (obj as IExtractable == null)
+				return new ExtractableAdapter (obj.Handle);
+			else
+				return obj as IExtractable;
+		}
+
+		public IExtractableImplementor Implementor {
+			get {
+				return implementor as IExtractableImplementor;
+			}
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_extractable_get_asset(IntPtr raw);
+
+		public GES.Asset Asset { 
+			get {
+				IntPtr raw_ret = ges_extractable_get_asset(Handle);
+				GES.Asset ret = GLib.Object.GetObject(raw_ret) as GES.Asset;
+				return ret;
+			}
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_extractable_get_id(IntPtr raw);
+
+		public string Id { 
+			get {
+				IntPtr raw_ret = ges_extractable_get_id(Handle);
+				string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
+				return ret;
+			}
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_extractable_set_asset(IntPtr raw, IntPtr asset);
+
+		public bool SetAsset(GES.Asset asset) {
+			bool raw_ret = ges_extractable_set_asset(Handle, asset == null ? IntPtr.Zero : asset.Handle);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+#endregion
+	}
+}

ges/generated/GES/ExtractableCheckId.cs

@@ -0,0 +1,10 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+
+	public delegate string ExtractableCheckId(GLib.GType type, string id);
+
+}

ges/generated/GES/FillTrackElementFunc.cs

@@ -0,0 +1,10 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+
+	public delegate bool FillTrackElementFunc(GES.Clip clip, GES.TrackElement track_element, Gst.Element nleobj);
+
+}

ges/generated/GES/Formatter.cs

@@ -0,0 +1,308 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class Formatter : GLib.InitiallyUnowned, GES.IExtractable {
+
+		protected Formatter (IntPtr raw) : base(raw) {}
+
+		protected Formatter() : base(IntPtr.Zero)
+		{
+			CreateNativeObject (new string [0], new GLib.Value [0]);
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("can_load_uri"
+							, GLib.Object.class_abi.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // can_load_uri
+							, null
+							, "load_from_uri"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("load_from_uri"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // load_from_uri
+							, "can_load_uri"
+							, "save_to_uri"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("save_to_uri"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // save_to_uri
+							, "load_from_uri"
+							, "name"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("name"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // name
+							, "save_to_uri"
+							, "description"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("description"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // description
+							, "name"
+							, "extension"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("extension"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // extension
+							, "description"
+							, "mimetype"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("mimetype"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // mimetype
+							, "extension"
+							, "version"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("version"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(double)) // version
+							, "mimetype"
+							, "rank"
+							, (long) Marshal.OffsetOf(typeof(GESFormatter_versionAlign), "version")
+							, 0
+							),
+						new GLib.AbiField("rank"
+							, -1
+							, (uint) Marshal.SizeOf(System.Enum.GetUnderlyingType(typeof(Gst.Rank))) // rank
+							, "version"
+							, "_ges_reserved"
+							, (long) Marshal.OffsetOf(typeof(GESFormatter_rankAlign), "rank")
+							, 0
+							),
+						new GLib.AbiField("_ges_reserved"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _ges_reserved
+							, "rank"
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+		[StructLayout(LayoutKind.Sequential)]
+		public struct GESFormatter_versionAlign
+		{
+			sbyte f1;
+			private double version;
+		}
+
+		[StructLayout(LayoutKind.Sequential)]
+		public struct GESFormatter_rankAlign
+		{
+			sbyte f1;
+			private Gst.Rank rank;
+		}
+
+
+		// End of the ABI representation.
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern void ges_formatter_class_register_metas(IntPtr name, IntPtr description, IntPtr extensions, IntPtr caps, double version, int rank);
+
+		public static void RegisterMetas(string name, string description, string extensions, string caps, double version, Gst.Rank rank) {
+			IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
+			IntPtr native_description = GLib.Marshaller.StringToPtrGStrdup (description);
+			IntPtr native_extensions = GLib.Marshaller.StringToPtrGStrdup (extensions);
+			IntPtr native_caps = GLib.Marshaller.StringToPtrGStrdup (caps);
+			ges_formatter_class_register_metas(native_name, native_description, native_extensions, native_caps, version, (int) rank);
+			GLib.Marshaller.Free (native_name);
+			GLib.Marshaller.Free (native_description);
+			GLib.Marshaller.Free (native_extensions);
+			GLib.Marshaller.Free (native_caps);
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_formatter_get_type();
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = ges_formatter_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern unsafe bool ges_formatter_can_load_uri(IntPtr uri, out IntPtr error);
+
+		public static unsafe bool CanLoadUri(string uri) {
+			IntPtr native_uri = GLib.Marshaller.StringToPtrGStrdup (uri);
+			IntPtr error = IntPtr.Zero;
+			bool raw_ret = ges_formatter_can_load_uri(native_uri, out error);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_uri);
+			if (error != IntPtr.Zero) throw new GLib.GException (error);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern unsafe bool ges_formatter_can_save_uri(IntPtr uri, out IntPtr error);
+
+		public static unsafe bool CanSaveUri(string uri) {
+			IntPtr native_uri = GLib.Marshaller.StringToPtrGStrdup (uri);
+			IntPtr error = IntPtr.Zero;
+			bool raw_ret = ges_formatter_can_save_uri(native_uri, out error);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_uri);
+			if (error != IntPtr.Zero) throw new GLib.GException (error);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_formatter_get_default();
+
+		public static GES.Asset Default { 
+			get {
+				IntPtr raw_ret = ges_formatter_get_default();
+				GES.Asset ret = GLib.Object.GetObject(raw_ret) as GES.Asset;
+				return ret;
+			}
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern unsafe bool ges_formatter_load_from_uri(IntPtr raw, IntPtr timeline, IntPtr uri, out IntPtr error);
+
+		[Obsolete]
+		public unsafe bool LoadFromUri(GES.Timeline timeline, string uri) {
+			IntPtr native_uri = GLib.Marshaller.StringToPtrGStrdup (uri);
+			IntPtr error = IntPtr.Zero;
+			bool raw_ret = ges_formatter_load_from_uri(Handle, timeline == null ? IntPtr.Zero : timeline.Handle, native_uri, out error);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_uri);
+			if (error != IntPtr.Zero) throw new GLib.GException (error);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern unsafe bool ges_formatter_save_to_uri(IntPtr raw, IntPtr timeline, IntPtr uri, bool overwrite, out IntPtr error);
+
+		[Obsolete]
+		public unsafe bool SaveToUri(GES.Timeline timeline, string uri, bool overwrite) {
+			IntPtr native_uri = GLib.Marshaller.StringToPtrGStrdup (uri);
+			IntPtr error = IntPtr.Zero;
+			bool raw_ret = ges_formatter_save_to_uri(Handle, timeline == null ? IntPtr.Zero : timeline.Handle, native_uri, overwrite, out error);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_uri);
+			if (error != IntPtr.Zero) throw new GLib.GException (error);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_extractable_get_asset(IntPtr raw);
+
+		public GES.Asset Asset { 
+			get {
+				IntPtr raw_ret = ges_extractable_get_asset(Handle);
+				GES.Asset ret = GLib.Object.GetObject(raw_ret) as GES.Asset;
+				return ret;
+			}
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_extractable_get_id(IntPtr raw);
+
+		public string Id { 
+			get {
+				IntPtr raw_ret = ges_extractable_get_id(Handle);
+				string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
+				return ret;
+			}
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_extractable_set_asset(IntPtr raw, IntPtr asset);
+
+		public bool SetAsset(GES.Asset asset) {
+			bool raw_ret = ges_extractable_set_asset(Handle, asset == null ? IntPtr.Zero : asset.Handle);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+
+		static Formatter ()
+		{
+			GtkSharp.GstEditingServices.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("priv"
+							, GLib.Object.abi_info.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // priv
+							, null
+							, "project"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("project"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // project
+							, "priv"
+							, "timeline"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("timeline"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // timeline
+							, "project"
+							, "_ges_reserved"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("_ges_reserved"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _ges_reserved
+							, "timeline"
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

ges/generated/GES/FormatterCanLoadURIMethod.cs

@@ -0,0 +1,10 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+
+	public delegate bool FormatterCanLoadURIMethod(GES.Formatter dummy_instance, string uri);
+
+}

ges/generated/GES/FormatterLoadFromURIMethod.cs

@@ -0,0 +1,10 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+
+	public delegate bool FormatterLoadFromURIMethod(GES.Formatter formatter, GES.Timeline timeline, string uri);
+
+}

ges/generated/GES/FormatterSaveToURIMethod.cs

@@ -0,0 +1,10 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+
+	public delegate bool FormatterSaveToURIMethod(GES.Formatter formatter, GES.Timeline timeline, string uri, bool overwrite);
+
+}

ges/generated/GES/GESSharp.BaseEffectTimeTranslationFuncNative.cs

@@ -0,0 +1,96 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GESSharp {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+	internal delegate ulong BaseEffectTimeTranslationFuncNative(IntPtr effect, ulong time, System.IntPtr time_property_values, IntPtr user_data);
+
+	internal class BaseEffectTimeTranslationFuncInvoker {
+
+		BaseEffectTimeTranslationFuncNative native_cb;
+		IntPtr __data;
+		GLib.DestroyNotify __notify;
+
+		~BaseEffectTimeTranslationFuncInvoker ()
+		{
+			if (__notify == null)
+				return;
+			__notify (__data);
+		}
+
+		internal BaseEffectTimeTranslationFuncInvoker (BaseEffectTimeTranslationFuncNative native_cb) : this (native_cb, IntPtr.Zero, null) {}
+
+		internal BaseEffectTimeTranslationFuncInvoker (BaseEffectTimeTranslationFuncNative native_cb, IntPtr data) : this (native_cb, data, null) {}
+
+		internal BaseEffectTimeTranslationFuncInvoker (BaseEffectTimeTranslationFuncNative native_cb, IntPtr data, GLib.DestroyNotify notify)
+		{
+			this.native_cb = native_cb;
+			__data = data;
+			__notify = notify;
+		}
+
+		internal GES.BaseEffectTimeTranslationFunc Handler {
+			get {
+				return new GES.BaseEffectTimeTranslationFunc(InvokeNative);
+			}
+		}
+
+		ulong InvokeNative (GES.BaseEffect effect, ulong time, System.IntPtr time_property_values)
+		{
+			ulong __result = native_cb (effect == null ? IntPtr.Zero : effect.Handle, time, time_property_values, __data);
+			return __result;
+		}
+	}
+
+	internal class BaseEffectTimeTranslationFuncWrapper {
+
+		public ulong NativeCallback (IntPtr effect, ulong time, System.IntPtr time_property_values, IntPtr user_data)
+		{
+			try {
+				ulong __ret = managed (GLib.Object.GetObject(effect) as GES.BaseEffect, time, time_property_values);
+				if (release_on_call)
+					gch.Free ();
+				return __ret;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: Above call does not return.
+				throw e;
+			}
+		}
+
+		bool release_on_call = false;
+		GCHandle gch;
+
+		public void PersistUntilCalled ()
+		{
+			release_on_call = true;
+			gch = GCHandle.Alloc (this);
+		}
+
+		internal BaseEffectTimeTranslationFuncNative NativeDelegate;
+		GES.BaseEffectTimeTranslationFunc managed;
+
+		public BaseEffectTimeTranslationFuncWrapper (GES.BaseEffectTimeTranslationFunc managed)
+		{
+			this.managed = managed;
+			if (managed != null)
+				NativeDelegate = new BaseEffectTimeTranslationFuncNative (NativeCallback);
+		}
+
+		public static GES.BaseEffectTimeTranslationFunc GetManagedDelegate (BaseEffectTimeTranslationFuncNative native)
+		{
+			if (native == null)
+				return null;
+			BaseEffectTimeTranslationFuncWrapper wrapper = (BaseEffectTimeTranslationFuncWrapper) native.Target;
+			if (wrapper == null)
+				return null;
+			return wrapper.managed;
+		}
+	}
+#endregion
+}

ges/generated/GES/GESSharp.CreateElementForGapFuncNative.cs

@@ -0,0 +1,96 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GESSharp {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+	internal delegate IntPtr CreateElementForGapFuncNative(IntPtr track);
+
+	internal class CreateElementForGapFuncInvoker {
+
+		CreateElementForGapFuncNative native_cb;
+		IntPtr __data;
+		GLib.DestroyNotify __notify;
+
+		~CreateElementForGapFuncInvoker ()
+		{
+			if (__notify == null)
+				return;
+			__notify (__data);
+		}
+
+		internal CreateElementForGapFuncInvoker (CreateElementForGapFuncNative native_cb) : this (native_cb, IntPtr.Zero, null) {}
+
+		internal CreateElementForGapFuncInvoker (CreateElementForGapFuncNative native_cb, IntPtr data) : this (native_cb, data, null) {}
+
+		internal CreateElementForGapFuncInvoker (CreateElementForGapFuncNative native_cb, IntPtr data, GLib.DestroyNotify notify)
+		{
+			this.native_cb = native_cb;
+			__data = data;
+			__notify = notify;
+		}
+
+		internal GES.CreateElementForGapFunc Handler {
+			get {
+				return new GES.CreateElementForGapFunc(InvokeNative);
+			}
+		}
+
+		Gst.Element InvokeNative (GES.Track track)
+		{
+			Gst.Element __result = GLib.Object.GetObject(native_cb (track == null ? IntPtr.Zero : track.Handle)) as Gst.Element;
+			return __result;
+		}
+	}
+
+	internal class CreateElementForGapFuncWrapper {
+
+		public IntPtr NativeCallback (IntPtr track)
+		{
+			try {
+				Gst.Element __ret = managed (GLib.Object.GetObject(track) as GES.Track);
+				if (release_on_call)
+					gch.Free ();
+				return __ret == null ? IntPtr.Zero : __ret.Handle;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: Above call does not return.
+				throw e;
+			}
+		}
+
+		bool release_on_call = false;
+		GCHandle gch;
+
+		public void PersistUntilCalled ()
+		{
+			release_on_call = true;
+			gch = GCHandle.Alloc (this);
+		}
+
+		internal CreateElementForGapFuncNative NativeDelegate;
+		GES.CreateElementForGapFunc managed;
+
+		public CreateElementForGapFuncWrapper (GES.CreateElementForGapFunc managed)
+		{
+			this.managed = managed;
+			if (managed != null)
+				NativeDelegate = new CreateElementForGapFuncNative (NativeCallback);
+		}
+
+		public static GES.CreateElementForGapFunc GetManagedDelegate (CreateElementForGapFuncNative native)
+		{
+			if (native == null)
+				return null;
+			CreateElementForGapFuncWrapper wrapper = (CreateElementForGapFuncWrapper) native.Target;
+			if (wrapper == null)
+				return null;
+			return wrapper.managed;
+		}
+	}
+#endregion
+}

ges/generated/GES/GESSharp.CreateTrackElementFuncNative.cs

@@ -0,0 +1,96 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GESSharp {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+	internal delegate IntPtr CreateTrackElementFuncNative(IntPtr clip, int type);
+
+	internal class CreateTrackElementFuncInvoker {
+
+		CreateTrackElementFuncNative native_cb;
+		IntPtr __data;
+		GLib.DestroyNotify __notify;
+
+		~CreateTrackElementFuncInvoker ()
+		{
+			if (__notify == null)
+				return;
+			__notify (__data);
+		}
+
+		internal CreateTrackElementFuncInvoker (CreateTrackElementFuncNative native_cb) : this (native_cb, IntPtr.Zero, null) {}
+
+		internal CreateTrackElementFuncInvoker (CreateTrackElementFuncNative native_cb, IntPtr data) : this (native_cb, data, null) {}
+
+		internal CreateTrackElementFuncInvoker (CreateTrackElementFuncNative native_cb, IntPtr data, GLib.DestroyNotify notify)
+		{
+			this.native_cb = native_cb;
+			__data = data;
+			__notify = notify;
+		}
+
+		internal GES.CreateTrackElementFunc Handler {
+			get {
+				return new GES.CreateTrackElementFunc(InvokeNative);
+			}
+		}
+
+		GES.TrackElement InvokeNative (GES.Clip clip, GES.TrackType type)
+		{
+			GES.TrackElement __result = GLib.Object.GetObject(native_cb (clip == null ? IntPtr.Zero : clip.Handle, (int) type)) as GES.TrackElement;
+			return __result;
+		}
+	}
+
+	internal class CreateTrackElementFuncWrapper {
+
+		public IntPtr NativeCallback (IntPtr clip, int type)
+		{
+			try {
+				GES.TrackElement __ret = managed (GLib.Object.GetObject(clip) as GES.Clip, (GES.TrackType) type);
+				if (release_on_call)
+					gch.Free ();
+				return __ret == null ? IntPtr.Zero : __ret.Handle;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: Above call does not return.
+				throw e;
+			}
+		}
+
+		bool release_on_call = false;
+		GCHandle gch;
+
+		public void PersistUntilCalled ()
+		{
+			release_on_call = true;
+			gch = GCHandle.Alloc (this);
+		}
+
+		internal CreateTrackElementFuncNative NativeDelegate;
+		GES.CreateTrackElementFunc managed;
+
+		public CreateTrackElementFuncWrapper (GES.CreateTrackElementFunc managed)
+		{
+			this.managed = managed;
+			if (managed != null)
+				NativeDelegate = new CreateTrackElementFuncNative (NativeCallback);
+		}
+
+		public static GES.CreateTrackElementFunc GetManagedDelegate (CreateTrackElementFuncNative native)
+		{
+			if (native == null)
+				return null;
+			CreateTrackElementFuncWrapper wrapper = (CreateTrackElementFuncWrapper) native.Target;
+			if (wrapper == null)
+				return null;
+			return wrapper.managed;
+		}
+	}
+#endregion
+}

ges/generated/GES/GESSharp.CreateTrackElementsFuncNative.cs

@@ -0,0 +1,96 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GESSharp {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+	internal delegate IntPtr CreateTrackElementsFuncNative(IntPtr clip, int type);
+
+	internal class CreateTrackElementsFuncInvoker {
+
+		CreateTrackElementsFuncNative native_cb;
+		IntPtr __data;
+		GLib.DestroyNotify __notify;
+
+		~CreateTrackElementsFuncInvoker ()
+		{
+			if (__notify == null)
+				return;
+			__notify (__data);
+		}
+
+		internal CreateTrackElementsFuncInvoker (CreateTrackElementsFuncNative native_cb) : this (native_cb, IntPtr.Zero, null) {}
+
+		internal CreateTrackElementsFuncInvoker (CreateTrackElementsFuncNative native_cb, IntPtr data) : this (native_cb, data, null) {}
+
+		internal CreateTrackElementsFuncInvoker (CreateTrackElementsFuncNative native_cb, IntPtr data, GLib.DestroyNotify notify)
+		{
+			this.native_cb = native_cb;
+			__data = data;
+			__notify = notify;
+		}
+
+		internal GES.CreateTrackElementsFunc Handler {
+			get {
+				return new GES.CreateTrackElementsFunc(InvokeNative);
+			}
+		}
+
+		GES.TrackElement[] InvokeNative (GES.Clip clip, GES.TrackType type)
+		{
+			GES.TrackElement[] __result = (GES.TrackElement[]) GLib.Marshaller.ListPtrToArray (native_cb (clip == null ? IntPtr.Zero : clip.Handle, (int) type), typeof(GLib.List), false, true, typeof(GES.TrackElement));
+			return __result;
+		}
+	}
+
+	internal class CreateTrackElementsFuncWrapper {
+
+		public IntPtr NativeCallback (IntPtr clip, int type)
+		{
+			try {
+				GES.TrackElement[] __ret = managed (GLib.Object.GetObject(clip) as GES.Clip, (GES.TrackType) type);
+				if (release_on_call)
+					gch.Free ();
+				return new GLib.List(__ret, typeof (GES.TrackElement), false, true) == null ? IntPtr.Zero : new GLib.List(__ret, typeof (GES.TrackElement), false, true).Handle;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: Above call does not return.
+				throw e;
+			}
+		}
+
+		bool release_on_call = false;
+		GCHandle gch;
+
+		public void PersistUntilCalled ()
+		{
+			release_on_call = true;
+			gch = GCHandle.Alloc (this);
+		}
+
+		internal CreateTrackElementsFuncNative NativeDelegate;
+		GES.CreateTrackElementsFunc managed;
+
+		public CreateTrackElementsFuncWrapper (GES.CreateTrackElementsFunc managed)
+		{
+			this.managed = managed;
+			if (managed != null)
+				NativeDelegate = new CreateTrackElementsFuncNative (NativeCallback);
+		}
+
+		public static GES.CreateTrackElementsFunc GetManagedDelegate (CreateTrackElementsFuncNative native)
+		{
+			if (native == null)
+				return null;
+			CreateTrackElementsFuncWrapper wrapper = (CreateTrackElementsFuncWrapper) native.Target;
+			if (wrapper == null)
+				return null;
+			return wrapper.managed;
+		}
+	}
+#endregion
+}

ges/generated/GES/GESSharp.ExtractableCheckIdNative.cs

@@ -0,0 +1,101 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GESSharp {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+	internal delegate IntPtr ExtractableCheckIdNative(IntPtr type, IntPtr id, out IntPtr error);
+
+	internal class ExtractableCheckIdInvoker {
+
+		ExtractableCheckIdNative native_cb;
+		IntPtr __data;
+		GLib.DestroyNotify __notify;
+
+		~ExtractableCheckIdInvoker ()
+		{
+			if (__notify == null)
+				return;
+			__notify (__data);
+		}
+
+		internal ExtractableCheckIdInvoker (ExtractableCheckIdNative native_cb) : this (native_cb, IntPtr.Zero, null) {}
+
+		internal ExtractableCheckIdInvoker (ExtractableCheckIdNative native_cb, IntPtr data) : this (native_cb, data, null) {}
+
+		internal ExtractableCheckIdInvoker (ExtractableCheckIdNative native_cb, IntPtr data, GLib.DestroyNotify notify)
+		{
+			this.native_cb = native_cb;
+			__data = data;
+			__notify = notify;
+		}
+
+		internal GES.ExtractableCheckId Handler {
+			get {
+				return new GES.ExtractableCheckId(InvokeNative);
+			}
+		}
+
+		string InvokeNative (GLib.GType type, string id)
+		{
+			IntPtr native_id = GLib.Marshaller.StringToPtrGStrdup (id);
+			IntPtr error = IntPtr.Zero;
+			string __result = GLib.Marshaller.PtrToStringGFree(native_cb (type.Val, native_id, out error));
+			GLib.Marshaller.Free (native_id);
+			return __result;
+		}
+	}
+
+	internal class ExtractableCheckIdWrapper {
+
+		public IntPtr NativeCallback (IntPtr type, IntPtr id, out IntPtr error)
+		{
+			error = IntPtr.Zero;
+
+			try {
+				string __ret = managed (new GLib.GType(type), GLib.Marshaller.Utf8PtrToString (id));
+				if (release_on_call)
+					gch.Free ();
+				return GLib.Marshaller.StringToPtrGStrdup(__ret);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: Above call does not return.
+				throw e;
+			}
+		}
+
+		bool release_on_call = false;
+		GCHandle gch;
+
+		public void PersistUntilCalled ()
+		{
+			release_on_call = true;
+			gch = GCHandle.Alloc (this);
+		}
+
+		internal ExtractableCheckIdNative NativeDelegate;
+		GES.ExtractableCheckId managed;
+
+		public ExtractableCheckIdWrapper (GES.ExtractableCheckId managed)
+		{
+			this.managed = managed;
+			if (managed != null)
+				NativeDelegate = new ExtractableCheckIdNative (NativeCallback);
+		}
+
+		public static GES.ExtractableCheckId GetManagedDelegate (ExtractableCheckIdNative native)
+		{
+			if (native == null)
+				return null;
+			ExtractableCheckIdWrapper wrapper = (ExtractableCheckIdWrapper) native.Target;
+			if (wrapper == null)
+				return null;
+			return wrapper.managed;
+		}
+	}
+#endregion
+}

ges/generated/GES/GESSharp.FillTrackElementFuncNative.cs

@@ -0,0 +1,95 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GESSharp {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+	internal delegate bool FillTrackElementFuncNative(IntPtr clip, IntPtr track_element, IntPtr nleobj);
+
+	internal class FillTrackElementFuncInvoker {
+
+		FillTrackElementFuncNative native_cb;
+		IntPtr __data;
+		GLib.DestroyNotify __notify;
+
+		~FillTrackElementFuncInvoker ()
+		{
+			if (__notify == null)
+				return;
+			__notify (__data);
+		}
+
+		internal FillTrackElementFuncInvoker (FillTrackElementFuncNative native_cb) : this (native_cb, IntPtr.Zero, null) {}
+
+		internal FillTrackElementFuncInvoker (FillTrackElementFuncNative native_cb, IntPtr data) : this (native_cb, data, null) {}
+
+		internal FillTrackElementFuncInvoker (FillTrackElementFuncNative native_cb, IntPtr data, GLib.DestroyNotify notify)
+		{
+			this.native_cb = native_cb;
+			__data = data;
+			__notify = notify;
+		}
+
+		internal GES.FillTrackElementFunc Handler {
+			get {
+				return new GES.FillTrackElementFunc(InvokeNative);
+			}
+		}
+
+		bool InvokeNative (GES.Clip clip, GES.TrackElement track_element, Gst.Element nleobj)
+		{
+			bool __result = native_cb (clip == null ? IntPtr.Zero : clip.Handle, track_element == null ? IntPtr.Zero : track_element.Handle, nleobj == null ? IntPtr.Zero : nleobj.Handle);
+			return __result;
+		}
+	}
+
+	internal class FillTrackElementFuncWrapper {
+
+		public bool NativeCallback (IntPtr clip, IntPtr track_element, IntPtr nleobj)
+		{
+			try {
+				bool __ret = managed (GLib.Object.GetObject(clip) as GES.Clip, GLib.Object.GetObject(track_element) as GES.TrackElement, GLib.Object.GetObject(nleobj) as Gst.Element);
+				if (release_on_call)
+					gch.Free ();
+				return __ret;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+				return false;
+			}
+		}
+
+		bool release_on_call = false;
+		GCHandle gch;
+
+		public void PersistUntilCalled ()
+		{
+			release_on_call = true;
+			gch = GCHandle.Alloc (this);
+		}
+
+		internal FillTrackElementFuncNative NativeDelegate;
+		GES.FillTrackElementFunc managed;
+
+		public FillTrackElementFuncWrapper (GES.FillTrackElementFunc managed)
+		{
+			this.managed = managed;
+			if (managed != null)
+				NativeDelegate = new FillTrackElementFuncNative (NativeCallback);
+		}
+
+		public static GES.FillTrackElementFunc GetManagedDelegate (FillTrackElementFuncNative native)
+		{
+			if (native == null)
+				return null;
+			FillTrackElementFuncWrapper wrapper = (FillTrackElementFuncWrapper) native.Target;
+			if (wrapper == null)
+				return null;
+			return wrapper.managed;
+		}
+	}
+#endregion
+}

ges/generated/GES/GESSharp.FormatterCanLoadURIMethodNative.cs

@@ -0,0 +1,100 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GESSharp {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+	internal delegate bool FormatterCanLoadURIMethodNative(IntPtr dummy_instance, IntPtr uri, out IntPtr error);
+
+	internal class FormatterCanLoadURIMethodInvoker {
+
+		FormatterCanLoadURIMethodNative native_cb;
+		IntPtr __data;
+		GLib.DestroyNotify __notify;
+
+		~FormatterCanLoadURIMethodInvoker ()
+		{
+			if (__notify == null)
+				return;
+			__notify (__data);
+		}
+
+		internal FormatterCanLoadURIMethodInvoker (FormatterCanLoadURIMethodNative native_cb) : this (native_cb, IntPtr.Zero, null) {}
+
+		internal FormatterCanLoadURIMethodInvoker (FormatterCanLoadURIMethodNative native_cb, IntPtr data) : this (native_cb, data, null) {}
+
+		internal FormatterCanLoadURIMethodInvoker (FormatterCanLoadURIMethodNative native_cb, IntPtr data, GLib.DestroyNotify notify)
+		{
+			this.native_cb = native_cb;
+			__data = data;
+			__notify = notify;
+		}
+
+		internal GES.FormatterCanLoadURIMethod Handler {
+			get {
+				return new GES.FormatterCanLoadURIMethod(InvokeNative);
+			}
+		}
+
+		bool InvokeNative (GES.Formatter dummy_instance, string uri)
+		{
+			IntPtr native_uri = GLib.Marshaller.StringToPtrGStrdup (uri);
+			IntPtr error = IntPtr.Zero;
+			bool __result = native_cb (dummy_instance == null ? IntPtr.Zero : dummy_instance.Handle, native_uri, out error);
+			GLib.Marshaller.Free (native_uri);
+			return __result;
+		}
+	}
+
+	internal class FormatterCanLoadURIMethodWrapper {
+
+		public bool NativeCallback (IntPtr dummy_instance, IntPtr uri, out IntPtr error)
+		{
+			error = IntPtr.Zero;
+
+			try {
+				bool __ret = managed (GLib.Object.GetObject(dummy_instance) as GES.Formatter, GLib.Marshaller.Utf8PtrToString (uri));
+				if (release_on_call)
+					gch.Free ();
+				return __ret;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+				return false;
+			}
+		}
+
+		bool release_on_call = false;
+		GCHandle gch;
+
+		public void PersistUntilCalled ()
+		{
+			release_on_call = true;
+			gch = GCHandle.Alloc (this);
+		}
+
+		internal FormatterCanLoadURIMethodNative NativeDelegate;
+		GES.FormatterCanLoadURIMethod managed;
+
+		public FormatterCanLoadURIMethodWrapper (GES.FormatterCanLoadURIMethod managed)
+		{
+			this.managed = managed;
+			if (managed != null)
+				NativeDelegate = new FormatterCanLoadURIMethodNative (NativeCallback);
+		}
+
+		public static GES.FormatterCanLoadURIMethod GetManagedDelegate (FormatterCanLoadURIMethodNative native)
+		{
+			if (native == null)
+				return null;
+			FormatterCanLoadURIMethodWrapper wrapper = (FormatterCanLoadURIMethodWrapper) native.Target;
+			if (wrapper == null)
+				return null;
+			return wrapper.managed;
+		}
+	}
+#endregion
+}

ges/generated/GES/GESSharp.FormatterLoadFromURIMethodNative.cs

@@ -0,0 +1,100 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GESSharp {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+	internal delegate bool FormatterLoadFromURIMethodNative(IntPtr formatter, IntPtr timeline, IntPtr uri, out IntPtr error);
+
+	internal class FormatterLoadFromURIMethodInvoker {
+
+		FormatterLoadFromURIMethodNative native_cb;
+		IntPtr __data;
+		GLib.DestroyNotify __notify;
+
+		~FormatterLoadFromURIMethodInvoker ()
+		{
+			if (__notify == null)
+				return;
+			__notify (__data);
+		}
+
+		internal FormatterLoadFromURIMethodInvoker (FormatterLoadFromURIMethodNative native_cb) : this (native_cb, IntPtr.Zero, null) {}
+
+		internal FormatterLoadFromURIMethodInvoker (FormatterLoadFromURIMethodNative native_cb, IntPtr data) : this (native_cb, data, null) {}
+
+		internal FormatterLoadFromURIMethodInvoker (FormatterLoadFromURIMethodNative native_cb, IntPtr data, GLib.DestroyNotify notify)
+		{
+			this.native_cb = native_cb;
+			__data = data;
+			__notify = notify;
+		}
+
+		internal GES.FormatterLoadFromURIMethod Handler {
+			get {
+				return new GES.FormatterLoadFromURIMethod(InvokeNative);
+			}
+		}
+
+		bool InvokeNative (GES.Formatter formatter, GES.Timeline timeline, string uri)
+		{
+			IntPtr native_uri = GLib.Marshaller.StringToPtrGStrdup (uri);
+			IntPtr error = IntPtr.Zero;
+			bool __result = native_cb (formatter == null ? IntPtr.Zero : formatter.Handle, timeline == null ? IntPtr.Zero : timeline.Handle, native_uri, out error);
+			GLib.Marshaller.Free (native_uri);
+			return __result;
+		}
+	}
+
+	internal class FormatterLoadFromURIMethodWrapper {
+
+		public bool NativeCallback (IntPtr formatter, IntPtr timeline, IntPtr uri, out IntPtr error)
+		{
+			error = IntPtr.Zero;
+
+			try {
+				bool __ret = managed (GLib.Object.GetObject(formatter) as GES.Formatter, GLib.Object.GetObject(timeline) as GES.Timeline, GLib.Marshaller.Utf8PtrToString (uri));
+				if (release_on_call)
+					gch.Free ();
+				return __ret;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+				return false;
+			}
+		}
+
+		bool release_on_call = false;
+		GCHandle gch;
+
+		public void PersistUntilCalled ()
+		{
+			release_on_call = true;
+			gch = GCHandle.Alloc (this);
+		}
+
+		internal FormatterLoadFromURIMethodNative NativeDelegate;
+		GES.FormatterLoadFromURIMethod managed;
+
+		public FormatterLoadFromURIMethodWrapper (GES.FormatterLoadFromURIMethod managed)
+		{
+			this.managed = managed;
+			if (managed != null)
+				NativeDelegate = new FormatterLoadFromURIMethodNative (NativeCallback);
+		}
+
+		public static GES.FormatterLoadFromURIMethod GetManagedDelegate (FormatterLoadFromURIMethodNative native)
+		{
+			if (native == null)
+				return null;
+			FormatterLoadFromURIMethodWrapper wrapper = (FormatterLoadFromURIMethodWrapper) native.Target;
+			if (wrapper == null)
+				return null;
+			return wrapper.managed;
+		}
+	}
+#endregion
+}

ges/generated/GES/GESSharp.FormatterSaveToURIMethodNative.cs

@@ -0,0 +1,100 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GESSharp {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+	internal delegate bool FormatterSaveToURIMethodNative(IntPtr formatter, IntPtr timeline, IntPtr uri, bool overwrite, out IntPtr error);
+
+	internal class FormatterSaveToURIMethodInvoker {
+
+		FormatterSaveToURIMethodNative native_cb;
+		IntPtr __data;
+		GLib.DestroyNotify __notify;
+
+		~FormatterSaveToURIMethodInvoker ()
+		{
+			if (__notify == null)
+				return;
+			__notify (__data);
+		}
+
+		internal FormatterSaveToURIMethodInvoker (FormatterSaveToURIMethodNative native_cb) : this (native_cb, IntPtr.Zero, null) {}
+
+		internal FormatterSaveToURIMethodInvoker (FormatterSaveToURIMethodNative native_cb, IntPtr data) : this (native_cb, data, null) {}
+
+		internal FormatterSaveToURIMethodInvoker (FormatterSaveToURIMethodNative native_cb, IntPtr data, GLib.DestroyNotify notify)
+		{
+			this.native_cb = native_cb;
+			__data = data;
+			__notify = notify;
+		}
+
+		internal GES.FormatterSaveToURIMethod Handler {
+			get {
+				return new GES.FormatterSaveToURIMethod(InvokeNative);
+			}
+		}
+
+		bool InvokeNative (GES.Formatter formatter, GES.Timeline timeline, string uri, bool overwrite)
+		{
+			IntPtr native_uri = GLib.Marshaller.StringToPtrGStrdup (uri);
+			IntPtr error = IntPtr.Zero;
+			bool __result = native_cb (formatter == null ? IntPtr.Zero : formatter.Handle, timeline == null ? IntPtr.Zero : timeline.Handle, native_uri, overwrite, out error);
+			GLib.Marshaller.Free (native_uri);
+			return __result;
+		}
+	}
+
+	internal class FormatterSaveToURIMethodWrapper {
+
+		public bool NativeCallback (IntPtr formatter, IntPtr timeline, IntPtr uri, bool overwrite, out IntPtr error)
+		{
+			error = IntPtr.Zero;
+
+			try {
+				bool __ret = managed (GLib.Object.GetObject(formatter) as GES.Formatter, GLib.Object.GetObject(timeline) as GES.Timeline, GLib.Marshaller.Utf8PtrToString (uri), overwrite);
+				if (release_on_call)
+					gch.Free ();
+				return __ret;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+				return false;
+			}
+		}
+
+		bool release_on_call = false;
+		GCHandle gch;
+
+		public void PersistUntilCalled ()
+		{
+			release_on_call = true;
+			gch = GCHandle.Alloc (this);
+		}
+
+		internal FormatterSaveToURIMethodNative NativeDelegate;
+		GES.FormatterSaveToURIMethod managed;
+
+		public FormatterSaveToURIMethodWrapper (GES.FormatterSaveToURIMethod managed)
+		{
+			this.managed = managed;
+			if (managed != null)
+				NativeDelegate = new FormatterSaveToURIMethodNative (NativeCallback);
+		}
+
+		public static GES.FormatterSaveToURIMethod GetManagedDelegate (FormatterSaveToURIMethodNative native)
+		{
+			if (native == null)
+				return null;
+			FormatterSaveToURIMethodWrapper wrapper = (FormatterSaveToURIMethodWrapper) native.Target;
+			if (wrapper == null)
+				return null;
+			return wrapper.managed;
+		}
+	}
+#endregion
+}

ges/generated/GES/GESSharp.MetaForeachFuncNative.cs

@@ -0,0 +1,96 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GESSharp {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+	internal delegate void MetaForeachFuncNative(IntPtr container, IntPtr key, IntPtr value, IntPtr user_data);
+
+	internal class MetaForeachFuncInvoker {
+
+		MetaForeachFuncNative native_cb;
+		IntPtr __data;
+		GLib.DestroyNotify __notify;
+
+		~MetaForeachFuncInvoker ()
+		{
+			if (__notify == null)
+				return;
+			__notify (__data);
+		}
+
+		internal MetaForeachFuncInvoker (MetaForeachFuncNative native_cb) : this (native_cb, IntPtr.Zero, null) {}
+
+		internal MetaForeachFuncInvoker (MetaForeachFuncNative native_cb, IntPtr data) : this (native_cb, data, null) {}
+
+		internal MetaForeachFuncInvoker (MetaForeachFuncNative native_cb, IntPtr data, GLib.DestroyNotify notify)
+		{
+			this.native_cb = native_cb;
+			__data = data;
+			__notify = notify;
+		}
+
+		internal GES.MetaForeachFunc Handler {
+			get {
+				return new GES.MetaForeachFunc(InvokeNative);
+			}
+		}
+
+		void InvokeNative (GES.IMetaContainer container, string key, GLib.Value value)
+		{
+			IntPtr native_key = GLib.Marshaller.StringToPtrGStrdup (key);
+			IntPtr native_value = GLib.Marshaller.StructureToPtrAlloc (value);
+			native_cb (container == null ? IntPtr.Zero : ((container is GLib.Object) ? (container as GLib.Object).Handle : (container as GES.MetaContainerAdapter).Handle), native_key, native_value, __data);
+			GLib.Marshaller.Free (native_key);
+			Marshal.FreeHGlobal (native_value);
+		}
+	}
+
+	internal class MetaForeachFuncWrapper {
+
+		public void NativeCallback (IntPtr container, IntPtr key, IntPtr value, IntPtr user_data)
+		{
+			try {
+				managed (GES.MetaContainerAdapter.GetObject (container, false), GLib.Marshaller.Utf8PtrToString (key), (GLib.Value) Marshal.PtrToStructure (value, typeof (GLib.Value)));
+				if (release_on_call)
+					gch.Free ();
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		bool release_on_call = false;
+		GCHandle gch;
+
+		public void PersistUntilCalled ()
+		{
+			release_on_call = true;
+			gch = GCHandle.Alloc (this);
+		}
+
+		internal MetaForeachFuncNative NativeDelegate;
+		GES.MetaForeachFunc managed;
+
+		public MetaForeachFuncWrapper (GES.MetaForeachFunc managed)
+		{
+			this.managed = managed;
+			if (managed != null)
+				NativeDelegate = new MetaForeachFuncNative (NativeCallback);
+		}
+
+		public static GES.MetaForeachFunc GetManagedDelegate (MetaForeachFuncNative native)
+		{
+			if (native == null)
+				return null;
+			MetaForeachFuncWrapper wrapper = (MetaForeachFuncWrapper) native.Target;
+			if (wrapper == null)
+				return null;
+			return wrapper.managed;
+		}
+	}
+#endregion
+}

ges/generated/GES/Global.cs

@@ -0,0 +1,153 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class Global {
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_add_missing_uri_relocation_uri(IntPtr uri, bool recurse);
+
+		public static bool AddMissingUriRelocationUri(string uri, bool recurse) {
+			IntPtr native_uri = GLib.Marshaller.StringToPtrGStrdup (uri);
+			bool raw_ret = ges_add_missing_uri_relocation_uri(native_uri, recurse);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_uri);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern void ges_deinit();
+
+		public static void Deinit() {
+			ges_deinit();
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_edge_name(int edge);
+
+		public static string EdgeName(GES.Edge edge) {
+			IntPtr raw_ret = ges_edge_name((int) edge);
+			string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_edit_mode_name(int mode);
+
+		public static string EditModeName(GES.EditMode mode) {
+			IntPtr raw_ret = ges_edit_mode_name((int) mode);
+			string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_find_formatter_for_uri(IntPtr uri);
+
+		public static GES.Asset FindFormatterForUri(string uri) {
+			IntPtr native_uri = GLib.Marshaller.StringToPtrGStrdup (uri);
+			IntPtr raw_ret = ges_find_formatter_for_uri(native_uri);
+			GES.Asset ret = GLib.Object.GetObject(raw_ret) as GES.Asset;
+			GLib.Marshaller.Free (native_uri);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_init();
+
+		public static bool Init() {
+			bool raw_ret = ges_init();
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_is_initialized();
+
+		public static bool IsInitialized { 
+			get {
+				bool raw_ret = ges_is_initialized();
+				bool ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_list_assets(IntPtr filter);
+
+		public static GES.Asset[] ListAssets(GLib.GType filter) {
+			IntPtr raw_ret = ges_list_assets(filter.Val);
+			GES.Asset[] ret = (GES.Asset[]) GLib.Marshaller.ListPtrToArray (raw_ret, typeof(GLib.List), false, true, typeof(GES.Asset));
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_play_sink_convert_frame(IntPtr playsink, IntPtr caps);
+
+		[Obsolete]
+		public static Gst.Sample PlaySinkConvertFrame(Gst.Element playsink, Gst.Caps caps) {
+			IntPtr raw_ret = ges_play_sink_convert_frame(playsink == null ? IntPtr.Zero : playsink.Handle, caps == null ? IntPtr.Zero : caps.Handle);
+			Gst.Sample ret = raw_ret == IntPtr.Zero ? null : (Gst.Sample) GLib.Opaque.GetOpaque (raw_ret, typeof (Gst.Sample), true);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_pspec_equal(IntPtr key_spec_1, IntPtr key_spec_2);
+
+		public static bool PspecEqual(IntPtr key_spec_1, IntPtr key_spec_2) {
+			bool raw_ret = ges_pspec_equal(key_spec_1, key_spec_2);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		public static bool PspecEqual() {
+			return PspecEqual (IntPtr.Zero, IntPtr.Zero);
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern uint ges_pspec_hash(IntPtr key_spec);
+
+		public static uint PspecHash(IntPtr key_spec) {
+			uint raw_ret = ges_pspec_hash(key_spec);
+			uint ret = raw_ret;
+			return ret;
+		}
+
+		public static uint PspecHash() {
+			return PspecHash (IntPtr.Zero);
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_track_type_name(int type);
+
+		public static string TrackTypeName(GES.TrackType type) {
+			IntPtr raw_ret = ges_track_type_name((int) type);
+			string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_validate_register_action_types();
+
+		public static bool ValidateRegisterActionTypes() {
+			bool raw_ret = ges_validate_register_action_types();
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern void ges_version(out uint major, out uint minor, out uint micro, out uint nano);
+
+		public static void Version(out uint major, out uint minor, out uint micro, out uint nano) {
+			ges_version(out major, out minor, out micro, out nano);
+		}
+
+#endregion
+	}
+}

ges/generated/GES/Group.cs

@@ -0,0 +1,177 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class Group : GES.Container {
+
+		public Group (IntPtr raw) : base(raw) {}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_group_new();
+
+		public Group () : base (IntPtr.Zero)
+		{
+			if (GetType () != typeof (Group)) {
+				CreateNativeObject (new string [0], new GLib.Value[0]);
+				return;
+			}
+			Raw = ges_group_new();
+		}
+
+		[GLib.Property ("duration")]
+		public new ulong Duration {
+			get {
+				GLib.Value val = GetProperty ("duration");
+				ulong ret = (ulong) val;
+				val.Dispose ();
+				return ret;
+			}
+			set {
+				GLib.Value val = new GLib.Value(value);
+				SetProperty("duration", val);
+				val.Dispose ();
+			}
+		}
+
+		[GLib.Property ("in-point")]
+		public new ulong InPoint {
+			get {
+				GLib.Value val = GetProperty ("in-point");
+				ulong ret = (ulong) val;
+				val.Dispose ();
+				return ret;
+			}
+			set {
+				GLib.Value val = new GLib.Value(value);
+				SetProperty("in-point", val);
+				val.Dispose ();
+			}
+		}
+
+		[GLib.Property ("max-duration")]
+		public new ulong MaxDuration {
+			get {
+				GLib.Value val = GetProperty ("max-duration");
+				ulong ret = (ulong) val;
+				val.Dispose ();
+				return ret;
+			}
+			set {
+				GLib.Value val = new GLib.Value(value);
+				SetProperty("max-duration", val);
+				val.Dispose ();
+			}
+		}
+
+		[GLib.Property ("priority")]
+		public new uint Priority {
+			get {
+				GLib.Value val = GetProperty ("priority");
+				uint ret = (uint) val;
+				val.Dispose ();
+				return ret;
+			}
+			set {
+				GLib.Value val = new GLib.Value(value);
+				SetProperty("priority", val);
+				val.Dispose ();
+			}
+		}
+
+		[GLib.Property ("start")]
+		public new ulong Start {
+			get {
+				GLib.Value val = GetProperty ("start");
+				ulong ret = (ulong) val;
+				val.Dispose ();
+				return ret;
+			}
+			set {
+				GLib.Value val = new GLib.Value(value);
+				SetProperty("start", val);
+				val.Dispose ();
+			}
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("_ges_reserved"
+							, GES.Container.class_abi.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _ges_reserved
+							, null
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_group_get_type();
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = ges_group_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+
+		static Group ()
+		{
+			GtkSharp.GstEditingServices.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("priv"
+							, GES.Container.abi_info.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // priv
+							, null
+							, "_ges_reserved"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("_ges_reserved"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _ges_reserved
+							, "priv"
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

ges/generated/GES/GroupAddedHandler.cs

@@ -0,0 +1,18 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+
+	public delegate void GroupAddedHandler(object o, GroupAddedArgs args);
+
+	public class GroupAddedArgs : GLib.SignalArgs {
+		public GES.Group Group{
+			get {
+				return (GES.Group) Args [0];
+			}
+		}
+
+	}
+}

ges/generated/GES/IExtractable.cs

@@ -0,0 +1,27 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+
+#region Autogenerated code
+	public partial interface IExtractable : GLib.IWrapper {
+
+		GES.Asset Asset { 
+			get;
+		}
+		string Id { 
+			get;
+		}
+		bool SetAsset(GES.Asset asset);
+	}
+
+	[GLib.GInterface (typeof (ExtractableAdapter))]
+	public partial interface IExtractableImplementor : GLib.IWrapper {
+
+		GES.Asset Asset { set; }
+		string Id { get; }
+	}
+#endregion
+}

ges/generated/GES/IMetaContainer.cs

@@ -0,0 +1,56 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+
+#region Autogenerated code
+	public partial interface IMetaContainer : GLib.IWrapper {
+
+		event GES.NotifyMetaHandler NotifyMeta;
+		bool AddMetasFromString(string str);
+		bool CheckMetaRegistered(string meta_item, out GES.MetaFlag flags, out GLib.GType type);
+		void Foreach(GES.MetaForeachFunc func);
+		bool GetBoolean(string meta_item, out bool dest);
+		bool GetDateTime(string meta_item, out Gst.DateTime dest);
+		bool GetDouble(string meta_item, out double dest);
+		bool GetFloat(string meta_item, out float dest);
+		bool GetInt(string meta_item, out int dest);
+		bool GetInt64(string meta_item, out long dest);
+		GES.MarkerList GetMarkerList(string key);
+		GLib.Value GetMeta(string key);
+		string GetString(string meta_item);
+		bool GetUint(string meta_item, out uint dest);
+		bool GetUint64(string meta_item, out ulong dest);
+		string MetasToString();
+		bool RegisterMeta(GES.MetaFlag flags, string meta_item, GLib.Value value);
+		bool RegisterMetaBoolean(GES.MetaFlag flags, string meta_item, bool value);
+		bool RegisterMetaDateTime(GES.MetaFlag flags, string meta_item, Gst.DateTime value);
+		bool RegisterMetaDouble(GES.MetaFlag flags, string meta_item, double value);
+		bool RegisterMetaFloat(GES.MetaFlag flags, string meta_item, float value);
+		bool RegisterMetaInt(GES.MetaFlag flags, string meta_item, int value);
+		bool RegisterMetaInt64(GES.MetaFlag flags, string meta_item, long value);
+		bool RegisterMetaString(GES.MetaFlag flags, string meta_item, string value);
+		bool RegisterMetaUint(GES.MetaFlag flags, string meta_item, uint value);
+		bool RegisterMetaUint64(GES.MetaFlag flags, string meta_item, ulong value);
+		bool RegisterStaticMeta(GES.MetaFlag flags, string meta_item, GLib.GType type);
+		bool SetBoolean(string meta_item, bool value);
+		bool SetDateTime(string meta_item, Gst.DateTime value);
+		bool SetDouble(string meta_item, double value);
+		bool SetFloat(string meta_item, float value);
+		bool SetInt(string meta_item, int value);
+		bool SetInt64(string meta_item, long value);
+		bool SetMarkerList(string meta_item, GES.MarkerList list);
+		bool SetMeta(string meta_item, GLib.Value value);
+		bool SetString(string meta_item, string value);
+		bool SetUint(string meta_item, uint value);
+		bool SetUint64(string meta_item, ulong value);
+	}
+
+	[GLib.GInterface (typeof (MetaContainerAdapter))]
+	public partial interface IMetaContainerImplementor : GLib.IWrapper {
+
+	}
+#endregion
+}

ges/generated/GES/ImageSource.cs

@@ -0,0 +1,114 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[Obsolete]
+	public partial class ImageSource : GES.VideoSource {
+
+		public ImageSource (IntPtr raw) : base(raw) {}
+
+		protected ImageSource() : base(IntPtr.Zero)
+		{
+			CreateNativeObject (new string [0], new GLib.Value [0]);
+		}
+
+		[GLib.Property ("uri")]
+		public string Uri {
+			get {
+				GLib.Value val = GetProperty ("uri");
+				string ret = (string) val;
+				val.Dispose ();
+				return ret;
+			}
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("_ges_reserved"
+							, GES.VideoSource.class_abi.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _ges_reserved
+							, null
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_image_source_get_type();
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = ges_image_source_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+
+		static ImageSource ()
+		{
+			GtkSharp.GstEditingServices.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("uri"
+							, GES.VideoSource.abi_info.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // uri
+							, null
+							, "priv"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("priv"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // priv
+							, "uri"
+							, "_ges_reserved"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("_ges_reserved"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _ges_reserved
+							, "priv"
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

ges/generated/GES/LayerAddedHandler.cs

@@ -0,0 +1,18 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+
+	public delegate void LayerAddedHandler(object o, LayerAddedArgs args);
+
+	public class LayerAddedArgs : GLib.SignalArgs {
+		public GES.Layer Layer{
+			get {
+				return (GES.Layer) Args [0];
+			}
+		}
+
+	}
+}

ges/generated/GES/LayerRemovedHandler.cs

@@ -0,0 +1,18 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+
+	public delegate void LayerRemovedHandler(object o, LayerRemovedArgs args);
+
+	public class LayerRemovedArgs : GLib.SignalArgs {
+		public GES.Layer Layer{
+			get {
+				return (GES.Layer) Args [0];
+			}
+		}
+
+	}
+}

ges/generated/GES/LoadedHandler.cs

@@ -0,0 +1,18 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+
+	public delegate void LoadedHandler(object o, LoadedArgs args);
+
+	public class LoadedArgs : GLib.SignalArgs {
+		public GES.Timeline Timeline{
+			get {
+				return (GES.Timeline) Args [0];
+			}
+		}
+
+	}
+}

ges/generated/GES/LoadingHandler.cs

@@ -0,0 +1,18 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+
+	public delegate void LoadingHandler(object o, LoadingArgs args);
+
+	public class LoadingArgs : GLib.SignalArgs {
+		public GES.Timeline Timeline{
+			get {
+				return (GES.Timeline) Args [0];
+			}
+		}
+
+	}
+}

ges/generated/GES/Marker.cs

@@ -0,0 +1,562 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class Marker : GLib.Object, GES.IMetaContainer {
+
+		public Marker (IntPtr raw) : base(raw) {}
+
+		protected Marker() : base(IntPtr.Zero)
+		{
+			CreateNativeObject (new string [0], new GLib.Value [0]);
+		}
+
+		[GLib.Property ("position")]
+		public ulong Position {
+			get {
+				GLib.Value val = GetProperty ("position");
+				ulong ret = (ulong) val;
+				val.Dispose ();
+				return ret;
+			}
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (GLib.Object.class_abi.Fields);
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_marker_get_type();
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = ges_marker_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_add_metas_from_string(IntPtr raw, IntPtr str);
+
+		public bool AddMetasFromString(string str) {
+			IntPtr native_str = GLib.Marshaller.StringToPtrGStrdup (str);
+			bool raw_ret = ges_meta_container_add_metas_from_string(Handle, native_str);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_str);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_check_meta_registered(IntPtr raw, IntPtr meta_item, out int flags, out IntPtr type);
+
+		public bool CheckMetaRegistered(string meta_item, out GES.MetaFlag flags, out GLib.GType type) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			int native_flags;
+			IntPtr native_type;
+			bool raw_ret = ges_meta_container_check_meta_registered(Handle, native_meta_item, out native_flags, out native_type);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			flags = (GES.MetaFlag) native_flags;
+			type = new GLib.GType(native_type);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern void ges_meta_container_foreach(IntPtr raw, GESSharp.MetaForeachFuncNative func, IntPtr user_data);
+
+		public void Foreach(GES.MetaForeachFunc func) {
+			GESSharp.MetaForeachFuncWrapper func_wrapper = new GESSharp.MetaForeachFuncWrapper (func);
+			ges_meta_container_foreach(Handle, func_wrapper.NativeDelegate, IntPtr.Zero);
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_get_boolean(IntPtr raw, IntPtr meta_item, out bool dest);
+
+		public bool GetBoolean(string meta_item, out bool dest) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_get_boolean(Handle, native_meta_item, out dest);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_get_date_time(IntPtr raw, IntPtr meta_item, out IntPtr dest);
+
+		public bool GetDateTime(string meta_item, out Gst.DateTime dest) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			IntPtr native_dest;
+			bool raw_ret = ges_meta_container_get_date_time(Handle, native_meta_item, out native_dest);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			dest = native_dest == IntPtr.Zero ? null : (Gst.DateTime) GLib.Opaque.GetOpaque (native_dest, typeof (Gst.DateTime), true);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_get_double(IntPtr raw, IntPtr meta_item, out double dest);
+
+		public bool GetDouble(string meta_item, out double dest) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_get_double(Handle, native_meta_item, out dest);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_get_float(IntPtr raw, IntPtr meta_item, out float dest);
+
+		public bool GetFloat(string meta_item, out float dest) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_get_float(Handle, native_meta_item, out dest);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_get_int(IntPtr raw, IntPtr meta_item, out int dest);
+
+		public bool GetInt(string meta_item, out int dest) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_get_int(Handle, native_meta_item, out dest);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_get_int64(IntPtr raw, IntPtr meta_item, out long dest);
+
+		public bool GetInt64(string meta_item, out long dest) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_get_int64(Handle, native_meta_item, out dest);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_meta_container_get_marker_list(IntPtr raw, IntPtr key);
+
+		public GES.MarkerList GetMarkerList(string key) {
+			IntPtr native_key = GLib.Marshaller.StringToPtrGStrdup (key);
+			IntPtr raw_ret = ges_meta_container_get_marker_list(Handle, native_key);
+			GES.MarkerList ret = GLib.Object.GetObject(raw_ret, true) as GES.MarkerList;
+			GLib.Marshaller.Free (native_key);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_meta_container_get_meta(IntPtr raw, IntPtr key);
+
+		public GLib.Value GetMeta(string key) {
+			IntPtr native_key = GLib.Marshaller.StringToPtrGStrdup (key);
+			IntPtr raw_ret = ges_meta_container_get_meta(Handle, native_key);
+			GLib.Value ret = (GLib.Value) Marshal.PtrToStructure (raw_ret, typeof (GLib.Value));
+			GLib.Marshaller.Free (native_key);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_meta_container_get_string(IntPtr raw, IntPtr meta_item);
+
+		public string GetString(string meta_item) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			IntPtr raw_ret = ges_meta_container_get_string(Handle, native_meta_item);
+			string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_get_uint(IntPtr raw, IntPtr meta_item, out uint dest);
+
+		public bool GetUint(string meta_item, out uint dest) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_get_uint(Handle, native_meta_item, out dest);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_get_uint64(IntPtr raw, IntPtr meta_item, out ulong dest);
+
+		public bool GetUint64(string meta_item, out ulong dest) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_get_uint64(Handle, native_meta_item, out dest);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_meta_container_metas_to_string(IntPtr raw);
+
+		public string MetasToString() {
+			IntPtr raw_ret = ges_meta_container_metas_to_string(Handle);
+			string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_register_meta(IntPtr raw, int flags, IntPtr meta_item, IntPtr value);
+
+		public bool RegisterMeta(GES.MetaFlag flags, string meta_item, GLib.Value value) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			IntPtr native_value = GLib.Marshaller.StructureToPtrAlloc (value);
+			bool raw_ret = ges_meta_container_register_meta(Handle, (int) flags, native_meta_item, native_value);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			Marshal.FreeHGlobal (native_value);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_register_meta_boolean(IntPtr raw, int flags, IntPtr meta_item, bool value);
+
+		public bool RegisterMetaBoolean(GES.MetaFlag flags, string meta_item, bool value) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_register_meta_boolean(Handle, (int) flags, native_meta_item, value);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_register_meta_date_time(IntPtr raw, int flags, IntPtr meta_item, IntPtr value);
+
+		public bool RegisterMetaDateTime(GES.MetaFlag flags, string meta_item, Gst.DateTime value) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_register_meta_date_time(Handle, (int) flags, native_meta_item, value == null ? IntPtr.Zero : value.Handle);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_register_meta_double(IntPtr raw, int flags, IntPtr meta_item, double value);
+
+		public bool RegisterMetaDouble(GES.MetaFlag flags, string meta_item, double value) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_register_meta_double(Handle, (int) flags, native_meta_item, value);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_register_meta_float(IntPtr raw, int flags, IntPtr meta_item, float value);
+
+		public bool RegisterMetaFloat(GES.MetaFlag flags, string meta_item, float value) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_register_meta_float(Handle, (int) flags, native_meta_item, value);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_register_meta_int(IntPtr raw, int flags, IntPtr meta_item, int value);
+
+		public bool RegisterMetaInt(GES.MetaFlag flags, string meta_item, int value) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_register_meta_int(Handle, (int) flags, native_meta_item, value);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_register_meta_int64(IntPtr raw, int flags, IntPtr meta_item, long value);
+
+		public bool RegisterMetaInt64(GES.MetaFlag flags, string meta_item, long value) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_register_meta_int64(Handle, (int) flags, native_meta_item, value);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_register_meta_string(IntPtr raw, int flags, IntPtr meta_item, IntPtr value);
+
+		public bool RegisterMetaString(GES.MetaFlag flags, string meta_item, string value) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
+			bool raw_ret = ges_meta_container_register_meta_string(Handle, (int) flags, native_meta_item, native_value);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			GLib.Marshaller.Free (native_value);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_register_meta_uint(IntPtr raw, int flags, IntPtr meta_item, uint value);
+
+		public bool RegisterMetaUint(GES.MetaFlag flags, string meta_item, uint value) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_register_meta_uint(Handle, (int) flags, native_meta_item, value);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_register_meta_uint64(IntPtr raw, int flags, IntPtr meta_item, ulong value);
+
+		public bool RegisterMetaUint64(GES.MetaFlag flags, string meta_item, ulong value) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_register_meta_uint64(Handle, (int) flags, native_meta_item, value);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_register_static_meta(IntPtr raw, int flags, IntPtr meta_item, IntPtr type);
+
+		public bool RegisterStaticMeta(GES.MetaFlag flags, string meta_item, GLib.GType type) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_register_static_meta(Handle, (int) flags, native_meta_item, type.Val);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_set_boolean(IntPtr raw, IntPtr meta_item, bool value);
+
+		public bool SetBoolean(string meta_item, bool value) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_set_boolean(Handle, native_meta_item, value);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_set_date_time(IntPtr raw, IntPtr meta_item, IntPtr value);
+
+		public bool SetDateTime(string meta_item, Gst.DateTime value) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_set_date_time(Handle, native_meta_item, value == null ? IntPtr.Zero : value.Handle);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_set_double(IntPtr raw, IntPtr meta_item, double value);
+
+		public bool SetDouble(string meta_item, double value) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_set_double(Handle, native_meta_item, value);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_set_float(IntPtr raw, IntPtr meta_item, float value);
+
+		public bool SetFloat(string meta_item, float value) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_set_float(Handle, native_meta_item, value);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_set_int(IntPtr raw, IntPtr meta_item, int value);
+
+		public bool SetInt(string meta_item, int value) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_set_int(Handle, native_meta_item, value);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_set_int64(IntPtr raw, IntPtr meta_item, long value);
+
+		public bool SetInt64(string meta_item, long value) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_set_int64(Handle, native_meta_item, value);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_set_marker_list(IntPtr raw, IntPtr meta_item, IntPtr list);
+
+		public bool SetMarkerList(string meta_item, GES.MarkerList list) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_set_marker_list(Handle, native_meta_item, list == null ? IntPtr.Zero : list.Handle);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_set_meta(IntPtr raw, IntPtr meta_item, IntPtr value);
+
+		public bool SetMeta(string meta_item, GLib.Value value) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			IntPtr native_value = GLib.Marshaller.StructureToPtrAlloc (value);
+			bool raw_ret = ges_meta_container_set_meta(Handle, native_meta_item, native_value);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			Marshal.FreeHGlobal (native_value);
+			return ret;
+		}
+
+		public bool SetMeta(string meta_item) {
+			return SetMeta (meta_item, GLib.Value.Empty);
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_set_string(IntPtr raw, IntPtr meta_item, IntPtr value);
+
+		public bool SetString(string meta_item, string value) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
+			bool raw_ret = ges_meta_container_set_string(Handle, native_meta_item, native_value);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			GLib.Marshaller.Free (native_value);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_set_uint(IntPtr raw, IntPtr meta_item, uint value);
+
+		public bool SetUint(string meta_item, uint value) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_set_uint(Handle, native_meta_item, value);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_set_uint64(IntPtr raw, IntPtr meta_item, ulong value);
+
+		public bool SetUint64(string meta_item, ulong value) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_set_uint64(Handle, native_meta_item, value);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[GLib.Signal("notify-meta")]
+		public event GES.NotifyMetaHandler NotifyMeta {
+			add {
+				this.AddSignalHandler ("notify-meta", value, typeof (GES.NotifyMetaArgs));
+			}
+			remove {
+				this.RemoveSignalHandler ("notify-meta", value);
+			}
+		}
+
+		static NotifyMetaNativeDelegate NotifyMeta_cb_delegate;
+		static NotifyMetaNativeDelegate NotifyMetaVMCallback {
+			get {
+				if (NotifyMeta_cb_delegate == null)
+					NotifyMeta_cb_delegate = new NotifyMetaNativeDelegate (NotifyMeta_cb);
+				return NotifyMeta_cb_delegate;
+			}
+		}
+
+		static void OverrideNotifyMeta (GLib.GType gtype)
+		{
+			OverrideNotifyMeta (gtype, NotifyMetaVMCallback);
+		}
+
+		static void OverrideNotifyMeta (GLib.GType gtype, NotifyMetaNativeDelegate callback)
+		{
+			OverrideVirtualMethod (gtype, "notify-meta", callback);
+		}
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void NotifyMetaNativeDelegate (IntPtr inst, IntPtr key, IntPtr value);
+
+		static void NotifyMeta_cb (IntPtr inst, IntPtr key, IntPtr value)
+		{
+			try {
+				GES.Marker __obj = GLib.Object.GetObject (inst, false) as GES.Marker;
+				__obj.OnNotifyMeta (GLib.Marshaller.Utf8PtrToString (key), (GLib.Value) Marshal.PtrToStructure (value, typeof (GLib.Value)));
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(GES.Marker), ConnectionMethod="OverrideNotifyMeta")]
+		protected virtual void OnNotifyMeta (string key, GLib.Value value)
+		{
+			InternalNotifyMeta (key, value);
+		}
+
+		private void InternalNotifyMeta (string key, GLib.Value value)
+		{
+			GLib.Value ret = GLib.Value.Empty;
+			GLib.ValueArray inst_and_params = new GLib.ValueArray (3);
+			GLib.Value[] vals = new GLib.Value [3];
+			vals [0] = new GLib.Value (this);
+			inst_and_params.Append (vals [0]);
+			vals [1] = new GLib.Value (key);
+			inst_and_params.Append (vals [1]);
+			vals [2] = new GLib.Value (value);
+			inst_and_params.Append (vals [2]);
+			g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
+			foreach (GLib.Value v in vals)
+				v.Dispose ();
+		}
+
+
+		static Marker ()
+		{
+			GtkSharp.GstEditingServices.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (GLib.Object.abi_info.Fields);
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

ges/generated/GES/MarkerAddedHandler.cs

@@ -0,0 +1,24 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+
+	public delegate void MarkerAddedHandler(object o, MarkerAddedArgs args);
+
+	public class MarkerAddedArgs : GLib.SignalArgs {
+		public ulong Position{
+			get {
+				return (ulong) Args [0];
+			}
+		}
+
+		public GES.Marker Marker{
+			get {
+				return (GES.Marker) Args [1];
+			}
+		}
+
+	}
+}

ges/generated/GES/MarkerList.cs

@@ -0,0 +1,312 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class MarkerList : GLib.Object {
+
+		public MarkerList (IntPtr raw) : base(raw) {}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_marker_list_new();
+
+		public MarkerList () : base (IntPtr.Zero)
+		{
+			if (GetType () != typeof (MarkerList)) {
+				CreateNativeObject (new string [0], new GLib.Value[0]);
+				return;
+			}
+			Raw = ges_marker_list_new();
+		}
+
+		[GLib.Signal("marker-added")]
+		public event GES.MarkerAddedHandler MarkerAdded {
+			add {
+				this.AddSignalHandler ("marker-added", value, typeof (GES.MarkerAddedArgs));
+			}
+			remove {
+				this.RemoveSignalHandler ("marker-added", value);
+			}
+		}
+
+		[GLib.Signal("marker-moved")]
+		public event GES.MarkerMovedHandler MarkerMoved {
+			add {
+				this.AddSignalHandler ("marker-moved", value, typeof (GES.MarkerMovedArgs));
+			}
+			remove {
+				this.RemoveSignalHandler ("marker-moved", value);
+			}
+		}
+
+		[GLib.Signal("marker-removed")]
+		public event GES.MarkerRemovedHandler MarkerRemoved {
+			add {
+				this.AddSignalHandler ("marker-removed", value, typeof (GES.MarkerRemovedArgs));
+			}
+			remove {
+				this.RemoveSignalHandler ("marker-removed", value);
+			}
+		}
+
+		static MarkerAddedNativeDelegate MarkerAdded_cb_delegate;
+		static MarkerAddedNativeDelegate MarkerAddedVMCallback {
+			get {
+				if (MarkerAdded_cb_delegate == null)
+					MarkerAdded_cb_delegate = new MarkerAddedNativeDelegate (MarkerAdded_cb);
+				return MarkerAdded_cb_delegate;
+			}
+		}
+
+		static void OverrideMarkerAdded (GLib.GType gtype)
+		{
+			OverrideMarkerAdded (gtype, MarkerAddedVMCallback);
+		}
+
+		static void OverrideMarkerAdded (GLib.GType gtype, MarkerAddedNativeDelegate callback)
+		{
+			OverrideVirtualMethod (gtype, "marker-added", callback);
+		}
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void MarkerAddedNativeDelegate (IntPtr inst, ulong position, IntPtr marker);
+
+		static void MarkerAdded_cb (IntPtr inst, ulong position, IntPtr marker)
+		{
+			try {
+				MarkerList __obj = GLib.Object.GetObject (inst, false) as MarkerList;
+				__obj.OnMarkerAdded (position, GLib.Object.GetObject(marker) as GES.Marker);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(GES.MarkerList), ConnectionMethod="OverrideMarkerAdded")]
+		protected virtual void OnMarkerAdded (ulong position, GES.Marker marker)
+		{
+			InternalMarkerAdded (position, marker);
+		}
+
+		private void InternalMarkerAdded (ulong position, GES.Marker marker)
+		{
+			GLib.Value ret = GLib.Value.Empty;
+			GLib.ValueArray inst_and_params = new GLib.ValueArray (3);
+			GLib.Value[] vals = new GLib.Value [3];
+			vals [0] = new GLib.Value (this);
+			inst_and_params.Append (vals [0]);
+			vals [1] = new GLib.Value (position);
+			inst_and_params.Append (vals [1]);
+			vals [2] = new GLib.Value (marker);
+			inst_and_params.Append (vals [2]);
+			g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
+			foreach (GLib.Value v in vals)
+				v.Dispose ();
+		}
+
+		static MarkerMovedNativeDelegate MarkerMoved_cb_delegate;
+		static MarkerMovedNativeDelegate MarkerMovedVMCallback {
+			get {
+				if (MarkerMoved_cb_delegate == null)
+					MarkerMoved_cb_delegate = new MarkerMovedNativeDelegate (MarkerMoved_cb);
+				return MarkerMoved_cb_delegate;
+			}
+		}
+
+		static void OverrideMarkerMoved (GLib.GType gtype)
+		{
+			OverrideMarkerMoved (gtype, MarkerMovedVMCallback);
+		}
+
+		static void OverrideMarkerMoved (GLib.GType gtype, MarkerMovedNativeDelegate callback)
+		{
+			OverrideVirtualMethod (gtype, "marker-moved", callback);
+		}
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void MarkerMovedNativeDelegate (IntPtr inst, ulong previous_position, ulong new_position, IntPtr marker);
+
+		static void MarkerMoved_cb (IntPtr inst, ulong previous_position, ulong new_position, IntPtr marker)
+		{
+			try {
+				MarkerList __obj = GLib.Object.GetObject (inst, false) as MarkerList;
+				__obj.OnMarkerMoved (previous_position, new_position, GLib.Object.GetObject(marker) as GES.Marker);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(GES.MarkerList), ConnectionMethod="OverrideMarkerMoved")]
+		protected virtual void OnMarkerMoved (ulong previous_position, ulong new_position, GES.Marker marker)
+		{
+			InternalMarkerMoved (previous_position, new_position, marker);
+		}
+
+		private void InternalMarkerMoved (ulong previous_position, ulong new_position, GES.Marker marker)
+		{
+			GLib.Value ret = GLib.Value.Empty;
+			GLib.ValueArray inst_and_params = new GLib.ValueArray (4);
+			GLib.Value[] vals = new GLib.Value [4];
+			vals [0] = new GLib.Value (this);
+			inst_and_params.Append (vals [0]);
+			vals [1] = new GLib.Value (previous_position);
+			inst_and_params.Append (vals [1]);
+			vals [2] = new GLib.Value (new_position);
+			inst_and_params.Append (vals [2]);
+			vals [3] = new GLib.Value (marker);
+			inst_and_params.Append (vals [3]);
+			g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
+			foreach (GLib.Value v in vals)
+				v.Dispose ();
+		}
+
+		static MarkerRemovedNativeDelegate MarkerRemoved_cb_delegate;
+		static MarkerRemovedNativeDelegate MarkerRemovedVMCallback {
+			get {
+				if (MarkerRemoved_cb_delegate == null)
+					MarkerRemoved_cb_delegate = new MarkerRemovedNativeDelegate (MarkerRemoved_cb);
+				return MarkerRemoved_cb_delegate;
+			}
+		}
+
+		static void OverrideMarkerRemoved (GLib.GType gtype)
+		{
+			OverrideMarkerRemoved (gtype, MarkerRemovedVMCallback);
+		}
+
+		static void OverrideMarkerRemoved (GLib.GType gtype, MarkerRemovedNativeDelegate callback)
+		{
+			OverrideVirtualMethod (gtype, "marker-removed", callback);
+		}
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void MarkerRemovedNativeDelegate (IntPtr inst, IntPtr marker);
+
+		static void MarkerRemoved_cb (IntPtr inst, IntPtr marker)
+		{
+			try {
+				MarkerList __obj = GLib.Object.GetObject (inst, false) as MarkerList;
+				__obj.OnMarkerRemoved (GLib.Object.GetObject(marker) as GES.Marker);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(GES.MarkerList), ConnectionMethod="OverrideMarkerRemoved")]
+		protected virtual void OnMarkerRemoved (GES.Marker marker)
+		{
+			InternalMarkerRemoved (marker);
+		}
+
+		private void InternalMarkerRemoved (GES.Marker marker)
+		{
+			GLib.Value ret = GLib.Value.Empty;
+			GLib.ValueArray inst_and_params = new GLib.ValueArray (2);
+			GLib.Value[] vals = new GLib.Value [2];
+			vals [0] = new GLib.Value (this);
+			inst_and_params.Append (vals [0]);
+			vals [1] = new GLib.Value (marker);
+			inst_and_params.Append (vals [1]);
+			g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
+			foreach (GLib.Value v in vals)
+				v.Dispose ();
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (GLib.Object.class_abi.Fields);
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_marker_list_get_type();
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = ges_marker_list_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_marker_list_add(IntPtr raw, ulong position);
+
+		public GES.Marker Add(ulong position) {
+			IntPtr raw_ret = ges_marker_list_add(Handle, position);
+			GES.Marker ret = GLib.Object.GetObject(raw_ret) as GES.Marker;
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_marker_list_get_markers(IntPtr raw);
+
+		public GES.Marker[] Markers { 
+			get {
+				IntPtr raw_ret = ges_marker_list_get_markers(Handle);
+				GES.Marker[] ret = (GES.Marker[]) GLib.Marshaller.ListPtrToArray (raw_ret, typeof(GLib.List), true, true, typeof(GES.Marker));
+				return ret;
+			}
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_marker_list_move(IntPtr raw, IntPtr marker, ulong position);
+
+		public bool Move(GES.Marker marker, ulong position) {
+			bool raw_ret = ges_marker_list_move(Handle, marker == null ? IntPtr.Zero : marker.Handle, position);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_marker_list_remove(IntPtr raw, IntPtr marker);
+
+		public bool Remove(GES.Marker marker) {
+			bool raw_ret = ges_marker_list_remove(Handle, marker == null ? IntPtr.Zero : marker.Handle);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern uint ges_marker_list_size(IntPtr raw);
+
+		public uint Size() {
+			uint raw_ret = ges_marker_list_size(Handle);
+			uint ret = raw_ret;
+			return ret;
+		}
+
+
+		static MarkerList ()
+		{
+			GtkSharp.GstEditingServices.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (GLib.Object.abi_info.Fields);
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

ges/generated/GES/MarkerMovedHandler.cs

@@ -0,0 +1,30 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+
+	public delegate void MarkerMovedHandler(object o, MarkerMovedArgs args);
+
+	public class MarkerMovedArgs : GLib.SignalArgs {
+		public ulong PreviousPosition{
+			get {
+				return (ulong) Args [0];
+			}
+		}
+
+		public ulong NewPosition{
+			get {
+				return (ulong) Args [1];
+			}
+		}
+
+		public GES.Marker Marker{
+			get {
+				return (GES.Marker) Args [2];
+			}
+		}
+
+	}
+}

ges/generated/GES/MarkerRemovedHandler.cs

@@ -0,0 +1,18 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+
+	public delegate void MarkerRemovedHandler(object o, MarkerRemovedArgs args);
+
+	public class MarkerRemovedArgs : GLib.SignalArgs {
+		public GES.Marker Marker{
+			get {
+				return (GES.Marker) Args [0];
+			}
+		}
+
+	}
+}

ges/generated/GES/MetaContainerAdapter.cs

@@ -0,0 +1,537 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class MetaContainerAdapter : GLib.GInterfaceAdapter, GES.IMetaContainer {
+
+		[StructLayout (LayoutKind.Sequential)]
+		struct GESMetaContainerInterface {
+			[MarshalAs (UnmanagedType.ByValArray, SizeConst=4)]
+			public IntPtr[] _gesGesReserved;
+		}
+
+		static GESMetaContainerInterface iface;
+
+		static MetaContainerAdapter ()
+		{
+			GLib.GType.Register (_gtype, typeof (MetaContainerAdapter));
+		}
+
+		static void Initialize (IntPtr ptr, IntPtr data)
+		{
+		}
+
+		GLib.Object implementor;
+
+		public MetaContainerAdapter ()
+		{
+			InitHandler = new GLib.GInterfaceInitHandler (Initialize);
+		}
+
+		public MetaContainerAdapter (IMetaContainerImplementor implementor)
+		{
+			if (implementor == null)
+				throw new ArgumentNullException ("implementor");
+			else if (!(implementor is GLib.Object))
+				throw new ArgumentException ("implementor must be a subclass of GLib.Object");
+			this.implementor = implementor as GLib.Object;
+		}
+
+		public MetaContainerAdapter (IntPtr handle)
+		{
+			if (!_gtype.IsInstance (handle))
+				throw new ArgumentException ("The gobject doesn't implement the GInterface of this adapter", "handle");
+			implementor = GLib.Object.GetObject (handle);
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_meta_container_get_type();
+
+		private static GLib.GType _gtype = new GLib.GType (ges_meta_container_get_type ());
+
+		public static GLib.GType GType {
+			get {
+				return _gtype;
+			}
+		}
+
+		public override GLib.GType GInterfaceGType {
+			get {
+				return _gtype;
+			}
+		}
+
+		public override IntPtr Handle {
+			get {
+				return implementor.Handle;
+			}
+		}
+
+		public IntPtr OwnedHandle {
+			get {
+				return implementor.OwnedHandle;
+			}
+		}
+
+		public static IMetaContainer GetObject (IntPtr handle, bool owned)
+		{
+			GLib.Object obj = GLib.Object.GetObject (handle, owned);
+			return GetObject (obj);
+		}
+
+		public static IMetaContainer GetObject (GLib.Object obj)
+		{
+			if (obj == null)
+				return null;
+			else if (obj is IMetaContainerImplementor)
+				return new MetaContainerAdapter (obj as IMetaContainerImplementor);
+			else if (obj as IMetaContainer == null)
+				return new MetaContainerAdapter (obj.Handle);
+			else
+				return obj as IMetaContainer;
+		}
+
+		public IMetaContainerImplementor Implementor {
+			get {
+				return implementor as IMetaContainerImplementor;
+			}
+		}
+
+		[GLib.Signal("notify-meta")]
+		public event GES.NotifyMetaHandler NotifyMeta {
+			add {
+				GLib.Object.GetObject (Handle).AddSignalHandler ("notify-meta", value, typeof (GES.NotifyMetaArgs));
+			}
+			remove {
+				GLib.Object.GetObject (Handle).RemoveSignalHandler ("notify-meta", value);
+			}
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_add_metas_from_string(IntPtr raw, IntPtr str);
+
+		public bool AddMetasFromString(string str) {
+			IntPtr native_str = GLib.Marshaller.StringToPtrGStrdup (str);
+			bool raw_ret = ges_meta_container_add_metas_from_string(Handle, native_str);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_str);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_check_meta_registered(IntPtr raw, IntPtr meta_item, out int flags, out IntPtr type);
+
+		public bool CheckMetaRegistered(string meta_item, out GES.MetaFlag flags, out GLib.GType type) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			int native_flags;
+			IntPtr native_type;
+			bool raw_ret = ges_meta_container_check_meta_registered(Handle, native_meta_item, out native_flags, out native_type);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			flags = (GES.MetaFlag) native_flags;
+			type = new GLib.GType(native_type);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern void ges_meta_container_foreach(IntPtr raw, GESSharp.MetaForeachFuncNative func, IntPtr user_data);
+
+		public void Foreach(GES.MetaForeachFunc func) {
+			GESSharp.MetaForeachFuncWrapper func_wrapper = new GESSharp.MetaForeachFuncWrapper (func);
+			ges_meta_container_foreach(Handle, func_wrapper.NativeDelegate, IntPtr.Zero);
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_get_boolean(IntPtr raw, IntPtr meta_item, out bool dest);
+
+		public bool GetBoolean(string meta_item, out bool dest) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_get_boolean(Handle, native_meta_item, out dest);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_get_date_time(IntPtr raw, IntPtr meta_item, out IntPtr dest);
+
+		public bool GetDateTime(string meta_item, out Gst.DateTime dest) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			IntPtr native_dest;
+			bool raw_ret = ges_meta_container_get_date_time(Handle, native_meta_item, out native_dest);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			dest = native_dest == IntPtr.Zero ? null : (Gst.DateTime) GLib.Opaque.GetOpaque (native_dest, typeof (Gst.DateTime), true);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_get_double(IntPtr raw, IntPtr meta_item, out double dest);
+
+		public bool GetDouble(string meta_item, out double dest) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_get_double(Handle, native_meta_item, out dest);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_get_float(IntPtr raw, IntPtr meta_item, out float dest);
+
+		public bool GetFloat(string meta_item, out float dest) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_get_float(Handle, native_meta_item, out dest);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_get_int(IntPtr raw, IntPtr meta_item, out int dest);
+
+		public bool GetInt(string meta_item, out int dest) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_get_int(Handle, native_meta_item, out dest);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_get_int64(IntPtr raw, IntPtr meta_item, out long dest);
+
+		public bool GetInt64(string meta_item, out long dest) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_get_int64(Handle, native_meta_item, out dest);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_meta_container_get_marker_list(IntPtr raw, IntPtr key);
+
+		public GES.MarkerList GetMarkerList(string key) {
+			IntPtr native_key = GLib.Marshaller.StringToPtrGStrdup (key);
+			IntPtr raw_ret = ges_meta_container_get_marker_list(Handle, native_key);
+			GES.MarkerList ret = GLib.Object.GetObject(raw_ret, true) as GES.MarkerList;
+			GLib.Marshaller.Free (native_key);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_meta_container_get_meta(IntPtr raw, IntPtr key);
+
+		public GLib.Value GetMeta(string key) {
+			IntPtr native_key = GLib.Marshaller.StringToPtrGStrdup (key);
+			IntPtr raw_ret = ges_meta_container_get_meta(Handle, native_key);
+			GLib.Value ret = (GLib.Value) Marshal.PtrToStructure (raw_ret, typeof (GLib.Value));
+			GLib.Marshaller.Free (native_key);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_meta_container_get_string(IntPtr raw, IntPtr meta_item);
+
+		public string GetString(string meta_item) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			IntPtr raw_ret = ges_meta_container_get_string(Handle, native_meta_item);
+			string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_get_uint(IntPtr raw, IntPtr meta_item, out uint dest);
+
+		public bool GetUint(string meta_item, out uint dest) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_get_uint(Handle, native_meta_item, out dest);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_get_uint64(IntPtr raw, IntPtr meta_item, out ulong dest);
+
+		public bool GetUint64(string meta_item, out ulong dest) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_get_uint64(Handle, native_meta_item, out dest);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_meta_container_metas_to_string(IntPtr raw);
+
+		public string MetasToString() {
+			IntPtr raw_ret = ges_meta_container_metas_to_string(Handle);
+			string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_register_meta(IntPtr raw, int flags, IntPtr meta_item, IntPtr value);
+
+		public bool RegisterMeta(GES.MetaFlag flags, string meta_item, GLib.Value value) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			IntPtr native_value = GLib.Marshaller.StructureToPtrAlloc (value);
+			bool raw_ret = ges_meta_container_register_meta(Handle, (int) flags, native_meta_item, native_value);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			Marshal.FreeHGlobal (native_value);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_register_meta_boolean(IntPtr raw, int flags, IntPtr meta_item, bool value);
+
+		public bool RegisterMetaBoolean(GES.MetaFlag flags, string meta_item, bool value) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_register_meta_boolean(Handle, (int) flags, native_meta_item, value);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_register_meta_date_time(IntPtr raw, int flags, IntPtr meta_item, IntPtr value);
+
+		public bool RegisterMetaDateTime(GES.MetaFlag flags, string meta_item, Gst.DateTime value) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_register_meta_date_time(Handle, (int) flags, native_meta_item, value == null ? IntPtr.Zero : value.Handle);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_register_meta_double(IntPtr raw, int flags, IntPtr meta_item, double value);
+
+		public bool RegisterMetaDouble(GES.MetaFlag flags, string meta_item, double value) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_register_meta_double(Handle, (int) flags, native_meta_item, value);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_register_meta_float(IntPtr raw, int flags, IntPtr meta_item, float value);
+
+		public bool RegisterMetaFloat(GES.MetaFlag flags, string meta_item, float value) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_register_meta_float(Handle, (int) flags, native_meta_item, value);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_register_meta_int(IntPtr raw, int flags, IntPtr meta_item, int value);
+
+		public bool RegisterMetaInt(GES.MetaFlag flags, string meta_item, int value) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_register_meta_int(Handle, (int) flags, native_meta_item, value);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_register_meta_int64(IntPtr raw, int flags, IntPtr meta_item, long value);
+
+		public bool RegisterMetaInt64(GES.MetaFlag flags, string meta_item, long value) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_register_meta_int64(Handle, (int) flags, native_meta_item, value);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_register_meta_string(IntPtr raw, int flags, IntPtr meta_item, IntPtr value);
+
+		public bool RegisterMetaString(GES.MetaFlag flags, string meta_item, string value) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
+			bool raw_ret = ges_meta_container_register_meta_string(Handle, (int) flags, native_meta_item, native_value);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			GLib.Marshaller.Free (native_value);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_register_meta_uint(IntPtr raw, int flags, IntPtr meta_item, uint value);
+
+		public bool RegisterMetaUint(GES.MetaFlag flags, string meta_item, uint value) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_register_meta_uint(Handle, (int) flags, native_meta_item, value);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_register_meta_uint64(IntPtr raw, int flags, IntPtr meta_item, ulong value);
+
+		public bool RegisterMetaUint64(GES.MetaFlag flags, string meta_item, ulong value) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_register_meta_uint64(Handle, (int) flags, native_meta_item, value);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_register_static_meta(IntPtr raw, int flags, IntPtr meta_item, IntPtr type);
+
+		public bool RegisterStaticMeta(GES.MetaFlag flags, string meta_item, GLib.GType type) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_register_static_meta(Handle, (int) flags, native_meta_item, type.Val);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_set_boolean(IntPtr raw, IntPtr meta_item, bool value);
+
+		public bool SetBoolean(string meta_item, bool value) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_set_boolean(Handle, native_meta_item, value);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_set_date_time(IntPtr raw, IntPtr meta_item, IntPtr value);
+
+		public bool SetDateTime(string meta_item, Gst.DateTime value) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_set_date_time(Handle, native_meta_item, value == null ? IntPtr.Zero : value.Handle);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_set_double(IntPtr raw, IntPtr meta_item, double value);
+
+		public bool SetDouble(string meta_item, double value) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_set_double(Handle, native_meta_item, value);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_set_float(IntPtr raw, IntPtr meta_item, float value);
+
+		public bool SetFloat(string meta_item, float value) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_set_float(Handle, native_meta_item, value);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_set_int(IntPtr raw, IntPtr meta_item, int value);
+
+		public bool SetInt(string meta_item, int value) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_set_int(Handle, native_meta_item, value);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_set_int64(IntPtr raw, IntPtr meta_item, long value);
+
+		public bool SetInt64(string meta_item, long value) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_set_int64(Handle, native_meta_item, value);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_set_marker_list(IntPtr raw, IntPtr meta_item, IntPtr list);
+
+		public bool SetMarkerList(string meta_item, GES.MarkerList list) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_set_marker_list(Handle, native_meta_item, list == null ? IntPtr.Zero : list.Handle);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_set_meta(IntPtr raw, IntPtr meta_item, IntPtr value);
+
+		public bool SetMeta(string meta_item, GLib.Value value) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			IntPtr native_value = GLib.Marshaller.StructureToPtrAlloc (value);
+			bool raw_ret = ges_meta_container_set_meta(Handle, native_meta_item, native_value);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			Marshal.FreeHGlobal (native_value);
+			return ret;
+		}
+
+		public bool SetMeta(string meta_item) {
+			return SetMeta (meta_item, GLib.Value.Empty);
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_set_string(IntPtr raw, IntPtr meta_item, IntPtr value);
+
+		public bool SetString(string meta_item, string value) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
+			bool raw_ret = ges_meta_container_set_string(Handle, native_meta_item, native_value);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			GLib.Marshaller.Free (native_value);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_set_uint(IntPtr raw, IntPtr meta_item, uint value);
+
+		public bool SetUint(string meta_item, uint value) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_set_uint(Handle, native_meta_item, value);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_meta_container_set_uint64(IntPtr raw, IntPtr meta_item, ulong value);
+
+		public bool SetUint64(string meta_item, ulong value) {
+			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
+			bool raw_ret = ges_meta_container_set_uint64(Handle, native_meta_item, value);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_meta_item);
+			return ret;
+		}
+
+#endregion
+	}
+}

ges/generated/GES/MetaFlag.cs

@@ -0,0 +1,30 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[Flags]
+	[GLib.GType (typeof (GES.MetaFlagGType))]
+	public enum MetaFlag : uint {
+
+		Readable = 1,
+		Writable = 2,
+		Readwrite = 3,
+	}
+
+	internal class MetaFlagGType {
+		[DllImport ("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_meta_flag_get_type ();
+
+		public static GLib.GType GType {
+			get {
+				return new GLib.GType (ges_meta_flag_get_type ());
+			}
+		}
+	}
+#endregion
+}

ges/generated/GES/MetaForeachFunc.cs

@@ -0,0 +1,10 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+
+	public delegate void MetaForeachFunc(GES.IMetaContainer container, string key, GLib.Value value);
+
+}

ges/generated/GES/MultiFileSource.cs

@@ -0,0 +1,127 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[Obsolete]
+	public partial class MultiFileSource : GES.VideoSource {
+
+		public MultiFileSource (IntPtr raw) : base(raw) {}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_multi_file_source_new(IntPtr uri);
+
+		public MultiFileSource (string uri) : base (IntPtr.Zero)
+		{
+			if (GetType () != typeof (MultiFileSource)) {
+				var vals = new List<GLib.Value> ();
+				var names = new List<string> ();
+				names.Add ("uri");
+				vals.Add (new GLib.Value (uri));
+				CreateNativeObject (names.ToArray (), vals.ToArray ());
+				return;
+			}
+			IntPtr native_uri = GLib.Marshaller.StringToPtrGStrdup (uri);
+			Raw = ges_multi_file_source_new(native_uri);
+			GLib.Marshaller.Free (native_uri);
+		}
+
+		[GLib.Property ("uri")]
+		public string Uri {
+			get {
+				GLib.Value val = GetProperty ("uri");
+				string ret = (string) val;
+				val.Dispose ();
+				return ret;
+			}
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("_ges_reserved"
+							, GES.VideoSource.class_abi.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _ges_reserved
+							, null
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_multi_file_source_get_type();
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = ges_multi_file_source_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+
+		static MultiFileSource ()
+		{
+			GtkSharp.GstEditingServices.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("uri"
+							, GES.VideoSource.abi_info.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // uri
+							, null
+							, "priv"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("priv"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // priv
+							, "uri"
+							, "_ges_reserved"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("_ges_reserved"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _ges_reserved
+							, "priv"
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

ges/generated/GES/NotifyMetaHandler.cs

@@ -0,0 +1,24 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+
+	public delegate void NotifyMetaHandler(object o, NotifyMetaArgs args);
+
+	public class NotifyMetaArgs : GLib.SignalArgs {
+		public string Key{
+			get {
+				return (string) Args [0];
+			}
+		}
+
+		public GLib.Value Value{
+			get {
+				return (GLib.Value) Args [1];
+			}
+		}
+
+	}
+}

ges/generated/GES/Operation.cs

@@ -0,0 +1,95 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class Operation : GES.TrackElement {
+
+		protected Operation (IntPtr raw) : base(raw) {}
+
+		protected Operation() : base(IntPtr.Zero)
+		{
+			CreateNativeObject (new string [0], new GLib.Value [0]);
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("_ges_reserved"
+							, GES.TrackElement.class_abi.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _ges_reserved
+							, null
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_operation_get_type();
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = ges_operation_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+
+		static Operation ()
+		{
+			GtkSharp.GstEditingServices.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("priv"
+							, GES.TrackElement.abi_info.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // priv
+							, null
+							, "_ges_reserved"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("_ges_reserved"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _ges_reserved
+							, "priv"
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

ges/generated/GES/OperationClip.cs

@@ -0,0 +1,95 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class OperationClip : GES.Clip {
+
+		protected OperationClip (IntPtr raw) : base(raw) {}
+
+		protected OperationClip() : base(IntPtr.Zero)
+		{
+			CreateNativeObject (new string [0], new GLib.Value [0]);
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("_ges_reserved"
+							, GES.Clip.class_abi.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _ges_reserved
+							, null
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_operation_clip_get_type();
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = ges_operation_clip_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+
+		static OperationClip ()
+		{
+			GtkSharp.GstEditingServices.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("priv"
+							, GES.Clip.abi_info.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // priv
+							, null
+							, "_ges_reserved"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("_ges_reserved"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _ges_reserved
+							, "priv"
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

ges/generated/GES/OverlayClip.cs

@@ -0,0 +1,95 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class OverlayClip : GES.OperationClip {
+
+		protected OverlayClip (IntPtr raw) : base(raw) {}
+
+		protected OverlayClip() : base(IntPtr.Zero)
+		{
+			CreateNativeObject (new string [0], new GLib.Value [0]);
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("_ges_reserved"
+							, GES.OperationClip.class_abi.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _ges_reserved
+							, null
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_overlay_clip_get_type();
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = ges_overlay_clip_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+
+		static OverlayClip ()
+		{
+			GtkSharp.GstEditingServices.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("priv"
+							, GES.OperationClip.abi_info.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // priv
+							, null
+							, "_ges_reserved"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("_ges_reserved"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _ges_reserved
+							, "priv"
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

ges/generated/GES/Pipeline.cs

@@ -0,0 +1,334 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class Pipeline : Gst.Pipeline, Gst.Video.IVideoOverlay {
+
+		public Pipeline (IntPtr raw) : base(raw) {}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_pipeline_new();
+
+		public Pipeline () : base (IntPtr.Zero)
+		{
+			if (GetType () != typeof (Pipeline)) {
+				CreateNativeObject (new string [0], new GLib.Value[0]);
+				return;
+			}
+			Raw = ges_pipeline_new();
+		}
+
+		[GLib.Property ("audio-filter")]
+		public Gst.Element AudioFilter {
+			get {
+				GLib.Value val = GetProperty ("audio-filter");
+				Gst.Element ret = (Gst.Element) val;
+				val.Dispose ();
+				return ret;
+			}
+			set {
+				GLib.Value val = new GLib.Value(value);
+				SetProperty("audio-filter", val);
+				val.Dispose ();
+			}
+		}
+
+		[GLib.Property ("audio-sink")]
+		public Gst.Element AudioSink {
+			get {
+				GLib.Value val = GetProperty ("audio-sink");
+				Gst.Element ret = (Gst.Element) val;
+				val.Dispose ();
+				return ret;
+			}
+			set {
+				GLib.Value val = new GLib.Value(value);
+				SetProperty("audio-sink", val);
+				val.Dispose ();
+			}
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern int ges_pipeline_get_mode(IntPtr raw);
+
+		[GLib.Property ("mode")]
+		public GES.PipelineFlags Mode {
+			get  {
+				int raw_ret = ges_pipeline_get_mode(Handle);
+				GES.PipelineFlags ret = (GES.PipelineFlags) raw_ret;
+				return ret;
+			}
+			set {
+				GLib.Value val = new GLib.Value((Enum) value);
+				SetProperty("mode", val);
+				val.Dispose ();
+			}
+		}
+
+		[GLib.Property ("timeline")]
+		public GES.Timeline Timeline {
+			get {
+				GLib.Value val = GetProperty ("timeline");
+				GES.Timeline ret = (GES.Timeline) val;
+				val.Dispose ();
+				return ret;
+			}
+			set {
+				GLib.Value val = new GLib.Value(value);
+				SetProperty("timeline", val);
+				val.Dispose ();
+			}
+		}
+
+		[GLib.Property ("video-filter")]
+		public Gst.Element VideoFilter {
+			get {
+				GLib.Value val = GetProperty ("video-filter");
+				Gst.Element ret = (Gst.Element) val;
+				val.Dispose ();
+				return ret;
+			}
+			set {
+				GLib.Value val = new GLib.Value(value);
+				SetProperty("video-filter", val);
+				val.Dispose ();
+			}
+		}
+
+		[GLib.Property ("video-sink")]
+		public Gst.Element VideoSink {
+			get {
+				GLib.Value val = GetProperty ("video-sink");
+				Gst.Element ret = (Gst.Element) val;
+				val.Dispose ();
+				return ret;
+			}
+			set {
+				GLib.Value val = new GLib.Value(value);
+				SetProperty("video-sink", val);
+				val.Dispose ();
+			}
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("_ges_reserved"
+							, Gst.Pipeline.class_abi.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _ges_reserved
+							, null
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_pipeline_get_type();
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = ges_pipeline_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_pipeline_get_thumbnail(IntPtr raw, IntPtr caps);
+
+		public Gst.Sample GetThumbnail(Gst.Caps caps) {
+			IntPtr raw_ret = ges_pipeline_get_thumbnail(Handle, caps == null ? IntPtr.Zero : caps.Handle);
+			Gst.Sample ret = raw_ret == IntPtr.Zero ? null : (Gst.Sample) GLib.Opaque.GetOpaque (raw_ret, typeof (Gst.Sample), true);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_pipeline_get_thumbnail_rgb24(IntPtr raw, int width, int height);
+
+		public Gst.Sample GetThumbnailRgb24(int width, int height) {
+			IntPtr raw_ret = ges_pipeline_get_thumbnail_rgb24(Handle, width, height);
+			Gst.Sample ret = raw_ret == IntPtr.Zero ? null : (Gst.Sample) GLib.Opaque.GetOpaque (raw_ret, typeof (Gst.Sample), true);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_pipeline_preview_get_audio_sink(IntPtr raw);
+
+		public Gst.Element PreviewGetAudioSink() {
+			IntPtr raw_ret = ges_pipeline_preview_get_audio_sink(Handle);
+			Gst.Element ret = GLib.Object.GetObject(raw_ret, true) as Gst.Element;
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_pipeline_preview_get_video_sink(IntPtr raw);
+
+		public Gst.Element PreviewGetVideoSink() {
+			IntPtr raw_ret = ges_pipeline_preview_get_video_sink(Handle);
+			Gst.Element ret = GLib.Object.GetObject(raw_ret, true) as Gst.Element;
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern void ges_pipeline_preview_set_audio_sink(IntPtr raw, IntPtr sink);
+
+		public void PreviewSetAudioSink(Gst.Element sink) {
+			ges_pipeline_preview_set_audio_sink(Handle, sink == null ? IntPtr.Zero : sink.Handle);
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern void ges_pipeline_preview_set_video_sink(IntPtr raw, IntPtr sink);
+
+		public void PreviewSetVideoSink(Gst.Element sink) {
+			ges_pipeline_preview_set_video_sink(Handle, sink == null ? IntPtr.Zero : sink.Handle);
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern unsafe bool ges_pipeline_save_thumbnail(IntPtr raw, int width, int height, IntPtr format, IntPtr location, out IntPtr error);
+
+		public unsafe bool SaveThumbnail(int width, int height, string format, string location) {
+			IntPtr native_format = GLib.Marshaller.StringToPtrGStrdup (format);
+			IntPtr native_location = GLib.Marshaller.StringToPtrGStrdup (location);
+			IntPtr error = IntPtr.Zero;
+			bool raw_ret = ges_pipeline_save_thumbnail(Handle, width, height, native_format, native_location, out error);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_format);
+			GLib.Marshaller.Free (native_location);
+			if (error != IntPtr.Zero) throw new GLib.GException (error);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_pipeline_set_mode(IntPtr raw, int mode);
+
+		public bool SetMode(GES.PipelineFlags mode) {
+			bool raw_ret = ges_pipeline_set_mode(Handle, (int) mode);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_pipeline_set_render_settings(IntPtr raw, IntPtr output_uri, IntPtr profile);
+
+		public bool SetRenderSettings(string output_uri, Gst.PbUtils.EncodingProfile profile) {
+			IntPtr native_output_uri = GLib.Marshaller.StringToPtrGStrdup (output_uri);
+			bool raw_ret = ges_pipeline_set_render_settings(Handle, native_output_uri, profile == null ? IntPtr.Zero : profile.Handle);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_output_uri);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_pipeline_set_timeline(IntPtr raw, IntPtr timeline);
+
+		public bool SetTimeline(GES.Timeline timeline) {
+			bool raw_ret = ges_pipeline_set_timeline(Handle, timeline == null ? IntPtr.Zero : timeline.OwnedHandle);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[DllImport("gstvideo-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
+		static extern void gst_video_overlay_expose(IntPtr raw);
+
+		public void Expose() {
+			gst_video_overlay_expose(Handle);
+		}
+
+		[DllImport("gstvideo-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
+		static extern void gst_video_overlay_got_window_handle(IntPtr raw, IntPtr handle);
+
+		public void GotWindowHandle(IntPtr handle) {
+			gst_video_overlay_got_window_handle(Handle, handle);
+		}
+
+		[DllImport("gstvideo-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
+		static extern void gst_video_overlay_handle_events(IntPtr raw, bool handle_events);
+
+		public void HandleEvents(bool handle_events) {
+			gst_video_overlay_handle_events(Handle, handle_events);
+		}
+
+		[DllImport("gstvideo-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
+		static extern void gst_video_overlay_prepare_window_handle(IntPtr raw);
+
+		public void PrepareWindowHandle() {
+			gst_video_overlay_prepare_window_handle(Handle);
+		}
+
+		[DllImport("gstvideo-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool gst_video_overlay_set_render_rectangle(IntPtr raw, int x, int y, int width, int height);
+
+		public bool SetRenderRectangle(int x, int y, int width, int height) {
+			bool raw_ret = gst_video_overlay_set_render_rectangle(Handle, x, y, width, height);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[DllImport("gstvideo-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
+		static extern void gst_video_overlay_set_window_handle(IntPtr raw, IntPtr handle);
+
+		public IntPtr WindowHandle { 
+			set {
+				gst_video_overlay_set_window_handle(Handle, value);
+			}
+		}
+
+
+		static Pipeline ()
+		{
+			GtkSharp.GstEditingServices.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("priv"
+							, Gst.Pipeline.abi_info.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // priv
+							, null
+							, "_ges_reserved"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("_ges_reserved"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _ges_reserved
+							, "priv"
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

ges/generated/GES/PipelineFlags.cs

@@ -0,0 +1,32 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[Flags]
+	[GLib.GType (typeof (GES.PipelineFlagsGType))]
+	public enum PipelineFlags : uint {
+
+		AudioPreview = 1,
+		VideoPreview = 2,
+		FullPreview = 3,
+		Render = 4,
+		SmartRender = 8,
+	}
+
+	internal class PipelineFlagsGType {
+		[DllImport ("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_pipeline_flags_get_type ();
+
+		public static GLib.GType GType {
+			get {
+				return new GLib.GType (ges_pipeline_flags_get_type ());
+			}
+		}
+	}
+#endregion
+}

ges/generated/GES/PitiviFormatter.cs

@@ -0,0 +1,102 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class PitiviFormatter : GES.Formatter {
+
+		public PitiviFormatter (IntPtr raw) : base(raw) {}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_pitivi_formatter_new();
+
+		public PitiviFormatter () : base (IntPtr.Zero)
+		{
+			if (GetType () != typeof (PitiviFormatter)) {
+				CreateNativeObject (new string [0], new GLib.Value[0]);
+				return;
+			}
+			Raw = ges_pitivi_formatter_new();
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("_ges_reserved"
+							, GES.Formatter.class_abi.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _ges_reserved
+							, null
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_pitivi_formatter_get_type();
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = ges_pitivi_formatter_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+
+		static PitiviFormatter ()
+		{
+			GtkSharp.GstEditingServices.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("priv"
+							, GES.Formatter.abi_info.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // priv
+							, null
+							, "_ges_reserved"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("_ges_reserved"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _ges_reserved
+							, "priv"
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

ges/generated/GES/Project.cs

@@ -0,0 +1,625 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class Project : GES.Asset {
+
+		public Project (IntPtr raw) : base(raw) {}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_project_new(IntPtr uri);
+
+		public Project (string uri) : base (IntPtr.Zero)
+		{
+			if (GetType () != typeof (Project)) {
+				var vals = new List<GLib.Value> ();
+				var names = new List<string> ();
+				names.Add ("uri");
+				vals.Add (new GLib.Value (uri));
+				CreateNativeObject (names.ToArray (), vals.ToArray ());
+				return;
+			}
+			IntPtr native_uri = GLib.Marshaller.StringToPtrGStrdup (uri);
+			Raw = ges_project_new(native_uri);
+			GLib.Marshaller.Free (native_uri);
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_project_get_uri(IntPtr raw);
+
+		[GLib.Property ("uri")]
+		public string Uri {
+			get  {
+				IntPtr raw_ret = ges_project_get_uri(Handle);
+				string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
+				return ret;
+			}
+		}
+
+		[GLib.Signal("loaded")]
+		public event GES.LoadedHandler Loaded {
+			add {
+				this.AddSignalHandler ("loaded", value, typeof (GES.LoadedArgs));
+			}
+			remove {
+				this.RemoveSignalHandler ("loaded", value);
+			}
+		}
+
+		[GLib.Signal("asset-added")]
+		public event GES.AssetAddedHandler AssetAdded {
+			add {
+				this.AddSignalHandler ("asset-added", value, typeof (GES.AssetAddedArgs));
+			}
+			remove {
+				this.RemoveSignalHandler ("asset-added", value);
+			}
+		}
+
+		[GLib.Signal("asset-removed")]
+		public event GES.AssetRemovedHandler AssetRemoved {
+			add {
+				this.AddSignalHandler ("asset-removed", value, typeof (GES.AssetRemovedArgs));
+			}
+			remove {
+				this.RemoveSignalHandler ("asset-removed", value);
+			}
+		}
+
+		[GLib.Signal("loading")]
+		public event GES.LoadingHandler Loading {
+			add {
+				this.AddSignalHandler ("loading", value, typeof (GES.LoadingArgs));
+			}
+			remove {
+				this.RemoveSignalHandler ("loading", value);
+			}
+		}
+
+		[GLib.Signal("asset-loading")]
+		public event GES.AssetLoadingHandler AssetLoading {
+			add {
+				this.AddSignalHandler ("asset-loading", value, typeof (GES.AssetLoadingArgs));
+			}
+			remove {
+				this.RemoveSignalHandler ("asset-loading", value);
+			}
+		}
+
+		static AssetAddedNativeDelegate AssetAdded_cb_delegate;
+		static AssetAddedNativeDelegate AssetAddedVMCallback {
+			get {
+				if (AssetAdded_cb_delegate == null)
+					AssetAdded_cb_delegate = new AssetAddedNativeDelegate (AssetAdded_cb);
+				return AssetAdded_cb_delegate;
+			}
+		}
+
+		static void OverrideAssetAdded (GLib.GType gtype)
+		{
+			OverrideAssetAdded (gtype, AssetAddedVMCallback);
+		}
+
+		static void OverrideAssetAdded (GLib.GType gtype, AssetAddedNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("asset_added"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void AssetAddedNativeDelegate (IntPtr inst, IntPtr asset);
+
+		static void AssetAdded_cb (IntPtr inst, IntPtr asset)
+		{
+			try {
+				Project __obj = GLib.Object.GetObject (inst, false) as Project;
+				__obj.OnAssetAdded (GLib.Object.GetObject(asset) as GES.Asset);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(GES.Project), ConnectionMethod="OverrideAssetAdded")]
+		protected virtual void OnAssetAdded (GES.Asset asset)
+		{
+			InternalAssetAdded (asset);
+		}
+
+		private void InternalAssetAdded (GES.Asset asset)
+		{
+			AssetAddedNativeDelegate unmanaged = null;
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("asset_added"));
+				unmanaged = (AssetAddedNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(AssetAddedNativeDelegate));
+			}
+			if (unmanaged == null) return;
+
+			unmanaged (this.Handle, asset == null ? IntPtr.Zero : asset.Handle);
+		}
+
+		static AssetLoadingNativeDelegate AssetLoading_cb_delegate;
+		static AssetLoadingNativeDelegate AssetLoadingVMCallback {
+			get {
+				if (AssetLoading_cb_delegate == null)
+					AssetLoading_cb_delegate = new AssetLoadingNativeDelegate (AssetLoading_cb);
+				return AssetLoading_cb_delegate;
+			}
+		}
+
+		static void OverrideAssetLoading (GLib.GType gtype)
+		{
+			OverrideAssetLoading (gtype, AssetLoadingVMCallback);
+		}
+
+		static void OverrideAssetLoading (GLib.GType gtype, AssetLoadingNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("asset_loading"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void AssetLoadingNativeDelegate (IntPtr inst, IntPtr asset);
+
+		static void AssetLoading_cb (IntPtr inst, IntPtr asset)
+		{
+			try {
+				Project __obj = GLib.Object.GetObject (inst, false) as Project;
+				__obj.OnAssetLoading (GLib.Object.GetObject(asset) as GES.Asset);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(GES.Project), ConnectionMethod="OverrideAssetLoading")]
+		protected virtual void OnAssetLoading (GES.Asset asset)
+		{
+			InternalAssetLoading (asset);
+		}
+
+		private void InternalAssetLoading (GES.Asset asset)
+		{
+			AssetLoadingNativeDelegate unmanaged = null;
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("asset_loading"));
+				unmanaged = (AssetLoadingNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(AssetLoadingNativeDelegate));
+			}
+			if (unmanaged == null) return;
+
+			unmanaged (this.Handle, asset == null ? IntPtr.Zero : asset.Handle);
+		}
+
+		static AssetRemovedNativeDelegate AssetRemoved_cb_delegate;
+		static AssetRemovedNativeDelegate AssetRemovedVMCallback {
+			get {
+				if (AssetRemoved_cb_delegate == null)
+					AssetRemoved_cb_delegate = new AssetRemovedNativeDelegate (AssetRemoved_cb);
+				return AssetRemoved_cb_delegate;
+			}
+		}
+
+		static void OverrideAssetRemoved (GLib.GType gtype)
+		{
+			OverrideAssetRemoved (gtype, AssetRemovedVMCallback);
+		}
+
+		static void OverrideAssetRemoved (GLib.GType gtype, AssetRemovedNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("asset_removed"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void AssetRemovedNativeDelegate (IntPtr inst, IntPtr asset);
+
+		static void AssetRemoved_cb (IntPtr inst, IntPtr asset)
+		{
+			try {
+				Project __obj = GLib.Object.GetObject (inst, false) as Project;
+				__obj.OnAssetRemoved (GLib.Object.GetObject(asset) as GES.Asset);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(GES.Project), ConnectionMethod="OverrideAssetRemoved")]
+		protected virtual void OnAssetRemoved (GES.Asset asset)
+		{
+			InternalAssetRemoved (asset);
+		}
+
+		private void InternalAssetRemoved (GES.Asset asset)
+		{
+			AssetRemovedNativeDelegate unmanaged = null;
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("asset_removed"));
+				unmanaged = (AssetRemovedNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(AssetRemovedNativeDelegate));
+			}
+			if (unmanaged == null) return;
+
+			unmanaged (this.Handle, asset == null ? IntPtr.Zero : asset.Handle);
+		}
+
+		static LoadedNativeDelegate Loaded_cb_delegate;
+		static LoadedNativeDelegate LoadedVMCallback {
+			get {
+				if (Loaded_cb_delegate == null)
+					Loaded_cb_delegate = new LoadedNativeDelegate (Loaded_cb);
+				return Loaded_cb_delegate;
+			}
+		}
+
+		static void OverrideLoaded (GLib.GType gtype)
+		{
+			OverrideLoaded (gtype, LoadedVMCallback);
+		}
+
+		static void OverrideLoaded (GLib.GType gtype, LoadedNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("loaded"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void LoadedNativeDelegate (IntPtr inst, IntPtr timeline);
+
+		static void Loaded_cb (IntPtr inst, IntPtr timeline)
+		{
+			try {
+				Project __obj = GLib.Object.GetObject (inst, false) as Project;
+				__obj.OnLoaded (GLib.Object.GetObject(timeline) as GES.Timeline);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(GES.Project), ConnectionMethod="OverrideLoaded")]
+		protected virtual void OnLoaded (GES.Timeline timeline)
+		{
+			InternalLoaded (timeline);
+		}
+
+		private void InternalLoaded (GES.Timeline timeline)
+		{
+			LoadedNativeDelegate unmanaged = null;
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("loaded"));
+				unmanaged = (LoadedNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(LoadedNativeDelegate));
+			}
+			if (unmanaged == null) return;
+
+			unmanaged (this.Handle, timeline == null ? IntPtr.Zero : timeline.Handle);
+		}
+
+		static LoadingNativeDelegate Loading_cb_delegate;
+		static LoadingNativeDelegate LoadingVMCallback {
+			get {
+				if (Loading_cb_delegate == null)
+					Loading_cb_delegate = new LoadingNativeDelegate (Loading_cb);
+				return Loading_cb_delegate;
+			}
+		}
+
+		static void OverrideLoading (GLib.GType gtype)
+		{
+			OverrideLoading (gtype, LoadingVMCallback);
+		}
+
+		static void OverrideLoading (GLib.GType gtype, LoadingNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("loading"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void LoadingNativeDelegate (IntPtr inst, IntPtr timeline);
+
+		static void Loading_cb (IntPtr inst, IntPtr timeline)
+		{
+			try {
+				Project __obj = GLib.Object.GetObject (inst, false) as Project;
+				__obj.OnLoading (GLib.Object.GetObject(timeline) as GES.Timeline);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(GES.Project), ConnectionMethod="OverrideLoading")]
+		protected virtual void OnLoading (GES.Timeline timeline)
+		{
+			InternalLoading (timeline);
+		}
+
+		private void InternalLoading (GES.Timeline timeline)
+		{
+			LoadingNativeDelegate unmanaged = null;
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("loading"));
+				unmanaged = (LoadingNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(LoadingNativeDelegate));
+			}
+			if (unmanaged == null) return;
+
+			unmanaged (this.Handle, timeline == null ? IntPtr.Zero : timeline.Handle);
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("asset_added"
+							, GES.Asset.class_abi.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // asset_added
+							, null
+							, "asset_loading"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("asset_loading"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // asset_loading
+							, "asset_added"
+							, "asset_removed"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("asset_removed"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // asset_removed
+							, "asset_loading"
+							, "missing_uri"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("missing_uri"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // missing_uri
+							, "asset_removed"
+							, "loading_error"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("loading_error"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // loading_error
+							, "missing_uri"
+							, "loaded"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("loaded"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // loaded
+							, "loading_error"
+							, "loading"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("loading"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // loading
+							, "loaded"
+							, "_ges_reserved"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("_ges_reserved"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 3 // _ges_reserved
+							, "loading"
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_project_get_type();
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = ges_project_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_project_add_asset(IntPtr raw, IntPtr asset);
+
+		public bool AddAsset(GES.Asset asset) {
+			bool raw_ret = ges_project_add_asset(Handle, asset == null ? IntPtr.Zero : asset.Handle);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_project_add_encoding_profile(IntPtr raw, IntPtr profile);
+
+		public bool AddEncodingProfile(Gst.PbUtils.EncodingProfile profile) {
+			bool raw_ret = ges_project_add_encoding_profile(Handle, profile == null ? IntPtr.Zero : profile.Handle);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern void ges_project_add_formatter(IntPtr raw, IntPtr formatter);
+
+		public void AddFormatter(GES.Formatter formatter) {
+			ges_project_add_formatter(Handle, formatter == null ? IntPtr.Zero : formatter.Handle);
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_project_create_asset(IntPtr raw, IntPtr id, IntPtr extractable_type);
+
+		public bool CreateAsset(string id, GLib.GType extractable_type) {
+			IntPtr native_id = GLib.Marshaller.StringToPtrGStrdup (id);
+			bool raw_ret = ges_project_create_asset(Handle, native_id, extractable_type.Val);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_id);
+			return ret;
+		}
+
+		public bool CreateAsset(GLib.GType extractable_type) {
+			return CreateAsset (null, extractable_type);
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern unsafe IntPtr ges_project_create_asset_sync(IntPtr raw, IntPtr id, IntPtr extractable_type, out IntPtr error);
+
+		public unsafe GES.Asset CreateAssetSync(string id, GLib.GType extractable_type) {
+			IntPtr native_id = GLib.Marshaller.StringToPtrGStrdup (id);
+			IntPtr error = IntPtr.Zero;
+			IntPtr raw_ret = ges_project_create_asset_sync(Handle, native_id, extractable_type.Val, out error);
+			GES.Asset ret = GLib.Object.GetObject(raw_ret, true) as GES.Asset;
+			GLib.Marshaller.Free (native_id);
+			if (error != IntPtr.Zero) throw new GLib.GException (error);
+			return ret;
+		}
+
+		public GES.Asset CreateAssetSync(GLib.GType extractable_type) {
+			return CreateAssetSync (null, extractable_type);
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_project_get_asset(IntPtr raw, IntPtr id, IntPtr extractable_type);
+
+		public GES.Asset GetAsset(string id, GLib.GType extractable_type) {
+			IntPtr native_id = GLib.Marshaller.StringToPtrGStrdup (id);
+			IntPtr raw_ret = ges_project_get_asset(Handle, native_id, extractable_type.Val);
+			GES.Asset ret = GLib.Object.GetObject(raw_ret, true) as GES.Asset;
+			GLib.Marshaller.Free (native_id);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_project_get_loading_assets(IntPtr raw);
+
+		public GES.Asset[] LoadingAssets { 
+			get {
+				IntPtr raw_ret = ges_project_get_loading_assets(Handle);
+				GES.Asset[] ret = (GES.Asset[]) GLib.Marshaller.ListPtrToArray (raw_ret, typeof(GLib.List), true, true, typeof(GES.Asset));
+				return ret;
+			}
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_project_list_assets(IntPtr raw, IntPtr filter);
+
+		public GES.Asset[] ListAssets(GLib.GType filter) {
+			IntPtr raw_ret = ges_project_list_assets(Handle, filter.Val);
+			GES.Asset[] ret = (GES.Asset[]) GLib.Marshaller.ListPtrToArray (raw_ret, typeof(GLib.List), true, true, typeof(GES.Asset));
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_project_list_encoding_profiles(IntPtr raw);
+
+		public Gst.PbUtils.EncodingProfile[] ListEncodingProfiles() {
+			IntPtr raw_ret = ges_project_list_encoding_profiles(Handle);
+			Gst.PbUtils.EncodingProfile[] ret = (Gst.PbUtils.EncodingProfile[]) GLib.Marshaller.ListPtrToArray (raw_ret, typeof(GLib.List), false, false, typeof(Gst.PbUtils.EncodingProfile));
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern unsafe bool ges_project_load(IntPtr raw, IntPtr timeline, out IntPtr error);
+
+		public unsafe bool Load(GES.Timeline timeline) {
+			IntPtr error = IntPtr.Zero;
+			bool raw_ret = ges_project_load(Handle, timeline == null ? IntPtr.Zero : timeline.Handle, out error);
+			bool ret = raw_ret;
+			if (error != IntPtr.Zero) throw new GLib.GException (error);
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern bool ges_project_remove_asset(IntPtr raw, IntPtr asset);
+
+		public bool RemoveAsset(GES.Asset asset) {
+			bool raw_ret = ges_project_remove_asset(Handle, asset == null ? IntPtr.Zero : asset.Handle);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern unsafe bool ges_project_save(IntPtr raw, IntPtr timeline, IntPtr uri, IntPtr formatter_asset, bool overwrite, out IntPtr error);
+
+		public unsafe bool Save(GES.Timeline timeline, string uri, GES.Asset formatter_asset, bool overwrite) {
+			IntPtr native_uri = GLib.Marshaller.StringToPtrGStrdup (uri);
+			IntPtr error = IntPtr.Zero;
+			bool raw_ret = ges_project_save(Handle, timeline == null ? IntPtr.Zero : timeline.Handle, native_uri, formatter_asset == null ? IntPtr.Zero : formatter_asset.OwnedHandle, overwrite, out error);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_uri);
+			if (error != IntPtr.Zero) throw new GLib.GException (error);
+			return ret;
+		}
+
+		public bool Save(GES.Timeline timeline, string uri, bool overwrite) {
+			return Save (timeline, uri, null, overwrite);
+		}
+
+
+		static Project ()
+		{
+			GtkSharp.GstEditingServices.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("priv"
+							, GES.Asset.abi_info.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // priv
+							, null
+							, "__ges_reserved"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("__ges_reserved"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 20 // __ges_reserved
+							, "priv"
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

ges/generated/GES/SelectElementTrackHandler.cs

@@ -0,0 +1,24 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+
+	public delegate void SelectElementTrackHandler(object o, SelectElementTrackArgs args);
+
+	public class SelectElementTrackArgs : GLib.SignalArgs {
+		public GES.Clip Clip{
+			get {
+				return (GES.Clip) Args [0];
+			}
+		}
+
+		public GES.TrackElement TrackElement{
+			get {
+				return (GES.TrackElement) Args [1];
+			}
+		}
+
+	}
+}

ges/generated/GES/SnappingEndedHandler.cs

@@ -0,0 +1,30 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+
+	public delegate void SnappingEndedHandler(object o, SnappingEndedArgs args);
+
+	public class SnappingEndedArgs : GLib.SignalArgs {
+		public GES.TrackElement Obj1{
+			get {
+				return (GES.TrackElement) Args [0];
+			}
+		}
+
+		public GES.TrackElement Obj2{
+			get {
+				return (GES.TrackElement) Args [1];
+			}
+		}
+
+		public ulong Position{
+			get {
+				return (ulong) Args [2];
+			}
+		}
+
+	}
+}

ges/generated/GES/SnappingStartedHandler.cs

@@ -0,0 +1,30 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+
+	public delegate void SnappingStartedHandler(object o, SnappingStartedArgs args);
+
+	public class SnappingStartedArgs : GLib.SignalArgs {
+		public GES.TrackElement Obj1{
+			get {
+				return (GES.TrackElement) Args [0];
+			}
+		}
+
+		public GES.TrackElement Obj2{
+			get {
+				return (GES.TrackElement) Args [1];
+			}
+		}
+
+		public ulong Position{
+			get {
+				return (ulong) Args [2];
+			}
+		}
+
+	}
+}

ges/generated/GES/Source.cs

@@ -0,0 +1,95 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GES {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class Source : GES.TrackElement {
+
+		public Source (IntPtr raw) : base(raw) {}
+
+		protected Source() : base(IntPtr.Zero)
+		{
+			CreateNativeObject (new string [0], new GLib.Value [0]);
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("_ges_reserved"
+							, GES.TrackElement.class_abi.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _ges_reserved
+							, null
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
+		static extern IntPtr ges_source_get_type();
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = ges_source_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+
+		static Source ()
+		{
+			GtkSharp.GstEditingServices.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("priv"
+							, GES.TrackElement.abi_info.Fields
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) // priv
+							, null
+							, "_ges_reserved"
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+						new GLib.AbiField("_ges_reserved"
+							, -1
+							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _ges_reserved
+							, "priv"
+							, null
+							, (uint) Marshal.SizeOf(typeof(IntPtr))
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}